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