Included new data member to change patch size in calorimeters trigger (Gustavo)
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 19 Oct 2006 10:42:09 +0000 (10:42 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 19 Oct 2006 10:42:09 +0000 (10:42 +0000)
EMCAL/AliEMCALTrigger.cxx
EMCAL/AliEMCALTrigger.h
EMCAL/macros/TestEMCALTrigger.C
PHOS/AliPHOSTrigger.cxx
PHOS/AliPHOSTrigger.h
PHOS/macros/TestPHOSTrigger.C [new file with mode: 0644]

index 649251a..257a8d0 100644 (file)
 //_________________________________________________________________________  
 //
 //  Class for trigger analysis.
-//  Digits are grouped in TRU's (384 cells? ordered fNTRUPhi x fNTRUEta). 
-//  The algorithm searches all possible 4x4 cell combinations per each TRU, 
-//  adding the digits amplitude and finding the maximum. Maximums are compared 
-//  to triggers threshold and they are set. Thresholds need to be fixed. 
-//  Last 2 modules are half size in Phi, I considered that the number of TRU
-//  is maintained for the last modules but decision not taken. If different, 
-//  then this must be changed. 
+//  Digits are grouped in TRU's (384 cells ordered fNTRUPhi x fNTRUEta). 
+//  The algorithm searches all possible 2x2 and nxn (n is a multiple of 4) cell 
+//  combinations per each TRU,  adding the digits amplitude and finding the 
+//  maximum. Maxima are compared to triggers threshold and they are set. 
+//  Thresholds need to be fixed. Last 2 modules are half size in Phi, I considered 
+//  that the number of TRU is maintained for the last modules but decision not taken. 
+//  If different, then this must be changed. 
 //  Usage:
 //
 //  //Inside the event loop
 //  AliEMCALTrigger *tr = new AliEMCALTrigger();//Init Trigger
-//  tr->SetL0Threshold(100);
+//  tr->SetL0Threshold(100); //Arbitrary threshold values
 //  tr->SetL1JetLowPtThreshold(1000);
 //  tr->SetL1JetMediumPtThreshold(10000);
 //  tr->SetL1JetHighPtThreshold(20000);
@@ -61,14 +61,14 @@ AliEMCALTrigger::AliEMCALTrigger()
   : AliTriggerDetector(),
     f2x2MaxAmp(-1), f2x2CellPhi(-1),  f2x2CellEta(-1),
     f2x2SM(0),
-    f4x4MaxAmp(-1), f4x4CellPhi(-1),  f4x4CellEta(-1),
-    f4x4SM(0),
-    fADCValuesHigh4x4(0x0),fADCValuesLow4x4(0x0),
+    fnxnMaxAmp(-1), fnxnCellPhi(-1),  fnxnCellEta(-1),
+    fnxnSM(0),
+    fADCValuesHighnxn(0x0),fADCValuesLownxn(0x0),
     fADCValuesHigh2x2(0x0),fADCValuesLow2x2(0x0),
     fDigitsList(0x0),
     fL0Threshold(100),fL1JetLowPtThreshold(200),
     fL1JetMediumPtThreshold(500), fL1JetHighPtThreshold(1000),
-    fSimulation(kTRUE)
+    fPatchSize(1), fSimulation(kTRUE)
 {
   //ctor 
 
@@ -87,12 +87,12 @@ AliEMCALTrigger::AliEMCALTrigger(const AliEMCALTrigger & trig)
     f2x2CellPhi(trig.f2x2CellPhi),  
     f2x2CellEta(trig.f2x2CellEta),
     f2x2SM(trig.f2x2SM),
-    f4x4MaxAmp(trig.f4x4MaxAmp), 
-    f4x4CellPhi(trig.f4x4CellPhi),  
-    f4x4CellEta(trig.f4x4CellEta),
-    f4x4SM(trig.f4x4SM),
-    fADCValuesHigh4x4(trig.fADCValuesHigh4x4),
-    fADCValuesLow4x4(trig.fADCValuesLow4x4),
+    fnxnMaxAmp(trig.fnxnMaxAmp), 
+    fnxnCellPhi(trig.fnxnCellPhi),  
+    fnxnCellEta(trig.fnxnCellEta),
+    fnxnSM(trig.fnxnSM),
+    fADCValuesHighnxn(trig.fADCValuesHighnxn),
+    fADCValuesLownxn(trig.fADCValuesLownxn),
     fADCValuesHigh2x2(trig.fADCValuesHigh2x2),
     fADCValuesLow2x2(trig.fADCValuesLow2x2),
     fDigitsList(trig.fDigitsList),
@@ -100,7 +100,7 @@ AliEMCALTrigger::AliEMCALTrigger(const AliEMCALTrigger & trig)
     fL1JetLowPtThreshold(trig.fL1JetLowPtThreshold),
     fL1JetMediumPtThreshold(trig.fL1JetMediumPtThreshold), 
     fL1JetHighPtThreshold(trig.fL1JetHighPtThreshold),
-    fSimulation(trig.fSimulation)
+    fPatchSize(trig.fPatchSize), fSimulation(trig.fSimulation)
 {
   // cpy ctor
 }
@@ -121,9 +121,9 @@ void AliEMCALTrigger::CreateInputs()
 }
 
 //____________________________________________________________________________
-void AliEMCALTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus, const Int_t isupermod,TMatrixD *ampmax2, TMatrixD *ampmax4, AliEMCALGeometry *geom){
+void AliEMCALTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus, const Int_t isupermod,TMatrixD *ampmax2, TMatrixD *ampmaxn, AliEMCALGeometry *geom){
   
-  //Sums energy of all possible 2x2 (L0) and 4x4 (L1) cells per each TRU. 
+  //Sums energy of all possible 2x2 (L0) and nxn (L1) cells per each TRU. 
   //Fast signal in the experiment is given by 2x2 cells, 
   //for this reason we loop inside the TRU cells by 2. 
 
@@ -137,16 +137,16 @@ void AliEMCALTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClone
   Int_t nTRU          = geom->GetNTRU();//3 TRU per super module
 
   Float_t amp2 = 0 ;
-  Float_t amp4 = 0 ; 
+  Float_t ampn = 0 ; 
   for(Int_t i = 0; i < 4; i++){
     for(Int_t j = 0; j < nTRU; j++){
       (*ampmax2)(i,j) = -1;
-      (*ampmax4)(i,j) = -1;
+      (*ampmaxn)(i,j) = -1;
     }
   }
 
   //Create matrix that will contain 2x2 amplitude sums
-  //used to calculate the 4x4 sums
+  //used to calculate the nxn sums
   TMatrixD  * tru2x2 = new TMatrixD(nCellsPhi/2,nCellsEta/2) ;
   for(Int_t i = 0; i < nCellsPhi/2; i++)
     for(Int_t j = 0; j < nCellsEta/2; j++)
@@ -164,7 +164,7 @@ void AliEMCALTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClone
        amp2 = (*amptru)(irow,icol)+(*amptru)(irow+1,icol)+
          (*amptru)(irow,icol+1)+(*amptru)(irow+1,icol+1);
 
-       //Fill matrix with added 2x2 crystals for use in 4x4 sums
+       //Fill matrix with added 2x2 crystals for use in nxn sums
        (*tru2x2)(irow/2,icol/2) = amp2 ;
        //Select 2x2 maximum sums to select L0 
        if(amp2 > (*ampmax2)(0,mtru)){
@@ -187,35 +187,47 @@ void AliEMCALTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClone
        }
       }
     }
-    
-    //Sliding 4x4, add 4x4 amplitudes  (OVERLAP)
-    for(Int_t irow = 0 ; irow <  nCellsPhi/2; irow++){ 
-      for(Int_t icol = 0 ; icol < nCellsEta/2 ; icol++){
-       if( (irow+1) < nCellsPhi/2 && (icol+1) < nCellsEta/2){//Avoid exit the TRU
-         amp4 = (*tru2x2)(irow,icol)+(*tru2x2)(irow+1,icol)+
-           (*tru2x2)(irow,icol+1)+(*tru2x2)(irow+1,icol+1);
-         //Select 4x4 maximum sums to select L1 
-         if(amp4 > (*ampmax4)(0,mtru)){
-           (*ampmax4)(0,mtru) = amp4 ; 
-           (*ampmax4)(1,mtru) = irow*2;
-           (*ampmax4)(2,mtru) = icol*2;
+
+    //Sliding nxn, add nxn amplitudes  (OVERLAP)
+    if(fPatchSize > 0){
+      for(Int_t irow = 0 ; irow <  nCellsPhi/2; irow++){ 
+       for(Int_t icol = 0 ; icol < nCellsEta/2 ; icol++){
+         ampn = 0;
+         if( (irow+fPatchSize) < nCellsPhi/2 && (icol+fPatchSize) < nCellsEta/2){//Avoid exit the TRU
+           for(Int_t i = 0 ; i <= fPatchSize ; i++)
+             for(Int_t j = 0 ; j <= fPatchSize ; j++)
+               ampn += (*tru2x2)(irow+i,icol+j);
+           //Select nxn maximum sums to select L1 
+           if(ampn > (*ampmaxn)(0,mtru)){
+             (*ampmaxn)(0,mtru) = ampn ; 
+             (*ampmaxn)(1,mtru) = irow*2;
+             (*ampmaxn)(2,mtru) = icol*2;
+           }
          }
        }
       }
-    }
-    
-    //Find most recent time in selected 4x4 cell
-    (*ampmax4)(3,mtru) = 1 ;
-    Int_t row4 =  static_cast <Int_t> ((*ampmax4)(1,mtru));
-    Int_t col4 =  static_cast <Int_t> ((*ampmax4)(2,mtru));
-    for(Int_t i = 0; i<4; i++){
-      for(Int_t j = 0; j<4; j++){
-       if((*amptru)(row4+i,col4+j) > 0 &&  (*timeRtru)(row4+i,col4+j)> 0){
-         if((*timeRtru)(row4+i,col4+j) <  (*ampmax4)(3,mtru)  )
-           (*ampmax4)(3,mtru) =  (*timeRtru)(row4+i,col4+j);
+      
+      //Find most recent time in selected nxn cell
+      (*ampmaxn)(3,mtru) = 1 ;
+      Int_t rown =  static_cast <Int_t> ((*ampmaxn)(1,mtru));
+      Int_t coln =  static_cast <Int_t> ((*ampmaxn)(2,mtru));
+      for(Int_t i = 0; i<4*fPatchSize; i++){
+       for(Int_t j = 0; j<4*fPatchSize; j++){
+         if( (rown+i) < nCellsPhi && (coln+j) < nCellsEta/2){//Avoid exit the TRU
+           if((*amptru)(rown+i,coln+j) > 0 &&  (*timeRtru)(rown+i,coln+j)> 0){
+             if((*timeRtru)(rown+i,coln+j) <  (*ampmaxn)(3,mtru)  )
+               (*ampmaxn)(3,mtru) =  (*timeRtru)(rown+i,coln+j);
+           }
+         }
        }
       }
     }
+    else {  
+       (*ampmaxn)(0,mtru) =  (*ampmax2)(0,mtru); 
+       (*ampmaxn)(1,mtru) =  (*ampmax2)(1,mtru);
+       (*ampmaxn)(2,mtru) =  (*ampmax2)(2,mtru);
+       (*ampmaxn)(3,mtru) =  (*ampmax2)(3,mtru);
+      }
   }
 }
 
@@ -232,10 +244,15 @@ void AliEMCALTrigger::Print(const Option_t * opt) const
   printf( "             Maximum Amplitude after Sliding Cell, \n") ; 
   printf( "               -2x2 cells sum (not overlapped): %10.2f, in Super Module %d\n",
          f2x2MaxAmp,f2x2SM) ; 
-   printf( "               -2x2 from row %d to row %d and from column %d to column %d\n", f2x2CellPhi, f2x2CellPhi+2, f2x2CellEta, f2x2CellEta+2) ; 
-  printf( "               -4x4 cells sum (overlapped)    : %10.2f, in Super Module %d\n",
-         f4x4MaxAmp,f4x4SM) ; 
-  printf( "               -4x4 from row %d to row %d and from column %d to column %d\n", f4x4CellPhi, f4x4CellPhi+4, f4x4CellEta, f4x4CellEta+4) ; 
+  printf( "               -2x2 from row %d to row %d and from column %d to column %d\n", f2x2CellPhi, f2x2CellPhi+2, f2x2CellEta, f2x2CellEta+2) ; 
+  if(fPatchSize > 0){
+    printf( "             Patch Size, n x n: %d x %d cells\n",4*fPatchSize, 4*fPatchSize);
+    printf( "               -nxn cells sum (overlapped)    : %10.2f, in Super Module %d\n",
+           fnxnMaxAmp,fnxnSM) ; 
+    printf( "               -nxn from row %d to row %d and from column %d to column %d\n", fnxnCellPhi, fnxnCellPhi+4*fPatchSize, fnxnCellEta, fnxnCellEta+4*fPatchSize) ; 
+  }
   printf( "             Threshold for LO %10.2f\n", 
          fL0Threshold) ;  
   in = (AliTriggerInput*)fInputs.FindObject( "EMCAL_L0" );
@@ -264,15 +281,15 @@ void AliEMCALTrigger::Print(const Option_t * opt) const
 
 //____________________________________________________________________________
 void AliEMCALTrigger::SetTriggers(const Int_t iSM, const TMatrixD *ampmax2, 
-                                 const TMatrixD *ampmax4, AliEMCALGeometry *geom)  
+                                 const TMatrixD *ampmaxn, AliEMCALGeometry *geom)  
 {
 
-  //Checks the 2x2 and 4x4 maximum amplitude per each TRU and 
+  //Checks the 2x2 and nxn maximum amplitude per each TRU and 
   //compares with the different L0 and L1 triggers thresholds
   Float_t max2[] = {-1,-1,-1,-1} ;
-  Float_t max4[] = {-1,-1,-1,-1} ;
+  Float_t maxn[] = {-1,-1,-1,-1} ;
   Int_t   itru2  = -1 ;
-  Int_t   itru4  = -1 ;
+  Int_t   itrun  = -1 ;
 
   //Find maximum summed amplitude of all the TRU 
   //in a Super Module
@@ -284,18 +301,18 @@ void AliEMCALTrigger::SetTriggers(const Int_t iSM, const TMatrixD *ampmax2,
        max2[3] =  (*ampmax2)(3,i) ; // corresponding most recent time
        itru2   = i ;
       }
-      if(max4[0] < (*ampmax4)(0,i) ){
-       max4[0] =  (*ampmax4)(0,i) ; // 4x4 summed max amplitude
-       max4[1] =  (*ampmax4)(1,i) ; // corresponding phi position in TRU
-       max4[2] =  (*ampmax4)(2,i) ; // corresponding eta position in TRU
-       max4[3] =  (*ampmax4)(3,i) ; // corresponding most recent time
-       itru4   = i ;
+      if(maxn[0] < (*ampmaxn)(0,i) ){
+       maxn[0] =  (*ampmaxn)(0,i) ; // nxn summed max amplitude
+       maxn[1] =  (*ampmaxn)(1,i) ; // corresponding phi position in TRU
+       maxn[2] =  (*ampmaxn)(2,i) ; // corresponding eta position in TRU
+       maxn[3] =  (*ampmaxn)(3,i) ; // corresponding most recent time
+       itrun   = i ;
       }
     }
 
   //--------Set max amplitude if larger than in other Super Modules------------
   Float_t maxtimeR2 = -1 ;
-  Float_t maxtimeR4 = -1 ;
+  Float_t maxtimeRn = -1 ;
   AliRunLoader *rl  = AliRunLoader::GetRunLoader();
   AliRun * gAlice   = rl->GetAliRun(); 
   AliEMCAL * emcal  = (AliEMCAL*)gAlice->GetDetector("EMCAL");
@@ -326,24 +343,24 @@ void AliEMCALTrigger::SetTriggers(const Int_t iSM, const TMatrixD *ampmax2,
     }
   }
   
-  //------------Set max of 4x4 amplitudes and select L1 trigger---------
-  if(max4[0] > f4x4MaxAmp ){
-    f4x4MaxAmp  = max4[0] ;
-    f4x4SM      = iSM ;
-    maxtimeR4   = max4[3] ;
-    geom->GetCellPhiEtaIndexInSModuleFromTRUIndex(itru4, 
-                                                 static_cast<Int_t>(max4[1]),
-                                                 static_cast<Int_t>(max4[2]),
-                                                 f4x4CellPhi,f4x4CellEta) ; 
+  //------------Set max of nxn amplitudes and select L1 trigger---------
+  if(maxn[0] > fnxnMaxAmp ){
+    fnxnMaxAmp  = maxn[0] ;
+    fnxnSM      = iSM ;
+    maxtimeRn   = maxn[3] ;
+    geom->GetCellPhiEtaIndexInSModuleFromTRUIndex(itrun, 
+                                                 static_cast<Int_t>(maxn[1]),
+                                                 static_cast<Int_t>(maxn[2]),
+                                                 fnxnCellPhi,fnxnCellEta) ; 
     //Transform digit amplitude in Raw Samples
-    fADCValuesHigh4x4 = new Int_t[nTimeBins];
-    fADCValuesLow4x4  = new Int_t[nTimeBins];
-    emcal->RawSampledResponse(maxtimeR4, f4x4MaxAmp, fADCValuesHigh4x4, fADCValuesLow4x4) ;
+    fADCValuesHighnxn = new Int_t[nTimeBins];
+    fADCValuesLownxn  = new Int_t[nTimeBins];
+    emcal->RawSampledResponse(maxtimeRn, fnxnMaxAmp, fADCValuesHighnxn, fADCValuesLownxn) ;
     
     //Set Trigger Inputs, compare ADC time bins until threshold is attained
     //SetL1 Low
     for(Int_t i = 0 ; i < nTimeBins ; i++){
-      if(fADCValuesHigh4x4[i] >= fL1JetLowPtThreshold  || fADCValuesLow4x4[i] >= fL1JetLowPtThreshold){
+      if(fADCValuesHighnxn[i] >= fL1JetLowPtThreshold  || fADCValuesLownxn[i] >= fL1JetLowPtThreshold){
        SetInput("EMCAL_JetLPt_L1") ;
        break; 
       }
@@ -351,7 +368,7 @@ void AliEMCALTrigger::SetTriggers(const Int_t iSM, const TMatrixD *ampmax2,
     
     //SetL1 Medium
     for(Int_t i = 0 ; i < nTimeBins ; i++){
-      if(fADCValuesHigh4x4[i] >= fL1JetMediumPtThreshold || fADCValuesLow4x4[i] >= fL1JetMediumPtThreshold){
+      if(fADCValuesHighnxn[i] >= fL1JetMediumPtThreshold || fADCValuesLownxn[i] >= fL1JetMediumPtThreshold){
        SetInput("EMCAL_JetMPt_L1") ;
        break;
       }
@@ -359,7 +376,7 @@ void AliEMCALTrigger::SetTriggers(const Int_t iSM, const TMatrixD *ampmax2,
     
     //SetL1 High
     for(Int_t i = 0 ; i < nTimeBins ; i++){
-      if(fADCValuesHigh4x4[i] >= fL1JetHighPtThreshold || fADCValuesLow4x4[i] >= fL1JetHighPtThreshold){
+      if(fADCValuesHighnxn[i] >= fL1JetHighPtThreshold || fADCValuesLownxn[i] >= fL1JetHighPtThreshold){
        SetInput("EMCAL_JetHPt_L1") ;
        break;
       }
@@ -391,7 +408,7 @@ void AliEMCALTrigger::Trigger()
 
   //Intialize data members each time the trigger is called in event loop
   f2x2MaxAmp = -1; f2x2CellPhi = -1;  f2x2CellEta = -1;
-  f4x4MaxAmp = -1; f4x4CellPhi = -1;  f4x4CellEta = -1;
+  fnxnMaxAmp = -1; fnxnCellPhi = -1;  fnxnCellEta = -1;
 
   //Take the digits list if simulation
   if(fSimulation){
@@ -413,13 +430,13 @@ void AliEMCALTrigger::Trigger()
   //Initialize varible that will contain maximum amplitudes and 
   //its corresponding cell position in eta and phi, and time.
   TMatrixD  * ampmax2 = new TMatrixD(4,nTRU) ;
-  TMatrixD  * ampmax4 = new TMatrixD(4,nTRU) ;
+  TMatrixD  * ampmaxn = new TMatrixD(4,nTRU) ;
 
   for(Int_t iSM = 0 ; iSM < nSuperModules ; iSM++) {
-    //Do 2x2 and 4x4 sums, select maximums. 
-    MakeSlidingCell(amptrus, timeRtrus, iSM, ampmax2, ampmax4, geom);
+    //Do 2x2 and nxn sums, select maximums. 
+    MakeSlidingCell(amptrus, timeRtrus, iSM, ampmax2, ampmaxn, geom);
   
     //Set the trigger
-    SetTriggers(iSM, ampmax2, ampmax4, geom) ;
+    SetTriggers(iSM, ampmax2, ampmaxn, geom) ;
   }
 }
index c1f4846..2474e6d 100644 (file)
@@ -8,10 +8,10 @@
 //___________________________________________________________
 //  Class for trigger analysis.
 //  Digits are grouped in TRU's (Trigger Units). A TRU consist of 384 cells 
-//  ordered fNTRUPhi x fNTRUZ. The algorithm searches all possible 
-//  4x4 crystal combinations per each TRU, adding the digits amplitude and 
-//  finding the maximum. Maximums are transformed in adc time samples. 
-//  Each time bin is compared to the trigger threshold until it is larger 
+//  ordered fNTRUPhi x fNTRUZ. The algorithm searches all possible 2x2 and 
+//  nxn (n multiple of 4) crystal combinations per each TRU, adding the digits 
+//  amplitude and finding the maximum. Maximums are transformed in adc time 
+//  samples. Each time bin is compared to the trigger threshold until it is larger 
 //  and then, triggers are set. Thresholds need to be fixed. 
 //  Last 2 modules are half size in Phi, I considered that the number 
 //  of TRU is maintained for the last modules but final decision has not 
@@ -55,24 +55,25 @@ class AliEMCALTrigger : public AliTriggerDetector {
 
   //Getters
   Float_t  Get2x2MaxAmplitude()  const {return f2x2MaxAmp ; }
-  Float_t  Get4x4MaxAmplitude()  const {return f4x4MaxAmp ; }
+  Float_t  GetnxnMaxAmplitude()  const {return fnxnMaxAmp ; }
   Int_t    Get2x2CellPhi()       const {return f2x2CellPhi ; }
-  Int_t    Get4x4CellPhi()       const {return f4x4CellPhi ; }
+  Int_t    GetnxnCellPhi()       const {return fnxnCellPhi ; }
   Int_t    Get2x2CellEta()       const {return f2x2CellEta ; }
-  Int_t    Get4x4CellEta()       const {return f4x4CellEta ; }
+  Int_t    GetnxnCellEta()       const {return fnxnCellEta ; }
   Int_t    Get2x2SuperModule()   const {return f2x2SM ; }
-  Int_t    Get4x4SuperModule()   const {return f4x4SM ; }
+  Int_t    GetnxnSuperModule()   const {return fnxnSM ; }
 
   Int_t *  GetADCValuesLowGainMax2x2Sum()  {return fADCValuesLow2x2; }
   Int_t *  GetADCValuesHighGainMax2x2Sum() {return fADCValuesHigh2x2; }
-  Int_t *  GetADCValuesLowGainMax4x4Sum()  {return fADCValuesLow4x4; }
-  Int_t *  GetADCValuesHighGainMax4x4Sum() {return fADCValuesHigh4x4; }
+  Int_t *  GetADCValuesLowGainMaxnxnSum()  {return fADCValuesLownxn; }
+  Int_t *  GetADCValuesHighGainMaxnxnSum() {return fADCValuesHighnxn; }
 
   Float_t  GetL0Threshold() const           {return fL0Threshold ; } 
   Float_t  GetL1JetLowPtThreshold() const   {return fL1JetLowPtThreshold ; }
   Float_t  GetL1JetMediumPtThreshold()const {return fL1JetMediumPtThreshold ; }
   Float_t  GetL1JetHighPtThreshold() const  {return fL1JetHighPtThreshold ; }
-  
+
+  Float_t  GetPatchSize() const  {return fPatchSize ; }
   Bool_t   IsSimulation() const {return fSimulation ; }
   
   //Setters
@@ -88,14 +89,15 @@ class AliEMCALTrigger : public AliTriggerDetector {
   void     SetL1JetHighPtThreshold(Int_t amp)
     {fL1JetHighPtThreshold   = amp; }
 
+  void SetPatchSize(Int_t ps)                {fPatchSize = ps ; }
   void SetSimulation(Bool_t sim )          {fSimulation = sim ; }
 
  private:
  
-  void MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus,const Int_t supermod, TMatrixD *ampmax2, TMatrixD *ampmax4, AliEMCALGeometry * geom) ; 
+  void MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus,const Int_t supermod, TMatrixD *ampmax2, TMatrixD *ampmaxn, AliEMCALGeometry * geom) ; 
   
 
-  void SetTriggers(const Int_t iSM, const TMatrixD *ampmax2, const TMatrixD *ampmax4, AliEMCALGeometry *geom) ;
+  void SetTriggers(const Int_t iSM, const TMatrixD *ampmax2, const TMatrixD *ampmaxn, AliEMCALGeometry *geom) ;
     
  private: 
 
@@ -103,13 +105,13 @@ class AliEMCALTrigger : public AliTriggerDetector {
   Int_t   f2x2CellPhi ;       //! upper right cell, row(phi)   
   Int_t   f2x2CellEta ;       //! and column(eta)  
   Int_t   f2x2SM ;            //! Super Module where maximum is found
-  Float_t f4x4MaxAmp ;        //! Maximum 4x4 added amplitude (overlapped)
-  Int_t   f4x4CellPhi ;       //! upper right cell, row(phi)   
-  Int_t   f4x4CellEta ;       //! and column(eta)
-  Int_t   f4x4SM ;            //! Super Module where maximum is found
+  Float_t fnxnMaxAmp ;        //! Maximum nxn added amplitude (overlapped)
+  Int_t   fnxnCellPhi ;       //! upper right cell, row(phi)   
+  Int_t   fnxnCellEta ;       //! and column(eta)
+  Int_t   fnxnSM ;            //! Super Module where maximum is found
 
-  Int_t*   fADCValuesHigh4x4 ; //! Sampled ADC high gain values for the 4x4 crystals amplitude sum
-  Int_t*   fADCValuesLow4x4  ; //! " low gain  " 
+  Int_t*   fADCValuesHighnxn ; //! Sampled ADC high gain values for the nxn crystals amplitude sum
+  Int_t*   fADCValuesLownxn  ; //! " low gain  " 
   Int_t*   fADCValuesHigh2x2 ; //! " high gain " 2x2 "
   Int_t*   fADCValuesLow2x2  ; //! " low gaing " "
 
@@ -120,6 +122,8 @@ class AliEMCALTrigger : public AliTriggerDetector {
   Float_t fL1JetMediumPtThreshold ; //! L1 Medium pT trigger energy threshold
   Float_t fL1JetHighPtThreshold ;   //! L1 High pT trigger energy threshold
 
+  Int_t fPatchSize;                 //! Trigger patch factor, to be multiplied to 2x2 cells
+                                            // 0 means 2x2, 1 means nxn, 2 means 8x8 ...
   Bool_t  fSimulation ;           //! Flag to do the trigger during simulation or reconstruction
 
   ClassDef(AliEMCALTrigger,1)
index dc2201f..a75cf7d 100644 (file)
@@ -24,27 +24,28 @@ void TestEMCALTrigger(){
 
   Int_t maxevent =  rl->GetNumberOfEvents();
   cout<<"n events "<<maxevent<<endl;
-
+//  maxevent=5;
   //Load Digits  
   rl->LoadDigits("EMCAL");
-  
-  //Create trigger pointer and set thresholds if you want
-  //Defautl threshold values need to be fixed
-  AliEMCALTrigger *tr = new AliEMCALTrigger();  
-  tr->SetL0MBPbPbThreshold(500);
-  tr->SetL0MBppThreshold(100);
-  tr->SetL1JetLowPtThreshold(2000);
-  tr->SetL1JetMediumPtThreshold(10000);
-  tr->SetL1JetHighPtThreshold(20000);
 
   //event loop
   for(Int_t iEvent = 0; iEvent < maxevent ; iEvent++){
     rl->GetEvent(iEvent);
     cout<<">>>>>>>>>>> Event >>> "<<iEvent<<endl;
-    
+    AliEMCALTrigger *tr = new AliEMCALTrigger();
+    //Create trigger pointer and set thresholds if you want
+    //Default threshold values need to be fixed  
+    //     tr->SetL0Threshold(10000);
+    //     tr->SetL1JetLowPtThreshold(10000);
+    //     tr->SetL1JetMediumPtThreshold(10000);
+    //     tr->SetL1JetHighPtThreshold(10000);
+    tr->SetPatchSize(4);//0 means 2x2, 1->4x4, 2->8x8, 3->16x16 ...
     //Select trigger for each event
     tr->Trigger();//Do the trigger algorithm
-    
+    //     cout<<"Patch "<<tr->GetPatchSize()<<endl;
+    //     cout<<"Trigger patch "<< tr->GetPatchSize()
+    //         <<" 2x2 maximum amplitude sum "<<tr->Get2x2MaxAmplitude()
+    //         <<" nxn max amp sum "<<tr->GetnxnMaxAmplitude()<<endl;
     tr->Print("");//Print results. 
     
   }
index 435831d..7e1ce6d 100644 (file)
@@ -19,9 +19,9 @@
 //  Class for trigger analysis.
 //  Digits are grouped in TRU's (Trigger Units). A TRU consist of 16x28 
 //  crystals ordered fNTRUPhi x fNTRUZ. The algorithm searches all possible 
-//  4x4 crystal combinations per each TRU, adding the digits amplitude and 
-//  finding the maximum. Maximums are transformed in ADC time samples. 
-//  Each time bin is compared to the trigger threshold until it is larger 
+//  2x2 and nxn (n multiple of 4) crystal combinations per each TRU, adding the 
+//  digits amplitude and  finding the maximum. Maxima are transformed in ADC 
+//  time samples. Each time bin is compared to the trigger threshold until it is larger 
 //  and then, triggers are set. Thresholds need to be fixed. 
 //  Usage:
 //
@@ -55,15 +55,15 @@ ClassImp(AliPHOSTrigger)
 AliPHOSTrigger::AliPHOSTrigger()
   : AliTriggerDetector(),
     f2x2MaxAmp(-1), f2x2CrystalPhi(-1),  f2x2CrystalEta(-1), f2x2SM(0),
-    f4x4MaxAmp(-1), f4x4CrystalPhi(-1),  f4x4CrystalEta(-1), f4x4SM(0),
-    fADCValuesHigh4x4(0), fADCValuesLow4x4(0),
+    fnxnMaxAmp(-1), fnxnCrystalPhi(-1),  fnxnCrystalEta(-1), fnxnSM(0),
+    fADCValuesHighnxn(0), fADCValuesLownxn(0),
     fADCValuesHigh2x2(0), fADCValuesLow2x2(0), fDigitsList(0),
     fL0Threshold(50), fL1JetLowPtThreshold(200), fL1JetHighPtThreshold(500),
-    fNTRU(8), fNTRUZ(2), fNTRUPhi(4), fSimulation(kTRUE)
+    fNTRU(8), fNTRUZ(2), fNTRUPhi(4),  fPatchSize(1), fSimulation(kTRUE)
 {
   //ctor
-  fADCValuesHigh4x4 = 0x0; //new Int_t[fTimeBins];
-  fADCValuesLow4x4  = 0x0; //new Int_t[fTimeBins];
+  fADCValuesHighnxn = 0x0; //new Int_t[fTimeBins];
+  fADCValuesLownxn  = 0x0; //new Int_t[fTimeBins];
   fADCValuesHigh2x2 = 0x0; //new Int_t[fTimeBins];
   fADCValuesLow2x2  = 0x0; //new Int_t[fTimeBins];
 
@@ -80,12 +80,12 @@ AliPHOSTrigger::AliPHOSTrigger(const AliPHOSTrigger & trig) :
   f2x2CrystalPhi(trig.f2x2CrystalPhi),
   f2x2CrystalEta(trig.f2x2CrystalEta),
   f2x2SM(trig.f2x2SM),
-  f4x4MaxAmp(trig.f4x4MaxAmp),
-  f4x4CrystalPhi(trig.f4x4CrystalPhi),
-  f4x4CrystalEta(trig.f4x4CrystalEta),
-  f4x4SM(trig.f4x4SM),
-  fADCValuesHigh4x4(trig.fADCValuesHigh4x4),
-  fADCValuesLow4x4(trig.fADCValuesLow4x4),
+  fnxnMaxAmp(trig.fnxnMaxAmp),
+  fnxnCrystalPhi(trig.fnxnCrystalPhi),
+  fnxnCrystalEta(trig.fnxnCrystalEta),
+  fnxnSM(trig.fnxnSM),
+  fADCValuesHighnxn(trig.fADCValuesHighnxn),
+  fADCValuesLownxn(trig.fADCValuesLownxn),
   fADCValuesHigh2x2(trig.fADCValuesHigh2x2),
   fADCValuesLow2x2(trig.fADCValuesLow2x2),
   fDigitsList(trig.fDigitsList),
@@ -95,7 +95,7 @@ AliPHOSTrigger::AliPHOSTrigger(const AliPHOSTrigger & trig) :
   fNTRU(trig.fNTRU),
   fNTRUZ(trig.fNTRUZ),
   fNTRUPhi(trig.fNTRUPhi),
-  fSimulation(trig.fSimulation)
+  fPatchSize(trig.fPatchSize), fSimulation(trig.fSimulation)
 {
   // cpy ctor
 }
@@ -163,7 +163,7 @@ void AliPHOSTrigger::FillTRU(const TClonesArray * digits, const AliPHOSGeometry
   for(Int_t idig = 0 ; idig < digits->GetEntriesFast() ; idig++){
     
     dig    = static_cast<AliPHOSDigit *>(digits->At(idig)) ;
-    amp    = dig->GetAmp() ;   // Energy of the digit (arbitrary units)
+    amp    = dig->GetEnergy() ;   // Energy of the digit 
     id     = dig->GetId() ;    // Id label of the cell
     timeR  = dig->GetTimeR() ; // Earliest time of the digit
     geom->AbsToRelNumbering(id, relid) ;
@@ -222,8 +222,8 @@ void AliPHOSTrigger::GetCrystalPhiEtaIndexInModuleFromTRUIndex(const Int_t itru,
 
 }
 //____________________________________________________________________________
-void AliPHOSTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus, const Int_t imod, TMatrixD *ampmax2, TMatrixD *ampmax4, const AliPHOSGeometry *geom){
-  //Sums energy of all possible 2x2 (L0) and 4x4 (L1) crystals per each TRU. 
+void AliPHOSTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus, const Int_t imod, TMatrixD *ampmax2, TMatrixD *ampmaxn, const AliPHOSGeometry *geom){
+  //Sums energy of all possible 2x2 (L0) and nxn (L1) crystals per each TRU. 
   //Fast signal in the experiment is given by 2x2 crystals, 
   //for this reason we loop inside the TRU crystals by 2. 
  
@@ -231,18 +231,17 @@ void AliPHOSTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClones
   Int_t nCrystalsPhi = geom->GetNPhi()/fNTRUPhi ;// 64/4=16
   Int_t nCrystalsZ   = geom->GetNZ()/fNTRUZ ;// 56/2=28
   Float_t amp2 = 0 ;
-  Float_t amp4 = 0 ; 
-  for(Int_t i = 0; i < 3; i++){
+  Float_t ampn = 0 ; 
+  for(Int_t i = 0; i < 4; i++){
     for(Int_t j = 0; j < fNTRU; j++){
       (*ampmax2)(i,j) = -1;
-      (*ampmax4)(i,j) = -1;
+      (*ampmaxn)(i,j) = -1;
     }
   }
 
   //Create matrix that will contain 2x2 amplitude sums
-  //used to calculate the 4x4 sums
+  //used to calculate the nxn sums
   TMatrixD  * tru2x2 = new TMatrixD(nCrystalsPhi/2,nCrystalsZ/2) ;
-
   for(Int_t i = 0; i < nCrystalsPhi/2; i++)
     for(Int_t j = 0; j < nCrystalsZ/2; j++)
       (*tru2x2)(i,j) = 0.0;
@@ -258,7 +257,8 @@ void AliPHOSTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClones
       for(Int_t icol = 0 ; icol < nCrystalsZ ; icol += 2){
        amp2 = (*amptru)(irow,icol)+(*amptru)(irow+1,icol)+
          (*amptru)(irow,icol+1)+(*amptru)(irow+1,icol+1);
-       //Fill new matrix with added 2x2 crystals for use in 4x4 sums
+       
+       //Fill new matrix with added 2x2 crystals for use in nxn sums
        (*tru2x2)(irow/2,icol/2) = amp2 ;
        //Select 2x2 maximum sums to select L0 
        if(amp2 > (*ampmax2)(0,mtru)){
@@ -282,37 +282,48 @@ void AliPHOSTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClones
       }
     }
 
-    //Sliding 4x4, add 4x4 amplitudes (OVERLAP)
-    for(Int_t irow = 0 ; irow <  nCrystalsPhi/2; irow++){ 
-      for(Int_t icol = 0 ; icol < nCrystalsZ/2 ; icol++){
-       if( (irow+1) < nCrystalsPhi/2 && (icol+1) < nCrystalsZ/2){//Avoid exit the TRU
-         amp4 = (*tru2x2)(irow,icol)+(*tru2x2)(irow+1,icol)+
-           (*tru2x2)(irow,icol+1)+(*tru2x2)(irow+1,icol+1);
-         //Select 4x4 maximum sums to select L1 
-         if(amp4 > (*ampmax4)(0,mtru)){
-           (*ampmax4)(0,mtru) = amp4 ; 
-           (*ampmax4)(1,mtru) = irow*2;
-           (*ampmax4)(2,mtru) = icol*2;
+    //Sliding nxn, add nxn amplitudes (OVERLAP)
+    if(fPatchSize > 0){
+      for(Int_t irow = 0 ; irow <  nCrystalsPhi/2; irow++){ 
+       for(Int_t icol = 0 ; icol < nCrystalsZ/2 ; icol++){
+         ampn = 0;
+         if( (irow+fPatchSize) < nCrystalsPhi/2 && (icol+fPatchSize) < nCrystalsZ/2){//Avoid exit the TRU
+           for(Int_t i = 0 ; i <= fPatchSize ; i++)
+             for(Int_t j = 0 ; j <= fPatchSize ; j++)
+               ampn += (*tru2x2)(irow+i,icol+j);
+           //Select nxn maximum sums to select L1 
+           if(ampn > (*ampmaxn)(0,mtru)){
+             (*ampmaxn)(0,mtru) = ampn ; 
+             (*ampmaxn)(1,mtru) = irow*2;
+             (*ampmaxn)(2,mtru) = icol*2;
+           }
          }
        }
       }
-    }
-
-    //Find most recent time in selected 4x4 cell
-    (*ampmax4)(3,mtru) = 1 ;
-    Int_t row4 =  static_cast <Int_t> ((*ampmax4)(1,mtru));
-    Int_t col4 =  static_cast <Int_t> ((*ampmax4)(2,mtru));
-    for(Int_t i = 0; i<4; i++){
-      for(Int_t j = 0; j<4; j++){
-       if((*amptru)(row4+i,col4+j) > 0 &&  (*timeRtru)(row4+i,col4+j)> 0){
-         if((*timeRtru)(row4+i,col4+j) <  (*ampmax4)(3,mtru)  )
-           (*ampmax4)(3,mtru) =  (*timeRtru)(row4+i,col4+j);
+      
+      //Find most recent time in selected nxn cell
+      (*ampmaxn)(3,mtru) = 1 ;
+      Int_t rown =  static_cast <Int_t> ((*ampmaxn)(1,mtru));
+      Int_t coln =  static_cast <Int_t> ((*ampmaxn)(2,mtru));
+      for(Int_t i = 0; i<4*fPatchSize; i++){
+       for(Int_t j = 0; j<4*fPatchSize; j++){
+         if( (rown+i) < nCrystalsPhi && (coln+j) < nCrystalsZ/2){//Avoid exit the TRU
+           if((*amptru)(rown+i,coln+j) > 0 &&  (*timeRtru)(rown+i,coln+j)> 0){
+             if((*timeRtru)(rown+i,coln+j) <  (*ampmaxn)(3,mtru)  )
+               (*ampmaxn)(3,mtru) =  (*timeRtru)(rown+i,coln+j);
+           }
+         }
        }
       }
     }
+    else {  
+       (*ampmaxn)(0,mtru) =  (*ampmax2)(0,mtru); 
+       (*ampmaxn)(1,mtru) =  (*ampmax2)(1,mtru);
+       (*ampmaxn)(2,mtru) =  (*ampmax2)(2,mtru);
+       (*ampmaxn)(3,mtru) =  (*ampmax2)(3,mtru);
+      }
   }
 }
-
 //____________________________________________________________________________
 void AliPHOSTrigger::Print(const Option_t * opt) const 
 {
@@ -327,9 +338,13 @@ void AliPHOSTrigger::Print(const Option_t * opt) const
   printf( "               -2x2 crystals sum (not overlapped): %10.2f, in Super Module %d\n",
          f2x2MaxAmp,f2x2SM) ; 
   printf( "               -2x2 from row %d to row %d and from column %d to column %d\n", f2x2CrystalPhi, f2x2CrystalPhi+2, f2x2CrystalEta, f2x2CrystalEta+2) ; 
-  printf( "               -4x4 crystals sum (overlapped)    : %10.2f, in Super Module %d\n",
-         f4x4MaxAmp,f4x4SM) ; 
-  printf( "               -4x4 from row %d to row %d and from column %d to column %d\n", f4x4CrystalPhi, f4x4CrystalPhi+4, f4x4CrystalEta, f4x4CrystalEta+4) ; 
+
+  if(fPatchSize > 0){
+    printf( "             Patch Size, n x n: %d x %d cells\n",4*fPatchSize, 4*fPatchSize);
+    printf( "               -nxn crystals sum (overlapped)    : %10.2f, in Super Module %d\n",
+           fnxnMaxAmp,fnxnSM) ; 
+    printf( "               -nxn from row %d to row %d and from column %d to column %d\n", fnxnCrystalPhi, fnxnCrystalPhi+4, fnxnCrystalEta, fnxnCrystalEta+4) ; 
+  }
   printf( "             Threshold for LO %10.1f\n", 
          fL0Threshold) ;  
   
@@ -351,16 +366,16 @@ void AliPHOSTrigger::Print(const Option_t * opt) const
 }
 
 //____________________________________________________________________________
-void AliPHOSTrigger::SetTriggers(const Int_t iMod, const TMatrixD * ampmax2, const TMatrixD * ampmax4, const AliPHOSGeometry *geom)  
+void AliPHOSTrigger::SetTriggers(const Int_t iMod, const TMatrixD * ampmax2, const TMatrixD * ampmaxn, const AliPHOSGeometry *geom)  
 {
-  //Checks the 2x2 and 4x4 maximum amplitude per each TRU and compares 
+  //Checks the 2x2 and nxn maximum amplitude per each TRU and compares 
   //with the different L0 and L1 triggers thresholds
 
   //Initialize variables
   Float_t max2[] = {-1,-1,-1,-1} ;
-  Float_t max4[] = {-1,-1,-1,-1} ;
+  Float_t maxn[] = {-1,-1,-1,-1} ;
   Int_t   itru2  = -1 ;
-  Int_t   itru4  = -1 ;
+  Int_t   itrun  = -1 ;
 
 
   //Find maximum summed amplitude of all the TRU 
@@ -373,18 +388,18 @@ void AliPHOSTrigger::SetTriggers(const Int_t iMod, const TMatrixD * ampmax2, con
       max2[3] =  (*ampmax2)(3,i) ; // corresponding most recent time
       itru2   = i ; // TRU number
     }
-    if(max4[0] < (*ampmax4)(0,i) ){
-      max4[0] =  (*ampmax4)(0,i) ; // 4x4 summed max amplitude
-      max4[1] =  (*ampmax4)(1,i) ; // corresponding phi position in TRU
-      max4[2] =  (*ampmax4)(2,i) ; // corresponding eta position in TRU
-      max4[3] =  (*ampmax4)(3,i) ; // corresponding most recent time
-      itru4   = i ; // TRU number
+    if(maxn[0] < (*ampmaxn)(0,i) ){
+      maxn[0] =  (*ampmaxn)(0,i) ; // nxn summed max amplitude
+      maxn[1] =  (*ampmaxn)(1,i) ; // corresponding phi position in TRU
+      maxn[2] =  (*ampmaxn)(2,i) ; // corresponding eta position in TRU
+      maxn[3] =  (*ampmaxn)(3,i) ; // corresponding most recent time
+      itrun   = i ; // TRU number
     }
   }
   
   //Set max amplitude if larger than in other Modules
   Float_t maxtimeR2 = -1 ;
-  Float_t maxtimeR4 = -1 ;
+  Float_t maxtimeRn = -1 ;
   AliPHOSGetter * gime = AliPHOSGetter::Instance() ;
   AliPHOS * phos  = gime->PHOS();
   Int_t nTimeBins = phos->GetRawFormatTimeBins() ;
@@ -417,38 +432,38 @@ void AliPHOSTrigger::SetTriggers(const Int_t iMod, const TMatrixD * ampmax2, con
 //         <<"; 2x2 High Gain "<<fADCValuesHigh2x2[i]<<endl;
   }
 
-  //Set max 4x4 amplitude and select L1 triggers
-  if(max4[0] > f4x4MaxAmp ){
-    f4x4MaxAmp  = max4[0] ;
-    f4x4SM      = iMod ;
-    maxtimeR4   = max4[3] ;
-    GetCrystalPhiEtaIndexInModuleFromTRUIndex(itru4,static_cast<Int_t>(max4[1]),static_cast<Int_t>(max4[2]),f4x4CrystalPhi,f4x4CrystalEta,geom) ; 
+  //Set max nxn amplitude and select L1 triggers
+  if(maxn[0] > fnxnMaxAmp ){
+    fnxnMaxAmp  = maxn[0] ;
+    fnxnSM      = iMod ;
+    maxtimeRn   = maxn[3] ;
+    GetCrystalPhiEtaIndexInModuleFromTRUIndex(itrun,static_cast<Int_t>(maxn[1]),static_cast<Int_t>(maxn[2]),fnxnCrystalPhi,fnxnCrystalEta,geom) ; 
     
     //Transform digit amplitude in Raw Samples
-    fADCValuesHigh4x4 = new Int_t[nTimeBins];
-    fADCValuesLow4x4  = new Int_t[nTimeBins];
-    phos->RawSampledResponse(maxtimeR4, f4x4MaxAmp, fADCValuesHigh4x4, fADCValuesLow4x4) ;
+    fADCValuesHighnxn = new Int_t[nTimeBins];
+    fADCValuesLownxn  = new Int_t[nTimeBins];
+    phos->RawSampledResponse(maxtimeRn, fnxnMaxAmp, fADCValuesHighnxn, fADCValuesLownxn) ;
     
     //Set Trigger Inputs, compare ADC time bins until threshold is attained
     //SetL1 Low
     for(Int_t i = 0 ; i < nTimeBins ; i++){
-      if(fADCValuesHigh4x4[i] >= fL1JetLowPtThreshold  || fADCValuesLow4x4[i] >= fL1JetLowPtThreshold){
+      if(fADCValuesHighnxn[i] >= fL1JetLowPtThreshold  || fADCValuesLownxn[i] >= fL1JetLowPtThreshold){
        SetInput("PHOS_JetLPt_L1") ;
        break; 
       }
     }
     //SetL1 High
     for(Int_t i = 0 ; i < nTimeBins ; i++){
-      if(fADCValuesHigh4x4[i] >= fL1JetHighPtThreshold || fADCValuesLow4x4[i] >= fL1JetHighPtThreshold){
+      if(fADCValuesHighnxn[i] >= fL1JetHighPtThreshold || fADCValuesLownxn[i] >= fL1JetHighPtThreshold){
        SetInput("PHOS_JetHPt_L1") ;
        break;
       }
     }
 //     for(Int_t i = 0 ; i < 256 ; i++)
-//       if(fADCValuesLow4x4[i]!=0||fADCValuesHigh4x4[i]!=0)
-//     cout<< "4x4 Time Bin "<<i
-//         <<"; 4x4 Low Gain  "<<fADCValuesLow4x4[i]
-//         <<"; 4x4 High Gain "<<fADCValuesHigh4x4[i]<<endl;
+//       if(fADCValuesLownxn[i]!=0||fADCValuesHighnxn[i]!=0)
+//     cout<< "nxn Time Bin "<<i
+//         <<"; nxn Low Gain  "<<fADCValuesLownxn[i]
+//         <<"; nxn High Gain "<<fADCValuesHighnxn[i]<<endl;
   }
 }
 
@@ -470,7 +485,7 @@ void AliPHOSTrigger::Trigger()
 
   //Intialize data members each time the trigger is called in event loop
   f2x2MaxAmp = -1; f2x2CrystalPhi = -1;  f2x2CrystalEta = -1;
-  f4x4MaxAmp = -1; f4x4CrystalPhi = -1;  f4x4CrystalEta = -1;
+  fnxnMaxAmp = -1; fnxnCrystalPhi = -1;  fnxnCrystalEta = -1;
 
   //Take the digits list if simulation
   if(fSimulation)
@@ -488,12 +503,12 @@ void AliPHOSTrigger::Trigger()
   //Initialize varible that will contain maximum amplitudes and 
   //its corresponding cell position in eta and phi, and time.
   TMatrixD  * ampmax2 = new TMatrixD(4,fNTRU) ;
-  TMatrixD  * ampmax4 = new TMatrixD(4,fNTRU) ;
+  TMatrixD  * ampmaxn = new TMatrixD(4,fNTRU) ;
 
   for(Int_t imod = 1 ; imod <= nModules ; imod++) {
-    //Do 2x2 and 4x4 sums, select maximums. 
-    MakeSlidingCell(amptrus, timeRtrus, imod, ampmax2, ampmax4, geom);
+    //Do 2x2 and nxn sums, select maximums. 
+    MakeSlidingCell(amptrus, timeRtrus, imod, ampmax2, ampmaxn, geom);
     //Set the trigger
-    SetTriggers(imod,ampmax2,ampmax4, geom) ;
+    SetTriggers(imod,ampmax2,ampmaxn, geom) ;
   }
 }
index 5f3a148..5b7fe03 100644 (file)
@@ -10,9 +10,9 @@
 //  Class for trigger analysis.
 //  Digits are grouped in TRU's (Trigger Units). A TRU consist of 16x28 
 //  crystals ordered fNTRUPhi x fNTRUZ. The algorithm searches all possible 
-//  4x4 crystal combinations per each TRU, adding the digits amplitude and 
-//  finding the maximum. Maximums are transformed in ADC time samples. 
-//  Each time bin is compared to the trigger threshold until it is larger 
+//  2x2 and nxn  (n multiple of 4) crystal combinations per each TRU, adding the 
+//  digits amplitude and finding the maximum. Maxima are transformed in ADC 
+//  time samples.  Each time bin is compared to the trigger threshold until it is larger 
 //  and then, triggers are set. Thresholds need to be fixed. 
 //  Usage:
 //
@@ -50,19 +50,19 @@ class AliPHOSTrigger : public AliTriggerDetector {
   virtual void    Trigger();  //Make PHOS trigger
 
   //Getters
-  Float_t  Get2x2MaxAmplitude()  const {return f4x4MaxAmp ; }
-  Float_t  Get4x4MaxAmplitude()  const {return f4x4MaxAmp ; }
+  Float_t  Get2x2MaxAmplitude()  const {return f2x2MaxAmp ; }
+  Float_t  GetnxnMaxAmplitude()  const {return fnxnMaxAmp ; }
   Int_t    Get2x2CrystalPhi()    const {return f2x2CrystalPhi ; }
-  Int_t    Get4x4CrystalPhi()    const {return f4x4CrystalPhi ; }
+  Int_t    GetnxnCrystalPhi()    const {return fnxnCrystalPhi ; }
   Int_t    Get2x2CrystalEta()    const {return f2x2CrystalEta ; }
-  Int_t    Get4x4CrystalEta()    const {return f4x4CrystalEta ; }
+  Int_t    GetnxnCrystalEta()    const {return fnxnCrystalEta ; }
   Int_t    Get2x2SuperModule()   const {return f2x2SM ; }
-  Int_t    Get4x4SuperModule()   const {return f4x4SM ; }
+  Int_t    GetnxnSuperModule()   const {return fnxnSM ; }
 
   Int_t *  GetADCValuesLowGainMax2x2Sum()  {return fADCValuesLow2x2; }
   Int_t *  GetADCValuesHighGainMax2x2Sum() {return fADCValuesHigh2x2; }
-  Int_t *  GetADCValuesLowGainMax4x4Sum()  {return fADCValuesLow4x4; }
-  Int_t *  GetADCValuesHighGainMax4x4Sum() {return fADCValuesHigh4x4; }
+  Int_t *  GetADCValuesLowGainMaxnxnSum()  {return fADCValuesLownxn; }
+  Int_t *  GetADCValuesHighGainMaxnxnSum() {return fADCValuesHighnxn; }
 
   void GetCrystalPhiEtaIndexInModuleFromTRUIndex(Int_t itru, Int_t iphitru, Int_t ietatru,Int_t &ietaMod,Int_t &iphiMod, const AliPHOSGeometry *geom) const ;
 
@@ -73,7 +73,8 @@ class AliPHOSTrigger : public AliTriggerDetector {
   Int_t    GetNTRU()    const  {return fNTRU ; }
   Int_t    GetNTRUZ()   const  {return fNTRUZ ; }
   Int_t    GetNTRUPhi() const  {return fNTRUPhi ; }
-
+  
+  Float_t  GetPatchSize() const  {return fPatchSize ; }
   Bool_t   IsSimulation() const {return fSimulation ; }
 
   //Setters
@@ -93,6 +94,7 @@ class AliPHOSTrigger : public AliTriggerDetector {
   void     SetL1JetHighPtThreshold(Int_t amp)
     {fL1JetHighPtThreshold = amp ; }
 
+  void SetPatchSize(Int_t ps)                {fPatchSize = ps ; }
   void SetSimulation(Bool_t sim )          {fSimulation = sim ; }
 
  private:
@@ -101,9 +103,9 @@ class AliPHOSTrigger : public AliTriggerDetector {
 
   void FillTRU(const TClonesArray * digits, const AliPHOSGeometry * geom, TClonesArray * amptru, TClonesArray * timeRtru) const ;
 
-  void MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus, Int_t mod, TMatrixD *ampmax2, TMatrixD *ampmax4, const AliPHOSGeometry *geom) ;
+  void MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus, Int_t mod, TMatrixD *ampmax2, TMatrixD *ampmaxn, const AliPHOSGeometry *geom) ;
 
-  void SetTriggers(Int_t iMod, const TMatrixD *ampmax2,const TMatrixD *ampmax4, const AliPHOSGeometry *geom) ;
+  void SetTriggers(Int_t iMod, const TMatrixD *ampmax2,const TMatrixD *ampmaxn, const AliPHOSGeometry *geom) ;
 
  private: 
 
@@ -111,13 +113,13 @@ class AliPHOSTrigger : public AliTriggerDetector {
   Int_t   f2x2CrystalPhi ; //! upper right cell, row(phi)   
   Int_t   f2x2CrystalEta ; //! and column(eta) 
   Int_t   f2x2SM ;         //! Module where maximum is found
-  Float_t f4x4MaxAmp ;     //! Maximum 4x4 added amplitude (overlapped)
-  Int_t   f4x4CrystalPhi ; //! upper right cell, row(phi)   
-  Int_t   f4x4CrystalEta ; //! and column(eta)
-  Int_t   f4x4SM ;         //! Module where maximum is found
+  Float_t fnxnMaxAmp ;     //! Maximum nxn added amplitude (overlapped)
+  Int_t   fnxnCrystalPhi ; //! upper right cell, row(phi)   
+  Int_t   fnxnCrystalEta ; //! and column(eta)
+  Int_t   fnxnSM ;         //! Module where maximum is found
 
-  Int_t*   fADCValuesHigh4x4 ; //! Sampled ADC high gain values for the 4x4 crystals amplitude sum
-  Int_t*   fADCValuesLow4x4  ; //! " low gain  " 
+  Int_t*   fADCValuesHighnxn ; //! Sampled ADC high gain values for the nxn crystals amplitude sum
+  Int_t*   fADCValuesLownxn  ; //! " low gain  " 
   Int_t*   fADCValuesHigh2x2 ; //! " high gain " 2x2 "
   Int_t*   fADCValuesLow2x2  ; //! " low gaing " "
 
@@ -130,7 +132,8 @@ class AliPHOSTrigger : public AliTriggerDetector {
   Int_t   fNTRU ;                 //! Number of TRUs per module
   Int_t   fNTRUZ ;                //! Number of crystal rows per Z in one TRU
   Int_t   fNTRUPhi ;              //! Number of crystal rows per Phi in one TRU
-
+  Int_t fPatchSize;               //! Trigger patch factor, to be multiplied to 2x2 cells
+                                          // 0 means 2x2, 1 means nxn, 2 means 8x8 ...
   Bool_t  fSimulation ;           //! Flag to do the trigger during simulation or reconstruction
   ClassDef(AliPHOSTrigger,4)
 } ;
diff --git a/PHOS/macros/TestPHOSTrigger.C b/PHOS/macros/TestPHOSTrigger.C
new file mode 100644 (file)
index 0000000..0cbf254
--- /dev/null
@@ -0,0 +1,55 @@
+
+// Test Macro, shows how to execute the Trigger, and prints the results. 
+// Author: Gustavo Conesa
+
+void TestPHOSTrigger(){
+
+  //Loader  
+  AliRunLoader* rl=0x0;
+  
+//   cout<<"TestPHOSTrigger: Creating Run Loader ..."<<endl;
+//   rl = AliRunLoader::Open("galice.root",
+//                       AliConfig::GetDefaultEventFolderName(),
+//                       "read");
+//   if (rl == 0x0)
+//     {
+//       gAlice->Fatal("Config.C","Can not instatiate the Run Loader");
+//       return;
+//     }
+
+//   AliPHOSLoader *emcalLoader = dynamic_cast<AliPHOSLoader*>
+//     (rl->GetDetectorLoader("PHOS"));
+
+//   //Load Digits  
+//   rl->LoadDigits("PHOS");
+
+  AliPHOSGetter * gime = AliPHOSGetter::Instance("./galice.root");
+  //Get Maximum number of events
+  Int_t maxevent = gime->MaxEvent();
+  //Int_t maxevent =  rl->GetNumberOfEvents();
+  cout<<"n events "<<maxevent<<endl;
+//  maxevent=5;
+
+
+  //event loop
+  for(Int_t iEvent = 0; iEvent < maxevent ; iEvent++){
+    //    rl->GetEvent(iEvent);
+    gime->Event(iEvent,"D"); //Only Digits
+    cout<<">>>>>>>>>>> Event >>> "<<iEvent<<endl;
+    AliPHOSTrigger *tr = new AliPHOSTrigger();
+    //Create trigger pointer and set thresholds if you want
+    //Default threshold values need to be fixed  
+    //     tr->SetL0Threshold(10000);
+    //     tr->SetL1JetLowPtThreshold(10000);
+    //     tr->SetL1JetHighPtThreshold(10000);
+    tr->SetPatchSize(1);//0 means 2x2, 1->4x4, 2->8x8, 3->16x16 ...
+    //Select trigger for each event
+    tr->Trigger();//Do the trigger algorithm
+    //cout<<"Patch "<<tr->GetPatchSize()<<endl;
+    cout<<"Trigger patch "<< tr->GetPatchSize()
+       <<" 2x2 maximum amplitude sum "<<tr->Get2x2MaxAmplitude()
+               <<" nxn max amp sum "<<tr->GetnxnMaxAmplitude()<<endl;
+    //tr->Print("");//Print results. 
+    
+  }
+}