[u/mrichter/AliRoot.git] / ITS / AliITSTrigger.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                         *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/


/* $Id$ */

#include <TClonesArray.h>

#include "AliLog.h"
#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliTriggerInput.h"

#include "AliITSTrigger.h"
#include "AliITSdigitSPD.h"
#include "AliITSgeom.h"
#include "AliITSLoader.h"

//______________________________________________________________________
ClassImp(AliITSTrigger)
////////////////////////////////////////////////////////////////////////
//                                                                    //
// Version 1                                                          //
// Modified by D. Elia, C. Jorgensen                                  //
// March 2006                                                         //
//                                                                    //
// Version 0                                                          //
// Written by J. Conrad, E. Lopez Torres                              //
// October 2005                                                       //
//                                                                    //
// AliITSTrigger: implementation of the SPD Fast-OR based triggers.   //
//                                                                    //
////////////////////////////////////////////////////////////////////////

//______________________________________________________________________
AliITSTrigger::AliITSTrigger()
  : AliTriggerDetector(),
fGlobalFOThreshold(1),
fHighMultFOThreshold(150){

  //standard constructor
  SetName("ITS");
  CreateInputs();

  // set parameters to define trigger condition thresholds
  //fGlobalFOThreshold = 1;
  //fHighMultFOThreshold = 150; 
}

//______________________________________________________________________
void AliITSTrigger::CreateInputs()
{
   // inputs

   // Do not create inputs again!!
   if( fInputs.GetEntriesFast() > 0 ) return;
   
   fInputs.AddLast( new AliTriggerInput( "ITS_SPD_GFO_L0",     "Global, Fast OR all detectors", 0x01 ) );
   fInputs.AddLast( new AliTriggerInput( "ITS_SPD_HMULT_L0",   "High Multiplicity",             0x02 ) );

}

//______________________________________________________________________
void AliITSTrigger::Trigger()
{

  //  ********** Get run loader for the current event **********
  AliRunLoader* runLoader = gAlice->GetRunLoader();

  AliITSLoader* loader = (AliITSLoader* )runLoader->GetLoader( "ITSLoader" );
  AliITSgeom* geom = loader->GetITSgeom();
  loader->LoadDigits("READ");
  TTree *treeD = loader->TreeD();
  if (!treeD) return;

  TObjArray *digDet = 0;
  digDet = new TObjArray(3);


  // Cut on Signal In the Pixel Detector
  TBranch* br = treeD->GetBranch( "ITSDigitsSPD" );
  br->SetAddress( &((*digDet)[0]) );
  ((TClonesArray*)(digDet->At(0)))->Clear();

  MultiplicityTriggers(digDet, treeD, geom);
  //  GeometryTriggers(digDet, treeD, geom);

  // Debug : FIX change to AliLog
//  cout << "=================================================" << endl;
//  cout << "  Pixel Trigger Mask ( " << hex << "0x" << GetMask() << " )" << endl << endl;
//  cout << " Global Fast OR        " << "0x" << GetInput( "ITS_SPD_GFO_L0"      )->GetValue() << endl;
//  cout << " High Multiplicity     " << "0x" << GetInput( "ITS_SPD_HMULT_L0"      )->GetValue() << endl;
//  cout << "=================================================" << endl << endl;

}

//______________________________________________________________________
void AliITSTrigger::MultiplicityTriggers(TObjArray* digDet, TTree* treeD, AliITSgeom* geom)
{
  // simple FO triggers that only cares about the multiplicity

  Int_t startSPD = geom->GetStartSPD();
  Int_t lastSPD  = geom->GetLastSPD();

  Int_t totalNumberOfFO = 0;
  Int_t ndigitsInChip[5];

  // loop over modules (ladders)
  for (Int_t moduleIndex=startSPD; moduleIndex<lastSPD+1; moduleIndex++) {
    treeD->GetEvent(moduleIndex);
    TClonesArray* digits = (TClonesArray*) (digDet->At(0)); // SPD only.
    
    // get number of digits in this module
    Int_t ndigitsInModule = digits->GetEntriesFast();

    // get number of digits in each chip of the module
    for( Int_t iChip=0; iChip<5; iChip++ ) {
	ndigitsInChip[iChip]=0;
    }	
    for( Int_t iDig=0; iDig<ndigitsInModule; iDig++ ) {
	AliITSdigitSPD* dp = (AliITSdigitSPD*) digits->At(iDig);
	Int_t column = dp->GetCoord1();
	Int_t isChip = Int_t(column/32.);
	ndigitsInChip[isChip]++;
    }
    // get number of FOs in the module
    for( Int_t ifChip=0; ifChip<5; ifChip++ ) {
	if( ndigitsInChip[ifChip] >= 1 ) {
    		totalNumberOfFO++;
    	}	
    }
  // end of loop over modules
  }

  // produce input trigger condition
  if (totalNumberOfFO>=fGlobalFOThreshold) 
    SetInput( "ITS_SPD_GFO_L0" );

  if (totalNumberOfFO>=fHighMultFOThreshold) 
    SetInput( "ITS_SPD_HMULT_L0" );

  return;

}

//______________________________________________________________________
// void AliITSTrigger::GeometryTriggers(TObjArray* digDet, TTree* treeD, AliITSgeom* geom)
void AliITSTrigger::GeometryTriggers()
{

//   //   const Int_t nlay = 2;      // not used
//   //   const Int_t nlad = 240;    // not used
//   //   const Int_t nstave = 40;   // not used
//   //   const Int_t ndet = 4;      // not used
//   //   const Int_t nchip = 5;     // not used
//   //   const Int_t ntotal = 1200;
  
//   Int_t ndigA[5];
//   Int_t iFOperlayer[2];
//   Int_t iFOperladder[240];
//   Int_t iFOperstave[40][2];
//   //   Int_t iFOperchip[ntotal];   // not used
//   Int_t iFOperChipinStave[20][40][2];
  
//   for (Int_t m=startSPD;m<lastSPD+1;m++) {
//     iFOperladder[m] = 0;
//   }

//   for (Int_t k = 0;k<2;k++){
//     iFOperlayer[k] = 0;
//     for (Int_t o=0; o<40; o++) {
//       iFOperstave[o][k] = 0;
//       for (Int_t ich=0; ich<20; ich++) {
// 	iFOperChipinStave[ich][o][k] = 0;
//       }
//     }
//   }

//   // nFO = 0.0;
//   Int_t mInStaveCounter = 0;
//   Int_t checkStave = 0;
  
//   // loop over modules
//   for (Int_t moduleIndex=startSPD; moduleIndex<lastSPD+1; moduleIndex++) {
//     treeD->GetEvent(moduleIndex);
//     TClonesArray* digits = (TClonesArray*) (digDet->At(0)); // SPD only.

//     Int_t lay, stav, det;
//     geom->GetModuleId(moduleIndex,lay,stav,det);

//     ndig = digits->GetEntriesFast();

//     for( Int_t l=0; l<5; l++ ) {
//       ndigA[l] = 0 ;
//     }
//     for( Int_t dig=0; dig<ndig; dig++) {
//       AliITSdigitSPD* dp = (AliITSdigitSPD*) digits->At(dig);
//       Int_t column = dp->GetCoord1();
//       //   Int_t row = dp->GetCoord2();
//       Int_t chip = Int_t(column/32.);
//       ndigA[chip]++;
//     }
    
//     if (checkStave != stav) {
//       mInStaveCounter = 0;
//     } else {
//       mInStaveCounter += 1;
//     }

//     // m 0,.., 239
//     // stav 1,..,40
//     // mInStave 0,..,3
//     // chipInStave 0,..,19
    
//     //cout << "m " << m << " stav "  << stav  << " mInStave " << mInStaveCounter << " " <<lay << endl;
    
//     for (Int_t ichip=0; ichip<5; ichip++) {
//       //Int_t seq = (m*5+ichip);
//       Int_t chipInStave = (mInStaveCounter *5) + ichip;
      
//       if (ndigA[ichip] >= 1) {
// 	iFOperladder[moduleIndex]++;
// 	iFOperlayer[lay-1]++;
// 	iFOperstave[stav-1][lay-1]++;
// 	//iFOperHstave[hstav-1][lay-1]++;
// 	iFOperChipinStave[chipInStave][stav-1][lay-1]++;
//         //    nFO++;
//       }
//     }
//     // SIMPLE FO ---> ANY HIT TRIGGERS
//     ndigfo += ndig;
//     checkStave = stav;
//   } // endl loop over SPD's


//    if ( ndigfo >= singhitthreshold ) {
//       // Set input GLOBAL FO
//       SetInput( "ITS_SPD_GFO_L0" );
//       // or SetInput( "0x01" );
//       // or ((AliTriggerInput*)fInputs.At(0))->Set();
//       // bit1 |= (1 << 1);
//    }

   // return bit1;
}
Commit	Line	Data
e628c711	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
e628c711	16
0ca510a1	17	/* $Id$ */
e628c711	18
7ca4655f	19	#include <TClonesArray.h>
e628c711	20
	21	#include "AliLog.h"
	22	#include "AliRun.h"
	23	#include "AliRunLoader.h"
2db4dcdc	24	#include "AliTriggerInput.h"
e628c711	25
e628c711	26	#include "AliITSTrigger.h"
2db4dcdc	27	#include "AliITSdigitSPD.h"
	28	#include "AliITSgeom.h"
	29	#include "AliITSLoader.h"
e628c711	30
	31	//______________________________________________________________________
	32	ClassImp(AliITSTrigger)
0ca510a1	33	////////////////////////////////////////////////////////////////////////
7537d03c	34	// //
	35	// Version 1 //
	36	// Modified by D. Elia, C. Jorgensen //
	37	// March 2006 //
	38	// //
	39	// Version 0 //
	40	// Written by J. Conrad, E. Lopez Torres //
	41	// October 2005 //
	42	// //
	43	// AliITSTrigger: implementation of the SPD Fast-OR based triggers. //
	44	// //
0ca510a1	45	////////////////////////////////////////////////////////////////////////
e628c711	46
	47	//______________________________________________________________________
	48	AliITSTrigger::AliITSTrigger()
7537d03c	49	: AliTriggerDetector(),
	50	fGlobalFOThreshold(1),
	51	fHighMultFOThreshold(150){
	52
	53	//standard constructor
	54	SetName("ITS");
	55	CreateInputs();
8e50d897	56
7537d03c	57	// set parameters to define trigger condition thresholds
	58	//fGlobalFOThreshold = 1;
	59	//fHighMultFOThreshold = 150;
e628c711	60	}
	61
	62	//______________________________________________________________________
	63	void AliITSTrigger::CreateInputs()
	64	{
	65	// inputs
	66
	67	// Do not create inputs again!!
	68	if( fInputs.GetEntriesFast() > 0 ) return;
	69
	70	fInputs.AddLast( new AliTriggerInput( "ITS_SPD_GFO_L0", "Global, Fast OR all detectors", 0x01 ) );
0ca510a1	71	fInputs.AddLast( new AliTriggerInput( "ITS_SPD_HMULT_L0", "High Multiplicity", 0x02 ) );
e628c711	72
	73	}
	74
	75	//______________________________________________________________________
	76	void AliITSTrigger::Trigger()
	77	{
	78
8e50d897	79	// ******** Get run loader for the current event ********
	80	AliRunLoader* runLoader = gAlice->GetRunLoader();
	81
	82	AliITSLoader* loader = (AliITSLoader* )runLoader->GetLoader( "ITSLoader" );
	83	AliITSgeom* geom = loader->GetITSgeom();
	84	loader->LoadDigits("READ");
	85	TTree *treeD = loader->TreeD();
698b2e52	86	if (!treeD) return;
8e50d897	87
	88	TObjArray *digDet = 0;
	89	digDet = new TObjArray(3);
	90
	91
	92	// Cut on Signal In the Pixel Detector
	93	TBranch* br = treeD->GetBranch( "ITSDigitsSPD" );
	94	br->SetAddress( &((*digDet)[0]) );
	95	((TClonesArray*)(digDet->At(0)))->Clear();
	96
	97	MultiplicityTriggers(digDet, treeD, geom);
	98	// GeometryTriggers(digDet, treeD, geom);
	99
	100	// Debug : FIX change to AliLog
0ca510a1	101	// cout << "=================================================" << endl;
	102	// cout << " Pixel Trigger Mask ( " << hex << "0x" << GetMask() << " )" << endl << endl;
	103	// cout << " Global Fast OR " << "0x" << GetInput( "ITS_SPD_GFO_L0" )->GetValue() << endl;
	104	// cout << " High Multiplicity " << "0x" << GetInput( "ITS_SPD_HMULT_L0" )->GetValue() << endl;
	105	// cout << "=================================================" << endl << endl;
e628c711	106
	107	}
	108
8e50d897	109	//______________________________________________________________________
	110	void AliITSTrigger::MultiplicityTriggers(TObjArray* digDet, TTree* treeD, AliITSgeom* geom)
	111	{
	112	// simple FO triggers that only cares about the multiplicity
	113
8e50d897	114	Int_t startSPD = geom->GetStartSPD();
	115	Int_t lastSPD = geom->GetLastSPD();
	116
0ca510a1	117	Int_t totalNumberOfFO = 0;
0ca510a1	118	Int_t ndigitsInChip[5];
e628c711	119
0ca510a1	120	// loop over modules (ladders)
2ca17abd	121	for (Int_t moduleIndex=startSPD; moduleIndex<lastSPD+1; moduleIndex++) {
8e50d897	122	treeD->GetEvent(moduleIndex);
	123	TClonesArray* digits = (TClonesArray*) (digDet->At(0)); // SPD only.
	124
	125	// get number of digits in this module
0ca510a1	126	Int_t ndigitsInModule = digits->GetEntriesFast();
	127
	128	// get number of digits in each chip of the module
	129	for( Int_t iChip=0; iChip<5; iChip++ ) {
	130	ndigitsInChip[iChip]=0;
	131	}
	132	for( Int_t iDig=0; iDig<ndigitsInModule; iDig++ ) {
	133	AliITSdigitSPD* dp = (AliITSdigitSPD*) digits->At(iDig);
	134	Int_t column = dp->GetCoord1();
	135	Int_t isChip = Int_t(column/32.);
	136	ndigitsInChip[isChip]++;
	137	}
	138	// get number of FOs in the module
	139	for( Int_t ifChip=0; ifChip<5; ifChip++ ) {
	140	if( ndigitsInChip[ifChip] >= 1 ) {
	141	totalNumberOfFO++;
	142	}
	143	}
	144	// end of loop over modules
8e50d897	145	}
8e50d897	146
0ca510a1	147	// produce input trigger condition
0ca510a1	148	if (totalNumberOfFO>=fGlobalFOThreshold)
8e50d897	149	SetInput( "ITS_SPD_GFO_L0" );
8e50d897	150
0ca510a1	151	if (totalNumberOfFO>=fHighMultFOThreshold)
8e50d897	152	SetInput( "ITS_SPD_HMULT_L0" );
	153
	154	return;
	155
	156	}
e628c711	157
e628c711	158	//______________________________________________________________________
0ca510a1	159	// void AliITSTrigger::GeometryTriggers(TObjArray* digDet, TTree* treeD, AliITSgeom* geom)
0ca510a1	160	void AliITSTrigger::GeometryTriggers()
e628c711	161	{
8e50d897	162
8e50d897	163	// // const Int_t nlay = 2; // not used
	164	// // const Int_t nlad = 240; // not used
	165	// // const Int_t nstave = 40; // not used
	166	// // const Int_t ndet = 4; // not used
	167	// // const Int_t nchip = 5; // not used
	168	// // const Int_t ntotal = 1200;
	169
	170	// Int_t ndigA[5];
	171	// Int_t iFOperlayer[2];
	172	// Int_t iFOperladder[240];
	173	// Int_t iFOperstave[40][2];
	174	// // Int_t iFOperchip[ntotal]; // not used
	175	// Int_t iFOperChipinStave[20][40][2];
	176
2ca17abd	177	// for (Int_t m=startSPD;m<lastSPD+1;m++) {
8e50d897	178	// iFOperladder[m] = 0;
	179	// }
	180
	181	// for (Int_t k = 0;k<2;k++){
	182	// iFOperlayer[k] = 0;
	183	// for (Int_t o=0; o<40; o++) {
	184	// iFOperstave[o][k] = 0;
	185	// for (Int_t ich=0; ich<20; ich++) {
	186	// iFOperChipinStave[ich][o][k] = 0;
	187	// }
	188	// }
	189	// }
	190
	191	// // nFO = 0.0;
	192	// Int_t mInStaveCounter = 0;
	193	// Int_t checkStave = 0;
	194
	195	// // loop over modules
2ca17abd	196	// for (Int_t moduleIndex=startSPD; moduleIndex<lastSPD+1; moduleIndex++) {
8e50d897	197	// treeD->GetEvent(moduleIndex);
	198	// TClonesArray* digits = (TClonesArray*) (digDet->At(0)); // SPD only.
	199
	200	// Int_t lay, stav, det;
	201	// geom->GetModuleId(moduleIndex,lay,stav,det);
	202
	203	// ndig = digits->GetEntriesFast();
	204
	205	// for( Int_t l=0; l<5; l++ ) {
	206	// ndigA[l] = 0 ;
	207	// }
	208	// for( Int_t dig=0; dig<ndig; dig++) {
	209	// AliITSdigitSPD* dp = (AliITSdigitSPD*) digits->At(dig);
	210	// Int_t column = dp->GetCoord1();
	211	// // Int_t row = dp->GetCoord2();
	212	// Int_t chip = Int_t(column/32.);
	213	// ndigA[chip]++;
	214	// }
	215
	216	// if (checkStave != stav) {
	217	// mInStaveCounter = 0;
	218	// } else {
	219	// mInStaveCounter += 1;
	220	// }
	221
	222	// // m 0,.., 239
	223	// // stav 1,..,40
	224	// // mInStave 0,..,3
	225	// // chipInStave 0,..,19
	226
	227	// //cout << "m " << m << " stav " << stav << " mInStave " << mInStaveCounter << " " <<lay << endl;
	228
	229	// for (Int_t ichip=0; ichip<5; ichip++) {
	230	// //Int_t seq = (m*5+ichip);
	231	// Int_t chipInStave = (mInStaveCounter *5) + ichip;
	232
	233	// if (ndigA[ichip] >= 1) {
	234	// iFOperladder[moduleIndex]++;
	235	// iFOperlayer[lay-1]++;
	236	// iFOperstave[stav-1][lay-1]++;
	237	// //iFOperHstave[hstav-1][lay-1]++;
	238	// iFOperChipinStave[chipInStave][stav-1][lay-1]++;
	239	// // nFO++;
	240	// }
	241	// }
	242	// // SIMPLE FO ---> ANY HIT TRIGGERS
	243	// ndigfo += ndig;
	244	// checkStave = stav;
	245	// } // endl loop over SPD's
	246
	247
	248
	249	// if ( ndigfo >= singhitthreshold ) {
	250	// // Set input GLOBAL FO
	251	// SetInput( "ITS_SPD_GFO_L0" );
	252	// // or SetInput( "0x01" );
	253	// // or ((AliTriggerInput*)fInputs.At(0))->Set();
	254	// // bit1 \|= (1 << 1);
	255	// }
	256
	257	// return bit1;
e628c711	258	}