Included new data member to change patch size in calorimeters trigger (Gustavo)
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALTrigger.cxx
index 032556254d48292b51691b4f6a6de6712e9da8d6..257a8d051ff2e35f345173914b7a70f2dc5fb70c 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);
@@ -60,22 +60,18 @@ ClassImp(AliEMCALTrigger)
 AliEMCALTrigger::AliEMCALTrigger()
   : AliTriggerDetector(),
     f2x2MaxAmp(-1), f2x2CellPhi(-1),  f2x2CellEta(-1),
-    f4x4MaxAmp(-1), f4x4CellPhi(-1),  f4x4CellEta(-1), 
-    fL0Threshold(100),fL1JetLowPtThreshold(200), 
-    fL1JetMediumPtThreshold(500), fL1JetHighPtThreshold(1000), 
-    fSimulation(kTRUE)
-
+    f2x2SM(0),
+    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),
+    fPatchSize(1), fSimulation(kTRUE)
 {
   //ctor 
 
-  fADCValuesHigh4x4 = 0x0; //new Int_t[fTimeBins];
-  fADCValuesLow4x4  = 0x0; //new Int_t[fTimeBins];
-  fADCValuesHigh2x2 = 0x0; //new Int_t[fTimeBins];
-  fADCValuesLow2x2  = 0x0; //new Int_t[fTimeBins];
-
-  fDigitsList = 0x0 ;
-
-
   SetName("EMCAL");
   CreateInputs();
    
@@ -86,30 +82,27 @@ AliEMCALTrigger::AliEMCALTrigger()
 
 //____________________________________________________________________________
 AliEMCALTrigger::AliEMCALTrigger(const AliEMCALTrigger & trig) 
-  : AliTriggerDetector(trig) 
+  : AliTriggerDetector(trig),
+    f2x2MaxAmp(trig.f2x2MaxAmp), 
+    f2x2CellPhi(trig.f2x2CellPhi),  
+    f2x2CellEta(trig.f2x2CellEta),
+    f2x2SM(trig.f2x2SM),
+    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),
+    fL0Threshold(trig.fL0Threshold),
+    fL1JetLowPtThreshold(trig.fL1JetLowPtThreshold),
+    fL1JetMediumPtThreshold(trig.fL1JetMediumPtThreshold), 
+    fL1JetHighPtThreshold(trig.fL1JetHighPtThreshold),
+    fPatchSize(trig.fPatchSize), fSimulation(trig.fSimulation)
 {
-
   // cpy ctor
-
-  f2x2MaxAmp               = trig.f2x2MaxAmp ;
-  f4x4MaxAmp               = trig.f4x4MaxAmp ;
-  f2x2CellPhi              = trig.f2x2CellPhi ;
-  f4x4CellPhi              = trig.f4x4CellPhi ;
-  f2x2CellEta              = trig.f2x2CellEta ;
-  f4x4CellEta              = trig.f4x4CellEta ;
-  fADCValuesHigh4x4        = trig.fADCValuesHigh4x4 ; 
-  fADCValuesLow4x4         = trig.fADCValuesLow4x4  ; 
-  fADCValuesHigh2x2        = trig.fADCValuesHigh2x2 ; 
-  fADCValuesLow2x2         = trig.fADCValuesLow2x2  ;
-  fDigitsList              = trig.fDigitsList ;
-  fL0Threshold             = trig.fL0Threshold ; 
-  fL1JetLowPtThreshold     = trig.fL1JetLowPtThreshold ;
-  fL1JetMediumPtThreshold  = trig.fL1JetMediumPtThreshold ;
-  fL1JetHighPtThreshold    = trig.fL1JetHighPtThreshold ;
-  fSimulation              = trig.fSimulation ;
-
-
-
 }
 
 //----------------------------------------------------------------------
@@ -128,15 +121,15 @@ 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. 
-  
+
   //Declare and initialize variables
   Int_t nCellsPhi  = geom->GetNPhi()*2/geom->GetNTRUPhi() ;
-  if(isupermod > 10)
+  if(isupermod > 9)
     nCellsPhi =  nCellsPhi / 2 ; //Half size SM. Not Final.
   // 12(tow)*2(cell)/1 TRU, cells in Phi in one TRU
   Int_t nCellsEta  = geom->GetNEta()*2/geom->GetNTRUEta() ;
@@ -144,33 +137,34 @@ 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 ; 
-  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 < 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++)
       (*tru2x2)(i,j) = -1;
   
   //Loop over all TRUS in a supermodule
-  for(Int_t itru = 0 + (isupermod - 1) * nTRU ; itru < isupermod*nTRU ; itru++) {
+  for(Int_t itru = 0 + isupermod * nTRU ; itru < (isupermod+1)*nTRU ; itru++) {
     TMatrixD * amptru   = dynamic_cast<TMatrixD *>(amptrus->At(itru)) ;
     TMatrixD * timeRtru = dynamic_cast<TMatrixD *>(timeRtrus->At(itru)) ;
-    Int_t mtru = itru-(isupermod-1)*nTRU ; //Number of TRU in Supermodule
-    
+    Int_t mtru = itru-isupermod*nTRU ; //Number of TRU in Supermodule
+   
     //Sliding 2x2, add 2x2 amplitudes (NOT OVERLAP)
     for(Int_t irow = 0 ; irow <  nCellsPhi; irow += 2){ 
       for(Int_t icol = 0 ; icol < nCellsEta ; icol += 2){
        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)){
@@ -193,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);
+      }
   }
 }
 
@@ -238,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" );
@@ -270,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
@@ -290,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[4] < (*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");
@@ -330,31 +341,26 @@ void AliEMCALTrigger::SetTriggers(const Int_t iSM, const TMatrixD *ampmax2,
        break;
       }
     }
-    //    for(Int_t i = 0 ; i < nTimeBins ; i++)
-    //       if(fADCValuesLow2x2[i]!=0||fADCValuesHigh2x2[i]!=0)
-    //         cout<< "2x2 Time Bin "<<i
-    //             <<"; 2x2 Low Gain  "<<fADCValuesLow2x2[i]
-    //           <<"; 2x2 High Gain "<<fADCValuesHigh2x2[i]<<endl;
   }
   
-  //------------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; 
       }
@@ -362,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;
       }
@@ -370,16 +376,11 @@ 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;
       }
     }
- //    for(Int_t i = 0 ; i < nTimeBins ; i++)
-//       if(fADCValuesLow4x4[i]!= 100||fADCValuesHigh4x4[i] != 100)
-//             cout<< "4x4 Time Bin "<<i
-//                 <<"; 4x4 Low Gain  "<<fADCValuesLow4x4[i]
-//                 <<"; 4x4 High Gain "<<fADCValuesHigh4x4[i]<<endl;
   } 
 }
 
@@ -407,14 +408,13 @@ 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){
     rl->LoadDigits("EMCAL");
     fDigitsList = emcalLoader->Digits() ;
   }
-  cout<<"Simulation "<<fSimulation<<endl;
   if(!fDigitsList)
     AliFatal("Digits not found !") ;
   
@@ -423,18 +423,20 @@ void AliEMCALTrigger::Trigger()
   //Fill TRU Matrix  
   TClonesArray * amptrus   = new TClonesArray("TMatrixD",1000);
   TClonesArray * timeRtrus = new TClonesArray("TMatrixD",1000);
+
   geom->FillTRU(fDigitsList, amptrus, timeRtrus) ;
 
   //Do Cell Sliding and select 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 = 1 ; iSM <= nSuperModules ; iSM++) {
-    //Do 2x2 and 4x4 sums, select maximums. 
-    MakeSlidingCell(amptrus, timeRtrus, iSM, ampmax2, ampmax4, geom);
+  for(Int_t iSM = 0 ; iSM < nSuperModules ; iSM++) {
+    //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) ;
   }
 }