EMCAL/DCAL Trigger Mapping for Run 2
authorguernane <guernane@lpsc.in2p3.fr>
Mon, 12 Jan 2015 15:59:05 +0000 (16:59 +0100)
committerguernane <guernane@lpsc.in2p3.fr>
Mon, 12 Jan 2015 15:59:05 +0000 (16:59 +0100)
20 files changed:
EMCAL/EMCALUtils/AliEMCALEMCGeometry.cxx [changed mode: 0644->0755]
EMCAL/EMCALUtils/AliEMCALEMCGeometry.h [changed mode: 0644->0755]
EMCAL/EMCALUtils/AliEMCALGeometry.cxx [changed mode: 0644->0755]
EMCAL/EMCALUtils/AliEMCALGeometry.h [changed mode: 0644->0755]
EMCAL/EMCALUtils/AliEMCALTriggerMapping.cxx [new file with mode: 0644]
EMCAL/EMCALUtils/AliEMCALTriggerMapping.h [new file with mode: 0755]
EMCAL/EMCALUtils/AliEMCALTriggerMappingV1.cxx [new file with mode: 0755]
EMCAL/EMCALUtils/AliEMCALTriggerMappingV1.h [new file with mode: 0755]
EMCAL/EMCALUtils/AliEMCALTriggerMappingV2.cxx [new file with mode: 0644]
EMCAL/EMCALUtils/AliEMCALTriggerMappingV2.h [new file with mode: 0644]
EMCAL/EMCALUtils/CMakeLists.txt
EMCAL/EMCALUtils/EMCALUtilsLinkDef.h [changed mode: 0644->0755]
EMCAL/EMCALbase/AliEMCAL.h
EMCAL/EMCALbase/AliEMCALDigitizer.cxx [changed mode: 0644->0755]
EMCAL/EMCALbase/AliEMCALPreprocessor.cxx [changed mode: 0644->0755]
EMCAL/EMCALbase/AliEMCALTrigger.cxx [deleted file]
EMCAL/EMCALbase/AliEMCALTrigger.h [deleted file]
EMCAL/EMCALbase/AliEMCALTriggerRawDigitMaker.cxx
EMCAL/EMCALbase/CMakeLists.txt
EMCAL/EMCALbase/EMCALbaseLinkDef.h [changed mode: 0644->0755]

old mode 100644 (file)
new mode 100755 (executable)
index 73dc0f1..b4a61ed
@@ -94,9 +94,6 @@ AliEMCALEMCGeometry::AliEMCALEMCGeometry()
     fFrontSteelStrip(0.),fLateralSteelStrip(0.),fPassiveScintThick(0.),fPhiModuleSize(0.),
     fEtaModuleSize(0.),fPhiTileSize(0.),fEtaTileSize(0.),fLongModuleSize(0.),fPhiSuperModule(0),fNPhiSuperModule(0),
     fNPHIdiv(0),fNETAdiv(0), fNCells(0),fNCellsInSupMod(0),fNCellsInModule(0),
-    // Trigger staff
-    fNTRUEta(0), fNTRUPhi(0), fNModulesInTRUEta(0), fNModulesInTRUPhi(0), fNEtaSubOfTRU(0), fNTotalTRU(0),
-    // 
     fTrd1Angle(0.),f2Trd1Dx2(0.),fPhiGapForSM(0.),fKey110DEG(0),fnSupModInDCAL(0),fPhiBoundariesOfSM(0),
     fPhiCentersOfSM(0),fPhiCentersOfSMSec(0),fEtaMaxOfTRD1(0),fTrd1AlFrontThick(0.0), fTrd1BondPaperThick(0.),
     fCentersOfCellsEtaDir(0), fCentersOfCellsXDir(0),fCentersOfCellsPhiDir(0),
@@ -126,9 +123,6 @@ AliEMCALEMCGeometry::AliEMCALEMCGeometry(const Text_t* name, const Text_t* title
     fFrontSteelStrip(0.),fLateralSteelStrip(0.),fPassiveScintThick(0.),fPhiModuleSize(0.),
     fEtaModuleSize(0.),fPhiTileSize(0.),fEtaTileSize(0.),fLongModuleSize(0.),fPhiSuperModule(0),fNPhiSuperModule(0),
     fNPHIdiv(0),fNETAdiv(0), fNCells(0),fNCellsInSupMod(0),fNCellsInModule(0),
-    // Trigger staff
-    fNTRUEta(0), fNTRUPhi(0), fNModulesInTRUEta(0), fNModulesInTRUPhi(0), fNEtaSubOfTRU(0), fNTotalTRU(0),
-    // 
     fTrd1Angle(0.),f2Trd1Dx2(0.),fPhiGapForSM(0.),fKey110DEG(0),fnSupModInDCAL(0),fPhiBoundariesOfSM(0),
     fPhiCentersOfSM(0),fPhiCentersOfSMSec(0),fEtaMaxOfTRD1(0),fTrd1AlFrontThick(0.0), fTrd1BondPaperThick(0.),
     fCentersOfCellsEtaDir(0),fCentersOfCellsXDir(0),fCentersOfCellsPhiDir(0),
@@ -192,14 +186,6 @@ AliEMCALEMCGeometry::AliEMCALEMCGeometry(const AliEMCALEMCGeometry& geom)
     fNCells(geom.fNCells),
     fNCellsInSupMod(geom.fNCellsInSupMod),
     fNCellsInModule(geom.fNCellsInModule),
-    // Trigger staff
-    fNTRUEta(geom.fNTRUEta),
-    fNTRUPhi(geom.fNTRUPhi),
-    fNModulesInTRUEta(geom.fNModulesInTRUEta),
-    fNModulesInTRUPhi(geom.fNModulesInTRUPhi),
-    fNEtaSubOfTRU(geom.fNEtaSubOfTRU),
-    fNTotalTRU(geom.fNTotalTRU),
-    //
     fTrd1Angle(geom.fTrd1Angle),
     f2Trd1Dx2(geom.f2Trd1Dx2),
     fPhiGapForSM(geom.fPhiGapForSM),
@@ -553,31 +539,6 @@ void AliEMCALEMCGeometry::Init(const Text_t* mcname, const Text_t* mctitle){
   //called after setting of scintillator and lead layer parameters
   DefineSamplingFraction(mcname,mctitle);
 
-  
-  // TRU parameters - Apr 29,08 by PAI. 
-  // These parameters values was updated at Nov 05, 2007
-  // As is on Olivier  BOURRION (LPSC) ppt preasentation 
-  // at ALICE trigger meeting at 13th-14th March
-  fNTRUEta = 1;           // was 3
-  fNTRUPhi = 3;           // was 1
-  fNModulesInTRUEta = 24; // was 8
-  fNModulesInTRUPhi = 4;  // was 12
-  // Jet trigger 
-  // 3*6*10 + 2*6*2 = 204 -> matrix (nphi(17), neta(12))
-  fNEtaSubOfTRU     = 6;  
-
-  fNTotalTRU = 0;
-  for(Int_t i = 0; i < GetNumberOfSuperModules(); i++){
-    if(      GetSMType(i) == kEMCAL_Standard)  fNTotalTRU += 3;
-    else if( GetSMType(i) == kEMCAL_Half)      fNTotalTRU += 1;
-    else if( GetSMType(i) == kEMCAL_3rd)       fNTotalTRU += 1;
-    else if( GetSMType(i) == kDCAL_Standard)   fNTotalTRU += 3;
-    else if( GetSMType(i) == kDCAL_Ext)        fNTotalTRU += 1;
-    else {
-      AliError(Form("Uknown SuperModule Type !!"));
-    }
-  }
-
   fgInit = kTRUE; 
 }
 
old mode 100644 (file)
new mode 100755 (executable)
index 40812b1..176013e
@@ -110,16 +110,7 @@ public:
   Int_t   GetKey110DEG()      const {return fKey110DEG;}
   Int_t   GetnSupModInDCAL()      const {return fnSupModInDCAL;}
   Int_t   GetILOSS() const {return fILOSS;}
-  Int_t   GetIHADR() const {return fIHADR;}
-    // For gamma(Jet) trigger simulations
-  Int_t    GetNTRU() const    {return fNTRUEta*fNTRUPhi ; }  
-  Int_t    GetNTRUEta() const {return fNTRUEta ; }  
-  Int_t    GetNTRUPhi() const {return fNTRUPhi ; }
-  Int_t    GetNEtaSubOfTRU() const {return fNEtaSubOfTRU;}
-  Int_t    GetNTotalTRU() const {return fNTotalTRU ; }
-  Int_t    GetNModulesInTRU() const {return fNModulesInTRUEta*fNModulesInTRUPhi; }
-  Int_t    GetNModulesInTRUEta() const {return fNModulesInTRUEta ; }  
-  Int_t    GetNModulesInTRUPhi() const {return fNModulesInTRUPhi ; }  
+  Int_t   GetIHADR() const {return fIHADR;}  
 
   // --
   Float_t  GetDeltaEta() const {return (fArm1EtaMax-fArm1EtaMin)/ ((Float_t)fNZ);}
@@ -152,10 +143,6 @@ public:
                          printf("SetNZ: Number of modules in Z set to %d", fNZ) ; }
   void SetNPhi(Int_t nphi) { fNPhi= nphi; 
                              printf("SetNPhi: Number of modules in Phi set to %d", fNPhi) ; }
-  void SetNTRUEta(Int_t ntru) {fNTRUEta = ntru;
-               printf("SetNTRU: Number of TRUs per SuperModule in Eta set to %d", fNTRUEta) ;}
-  void SetNTRUPhi(Int_t ntru) {fNTRUPhi = ntru;
-              printf("SetNTRU: Number of TRUs per SuperModule in Phi set to %d", fNTRUPhi) ;}
   void SetSampling(Float_t samp) { fSampling = samp; 
                               printf("SetSampling: Sampling factor set to %f", fSampling) ; }
 
@@ -237,13 +224,6 @@ private:
   Int_t   fNCells;                       // number of cells in calo
   Int_t   fNCellsInSupMod;               // number cell in super module
   Int_t   fNCellsInModule;               // number cell in module)
-  //TRU parameters
-  Int_t   fNTRUEta ;                     // Number of TRUs per module in eta
-  Int_t   fNTRUPhi ;                     // Number of TRUs per module in phi
-  Int_t   fNModulesInTRUEta;             // Number of modules per TRU in eta 
-  Int_t   fNModulesInTRUPhi;             // Number of modules per TRU in phi 
-  Int_t   fNEtaSubOfTRU;                 // Number of eta (z) subregiohi
-  Int_t   fNTotalTRU;                   // Total Number of TRU (all SM)
 
   // TRD1 options - 30-sep-04
   Float_t fTrd1Angle;                    // angle in x-z plane (in degree) 
old mode 100644 (file)
new mode 100755 (executable)
index 18c5c80..84e2ee4
 #include "AliLog.h"
 #include "AliEMCALGeometry.h"
 #include "AliEMCALShishKebabTrd1Module.h"
+#include "AliEMCALTriggerMappingV1.h"
+#include "AliEMCALTriggerMappingV2.h"
 
 ClassImp(AliEMCALGeometry)
 
@@ -125,7 +127,7 @@ const Char_t*      AliEMCALGeometry::fgkDefaultGeometryName = "EMCAL_COMPLETE12S
 
 //____________________________________________________________________________
 AliEMCALGeometry::AliEMCALGeometry():
-  fEMCGeometry(0x0),fGeoName(0),fEMCSMSystem(0x0),
+  fEMCGeometry(0x0),fTriggerMapping(0x0),fGeoName(0),fEMCSMSystem(0x0),
   fKey110DEG(0),fnSupModInDCAL(0),fNCellsInSupMod(0),fNETAdiv(0),fNPHIdiv(0),
   fNCellsInModule(0),fPhiBoundariesOfSM(0x0),fPhiCentersOfSM(0x0),
   fPhiCentersOfSMSec(0x0),fPhiCentersOfCells(0x0),fCentersOfCellsEtaDir(0x0),
@@ -148,15 +150,12 @@ AliEMCALGeometry::AliEMCALGeometry():
   fParSM[2]   = 0.;
   for (Int_t i=0;i<AliEMCALGeoParams::fgkEMCALModules;i++)
     fkSModuleMatrix[i]=0 ;
-
-  for (Int_t i = 0; i < 48; i++)
-   for (Int_t j = 0; j < 124; j++) fFastOR2DMap[i][j] = -1;
 }  
 
 //____________________________________________________________________________
 AliEMCALGeometry::AliEMCALGeometry(const AliEMCALGeometry & geo)
   : TNamed(geo),
-    fEMCGeometry(geo.fEMCGeometry),fGeoName(geo.fGeoName),fEMCSMSystem(geo.fEMCSMSystem),
+    fEMCGeometry(geo.fEMCGeometry),fTriggerMapping(geo.fTriggerMapping),fGeoName(geo.fGeoName),fEMCSMSystem(geo.fEMCSMSystem),
     fKey110DEG(geo.fKey110DEG),fnSupModInDCAL(geo.fnSupModInDCAL),fNCellsInSupMod(geo.fNCellsInSupMod),fNETAdiv(geo.fNETAdiv),fNPHIdiv(geo.fNPHIdiv),
     fNCellsInModule(geo.fNCellsInModule),fPhiBoundariesOfSM(geo.fPhiBoundariesOfSM),fPhiCentersOfSM(geo.fPhiCentersOfSM),
     fPhiCentersOfSMSec(geo.fPhiCentersOfSMSec),fPhiCentersOfCells(geo.fPhiCentersOfCells),fCentersOfCellsEtaDir(geo.fCentersOfCellsEtaDir),
@@ -178,16 +177,13 @@ AliEMCALGeometry::AliEMCALGeometry(const AliEMCALGeometry & geo)
   fParSM[2]   = geo.fParSM[2];
   for (Int_t i=0;i<AliEMCALGeoParams::fgkEMCALModules;i++)
     fkSModuleMatrix[i]=0 ;
-  
-  for (Int_t i = 0; i < 48; i++)
-    for (Int_t j = 0; j < 124; j++) fFastOR2DMap[i][j] = geo.fFastOR2DMap[i][j];
 }
 
 //____________________________________________________________________________
 AliEMCALGeometry::AliEMCALGeometry(const Text_t* name,   const Text_t* title,
                                    const Text_t* mcname, const Text_t* mctitle) 
   : TNamed(name, title),
-    fEMCGeometry(0x0),fGeoName(0),fEMCSMSystem(0x0),
+    fEMCGeometry(0x0),fTriggerMapping(0x0),fGeoName(0),fEMCSMSystem(0x0),
     fKey110DEG(0),fnSupModInDCAL(0),fNCellsInSupMod(0),fNETAdiv(0),fNPHIdiv(0),
     fNCellsInModule(0),fPhiBoundariesOfSM(0x0),fPhiCentersOfSM(0x0),
     fPhiCentersOfSMSec(0x0),fPhiCentersOfCells(0x0),fCentersOfCellsEtaDir(0x0),
@@ -266,11 +262,12 @@ AliEMCALGeometry::AliEMCALGeometry(const Text_t* name,   const Text_t* title,
     fEMCGeometry->Print();
     PrintGeometryGeoUtils();
   }
-
-  for (Int_t ix = 0; ix < 48; ix++)
-       for(Int_t jx = 0; jx < 124; jx++) fFastOR2DMap[ix][jx] = -1;
-
-  BuildFastOR2DMap();
+  
+  if ((fEMCGeometry->GetGeoName()).Contains("DCAL")) {
+    fTriggerMapping = new AliEMCALTriggerMappingV2(46, this);
+  } else { 
+    fTriggerMapping = new AliEMCALTriggerMappingV1(32, this);
+  }
 }
 
 //____________________________________________________________________________
@@ -303,6 +300,8 @@ AliEMCALGeometry::~AliEMCALGeometry(void)
     
     delete fEMCGeometry; // fEMCGeometry = 0 ;
   }
+  
+  if (fTriggerMapping) delete fTriggerMapping;
 }
 
 //______________________________________________________________________
@@ -1202,370 +1201,6 @@ Int_t AliEMCALGeometry::IsInEMCALOrDCAL(Double_t x, Double_t y, Double_t z) cons
   } 
 }
 
-//________________________________________________________________________________________________
-Int_t AliEMCALGeometry::GetAbsTRUNumberFromNumberInSm(const Int_t row, const Int_t col, const Int_t sm) const
-{ 
-  // Nov 6, 2007
-  // Get TRU absolute number from column, row and Super Module number
-  Int_t itru = row + col*fEMCGeometry->GetNModulesInTRUPhi() + sm*fEMCGeometry->GetNTRU();
-  // printf("  GetAbsTRUNumberFromNumberInSm : row %2i col %2i sm %2i -> itru %2i\n", row, col, sm, itru); 
-  return itru;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetAbsFastORIndexFromTRU(const Int_t iTRU, const Int_t iADC, Int_t& id) const
-{
-  //Trigger mapping method, get  FastOr Index from TRU
-
-  if (iTRU > GetNTotalTRU()-1 || iTRU < 0 || iADC > 95 || iADC < 0) 
-  {
-    AliError("TRU out of range!");
-    return kFALSE;
-  }
-       
-  id  = ( iTRU % 2 ) ? iADC%4 + 4 * (23 - int(iADC/4)) : (3 - iADC%4) + 4 * int(iADC/4);
-  id += iTRU * 96;
-  return kTRUE;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iADC) const
-{
-  //Trigger mapping method, get TRU number from FastOr Index
-
-  Int_t nModule = GetNTotalTRU()*96;
-  if (id > nModule-1 || id < 0)
-  {
-    AliError("Id out of range!");
-    return kFALSE;
-  }
-       
-  iTRU = id / 96;
-  iADC = id % 96;
-  iADC = ( iTRU % 2 ) ? iADC%4 + 4 * (23 - int(iADC/4)) : (3 - iADC%4) + 4 * int(iADC/4);
-  return kTRUE;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetPositionInTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iEta, Int_t& iPhi) const
-{
-  //Trigger mapping method, get position in TRU from FasOr Index
-       
-  Int_t iADC=-1;       
-  if (!GetTRUFromAbsFastORIndex(id, iTRU, iADC)) return kFALSE;
-       
-  Int_t x = iADC / 4;
-  Int_t y = iADC % 4;
-  if ( iTRU % 2 ) // C side 
-  {
-    iEta = 23 - x;
-    iPhi =      y;
-  }
-  else            // A side
-  {
-    iEta =      x;
-    iPhi =  3 - y;
-  }
-  return kTRUE;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetPositionInSMFromAbsFastORIndex(const Int_t id, Int_t& iSM, Int_t& iEta, Int_t& iPhi) const
-{
-  //Trigger mapping method, get position in Super Module from FasOr Index
-
-  Int_t iTRU=-1;
-  if (!GetPositionInTRUFromAbsFastORIndex(id, iTRU, iEta, iPhi)) return kFALSE;
-  if (iTRU % 2) // C side
-  {
-    iSM  = 2 * ( int( int(iTRU / 2) / 3 ) ) + 1;
-  }
-  else            // A side
-  {
-    iSM  = 2 * ( int( int(iTRU / 2) / 3 ) );
-  }
-  iPhi += 4 * int((iTRU % 6) / 2);
-  return kTRUE;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetPositionInEMCALFromAbsFastORIndex(const Int_t id, Int_t& iEta, Int_t& iPhi) const
-{
-  //Trigger mapping method, get position in EMCAL from FastOR index
-
-  Int_t iSM=-1;
-  if (GetPositionInSMFromAbsFastORIndex(id, iSM, iEta, iPhi))
-  {
-    if (iSM % 2) iEta += 24; 
-    iPhi += 12 * int(iSM / 2);
-    return kTRUE;
-  }
-  return kFALSE;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetAbsFastORIndexFromPositionInTRU(const Int_t iTRU, const Int_t iEta, const Int_t iPhi, Int_t& id) const
-{
-  //Trigger mapping method, get Index if FastOr from Position in TRU
-  if (iTRU < 0 || iTRU > GetNTotalTRU()-1 || iEta < 0 || iEta > 23 || iPhi < 0 || iPhi > 3) 
-  {
-    AliError(Form("Out of range! iTRU=%d, iEta=%d, iPhi=%d", iTRU, iEta, iPhi));       
-    return kFALSE;
-  }
-  id =  iPhi  + 4 * iEta + iTRU * 96;
-  return kTRUE;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetAbsFastORIndexFromPositionInSM(const Int_t  iSM, const Int_t iEta, const Int_t iPhi, Int_t& id) const
-{
-  //Trigger mapping method, from position in SM Index get FastOR index 
-
-  Int_t iSMMax  = fEMCGeometry->GetNumberOfSuperModules();
-  Int_t iEtaMax = fEMCGeometry->GetNZ();
-  Int_t iPhiMax = fEMCGeometry->GetNPhi();
-  if( GetSMType(iSM) == kEMCAL_3rd || GetSMType(iSM) == kDCAL_Ext ) iPhiMax /= 3;
-  if( GetSMType(iSM) == kEMCAL_Half )                               iPhiMax /= 2;
-  if( GetSMType(iSM) == kDCAL_Standard )                            iEtaMax = iEtaMax*2/3;
-
-  if (iSM < 0 || iSM >= iSMMax || iEta < 0 || iEta >= iEtaMax || iPhi < 0 || iPhi >= iPhiMax) 
-  {
-    AliError("Out of range!");
-    return kFALSE;
-  }
-  Int_t x = iEta;
-  Int_t y = iPhi % 4;  
-  Int_t iOff = (iSM % 2) ? 1 : 0;
-  Int_t iTRU = 2 * int(iPhi / 4) + 6 * int(iSM / 2) + iOff;
-  if(IsDCALSM(iSM) ) iTRU -=4;
-  if (GetAbsFastORIndexFromPositionInTRU(iTRU, x, y, id))
-  {
-    return kTRUE;
-  }
-  return kFALSE;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetAbsFastORIndexFromPositionInEMCAL(const Int_t iEta, const Int_t iPhi, Int_t& id) const
-{
-  //Trigger mapping method, from position in EMCAL Index get FastOR index 
-
-  if (iEta < 0 || iEta > 47 || iPhi < 0 || iPhi >= 2*GetNTotalTRU() )//for future DCAL trigge
-  {
-    AliError(Form("Out of range! eta: %2d phi: %2d", iEta, iPhi));
-    return kFALSE;
-  }
-  if (fFastOR2DMap[iEta][iPhi] == -1) 
-  {
-    AliError("Invalid index!");
-    return kFALSE;
-  }
-  id = fFastOR2DMap[iEta][iPhi];
-  return kTRUE;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetFastORIndexFromCellIndex(const Int_t id, Int_t& idx) const
-{
-  //Trigger mapping method, from cell index get FastOR index 
-
-  Int_t iSupMod, nModule, nIphi, nIeta, iphim, ietam;
-  Bool_t isOK = GetCellIndex( id, iSupMod, nModule, nIphi, nIeta );
-  GetModulePhiEtaIndexInSModule( iSupMod, nModule, iphim, ietam );
-  if (isOK && GetAbsFastORIndexFromPositionInSM(iSupMod, ietam, iphim, idx))
-  {
-    return kTRUE;
-  }
-  return kFALSE;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetCellIndexFromFastORIndex(const Int_t id, Int_t idx[4]) const
-{
-  //Trigger mapping method, from FASTOR index get cell index 
-
-  Int_t iSM=-1, iEta=-1, iPhi=-1;
-  if (GetPositionInSMFromAbsFastORIndex(id, iSM, iEta, iPhi))
-  {
-    Int_t ix = 2 * iEta;
-    Int_t iy = 2 * iPhi;
-    for (Int_t i=0; i<2; i++)
-    {
-      for (Int_t j=0; j<2; j++)
-      {
-        idx[2*i+j] = GetAbsCellIdFromCellIndexes(iSM, iy + i, ix + j);
-      }
-    }
-    return kTRUE;
-  }
-  return kFALSE;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetTRUIndexFromSTUIndex(const Int_t id, Int_t& idx) const
-{
-  //Trigger mapping method, from STU index get TRU index 
-
-   idx = GetTRUIndexFromSTUIndex(id);
-   if (idx > GetNTotalTRU()-1 || idx < 0)
-   {
-     AliError(Form("TRU index out of range: %d",idx));
-     return kFALSE;
-   }
-   return kTRUE;
-}
-
-//________________________________________________________________________________________________
-Int_t AliEMCALGeometry::GetTRUIndexFromSTUIndex(const Int_t id) const
-{
-  //Trigger mapping method, from STU index get TRU index 
-
-  if (id > GetNTotalTRU()-1 || id < 0) 
-  {
-    AliError(Form("TRU index out of range: %d",id));
-  }
-
-  Int_t idx = 0;
-  if(id < 32){
-    idx = (id > 15) ? 2 * (31 - id) : 2 * (15 - id) + 1;
-  } else if(id >= 32){// DCAL
-    idx = (id > 32+3*fnSupModInDCAL/2-1) ? 2 * (GetNTotalTRU()-1 - id)+32 : 2 * (32+3*fnSupModInDCAL/2-1 - id) + 32+1;
-  }
-  return idx;
-}
-
-//________________________________________________________________________________________________
-void AliEMCALGeometry::BuildFastOR2DMap()
-{
-  // Needed by STU
-
-  for (Int_t i = 0; i < GetNTotalTRU(); i++)
-  {
-    for (Int_t j = 0; j < 24; j++)
-    {
-      for (Int_t k = 0; k < 4; k++)
-      {
-        Int_t id;
-        if (GetAbsFastORIndexFromPositionInTRU(i, j, k, id))
-        {
-          Int_t x = j, y = k + 4 * int(i / 2);
-          if (i % 2) x += 24;
-          fFastOR2DMap[x][y] = id;
-        }
-      }                        
-    }
-  }
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetTRUIndexFromOnlineIndex(const Int_t id, Int_t& idx) const
-{
-  //Trigger mapping method, from STU index get TRU index 
-
-   idx = GetOnlineIndexFromTRUIndex(id);
-   if (idx > GetNTotalTRU()-1 || idx < 0)
-   {
-     AliError(Form("TRU index out of range: %d",idx));
-     return kFALSE;
-   }
-   return kTRUE;
-}
-
-//________________________________________________________________________________________________
-Int_t AliEMCALGeometry::GetTRUIndexFromOnlineIndex(const Int_t id) const
-{
-  //Trigger mapping method, from STU index get TRU index 
-       
-  if (id > GetNTotalTRU()-1 || id < 0) 
-  {
-    AliError(Form("TRU index out of range: %d",id));
-  }
-  if (id == 31) {
-    return 31;
-  }
-  if (fGeoName.Contains("DCAL_8SM") && id == 51) {
-    return 51;
-  }
-
-  //jump 4 TRUs for DCAL
-  Int_t tmp=0;
-  if(id > 31) tmp = id+4;
-  else        tmp = id;
-  Int_t idx = ((tmp% 6) < 3) ? 6 * int(tmp/ 6) + 2 * (tmp% 3) : 6 * int(tmp/ 6) + 2 * (2 - (tmp% 3)) + 1;
-  if(id > 31) idx-=4;
-  return idx;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetOnlineIndexFromTRUIndex(const Int_t id, Int_t& idx) const
-{
-  //Trigger mapping method, from STU index get TRU index 
-    idx = GetOnlineIndexFromTRUIndex(id);
-    if (idx > GetNTotalTRU()-1 || idx < 0)
-   {
-     AliError(Form("TRU index out of range: %d",idx));
-     return kFALSE;
-   }
-   return kTRUE;
-}
-//________________________________________________________________________________________________
-Int_t AliEMCALGeometry::GetOnlineIndexFromTRUIndex(const Int_t id) const
-{
-  //Trigger mapping method, from STU index get TRU index 
-       
-  if (id > GetNTotalTRU()-1 || id < 0) 
-  {
-    AliError(Form("TRU index out of range: %d",id));
-  }
-  if (id == 31) {
-    return 31;
-  }
-  if (fGeoName.Contains("DCAL_8SM") && id == 51) {
-    return 51;
-  }
-
-  //jump 4 TRUs for DCAL
-  Int_t tmp=0;
-  if(id > 31) tmp = id+4;
-  else        tmp = id;
-  Int_t idx = (tmp % 2) ? int((6 - (tmp % 6)) / 2) + 3 * (2 * int(tmp / 6) + 1) : 3 * int(tmp / 6) + int(tmp / 2);
-  if(id > 31) idx-=4;
-  return idx;
-}
-
-//________________________________________________________________________________________________
-Bool_t AliEMCALGeometry::GetFastORIndexFromL0Index(const Int_t iTRU, const Int_t id, Int_t idx[], const Int_t size) const
-{
-  //Trigger mapping method, from L0 index get FastOR index 
-
-  if (size <= 0 ||size > 4)
-  {
-    AliError("Size not supported!");
-    return kFALSE;
-  }
-               
-  Int_t motif[4] = {0, 1, 4, 5};
-  switch (size)
-  {
-    case 1: // Cosmic trigger
-      if (!GetAbsFastORIndexFromTRU(iTRU, id, idx[1])) return kFALSE;
-      break;
-    case 4: // 4 x 4
-      for (Int_t k = 0; k < 4; k++)
-      {
-        Int_t iADC = motif[k] + 4 * int(id / 3) + (id % 3);
-                               
-        if (!GetAbsFastORIndexFromTRU(iTRU, iADC, idx[k])) return kFALSE;
-      }
-      break;
-    default:
-      break;
-  }
-       
-  return kTRUE;
-}
-
 //____________________________________________________________________________
 const TGeoHMatrix * AliEMCALGeometry::GetMatrixForSuperModule(Int_t smod) const 
 {
@@ -1632,22 +1267,6 @@ const TGeoHMatrix * AliEMCALGeometry::GetMatrixForSuperModule(Int_t smod) const
   return 0 ;
 }
 
-//______________________________________________________________________
-void AliEMCALGeometry::GetModulePhiEtaIndexInSModuleFromTRUIndex(Int_t itru, Int_t iphitru, Int_t ietatru, Int_t &iphiSM, Int_t &ietaSM) const 
-{
-  // This method transforms the (eta,phi) index of module in a 
-  // TRU matrix into Super Module (eta,phi) index.
-  
-  // Calculate in which row and column where the TRU are 
-  // ordered in the SM
-
-  Int_t col = itru/fEMCGeometry->GetNTRUPhi() ; // indexes of TRU in SM
-  Int_t row = itru - col*fEMCGeometry->GetNTRUPhi();
-   
-  iphiSM = fEMCGeometry->GetNModulesInTRUPhi()*row + iphitru  ;
-  ietaSM = fEMCGeometry->GetNModulesInTRUEta()*col + ietatru  ; 
-}
-
 //__________________________________________________________________________________________________________________
 void AliEMCALGeometry::RecalculateTowerPosition(Float_t drow, Float_t dcol, const Int_t sm, const Float_t depth,
                                                 const Float_t misaligTransShifts[15], const Float_t misaligRotShifts[15], Float_t global[3]) const
old mode 100644 (file)
new mode 100755 (executable)
index e37eab1..c268033
@@ -28,6 +28,7 @@ class TParticle ;
 // --- AliRoot header files ---
 #include "AliEMCALEMCGeometry.h"
 #include "AliEMCALGeoParams.h"
+#include "AliEMCALTriggerMapping.h"
 class AliEMCALShishKebabTrd1Module;
 class AliLog;
 
@@ -78,6 +79,9 @@ public:
   //
   
   AliEMCALEMCGeometry* GetEMCGeometry()       const { return fEMCGeometry                            ; }
+  
+  AliEMCALTriggerMapping* GetTriggerMapping() const { return fTriggerMapping; }
+  
   //
   const Char_t*  GetNameOfEMCALEnvelope(void) const { return fEMCGeometry->GetNameOfEMCALEnvelope()  ; }
   Float_t  GetArm1PhiMin(void)                const { return fEMCGeometry->GetArm1PhiMin()           ; }
@@ -164,9 +168,6 @@ public:
   //
   void SetNZ(Int_t nz)           { fEMCGeometry->SetNZ(nz)         ; }
   void SetNPhi(Int_t nphi)       { fEMCGeometry->SetNPhi(nphi)     ; }
-  //Trigger
-  void SetNTRUEta(Int_t ntru)    { fEMCGeometry->SetNTRUEta(ntru)  ; }
-  void SetNTRUPhi(Int_t ntru)    { fEMCGeometry->SetNTRUPhi(ntru)  ; }
   //
   void SetSampling(Float_t samp) { fEMCGeometry->SetSampling(samp) ; }
   //
@@ -245,44 +246,6 @@ public:
   //
   TArrayD  GetEtaCentersOfCells()    const { return fEtaCentersOfCells    ; }     // [fNEta*fNETAdiv*fNPhi*fNPHIdiv], positive direction (eta>0); eta depend from phi position; 
   TArrayD  GetPhiCentersOfCells()    const { return fPhiCentersOfCells    ; }     // [fNPhi*fNPHIdiv] from center of SM (-10. < phi < +10.)
-
-  
-  // For gamma(Jet) trigger simulations *FIXME OLD TO BE REMOVED with AliEMCALTrigger*
-  Int_t    GetNTRU()             const { return fEMCGeometry->GetNTRU()             ; }  
-  Int_t    GetNTRUEta()          const { return fEMCGeometry->GetNTRUEta()          ; }  
-  Int_t    GetNTRUPhi()          const { return fEMCGeometry->GetNTRUPhi()          ; }
-  Int_t    GetNEtaSubOfTRU()     const { return fEMCGeometry->GetNEtaSubOfTRU()     ; }
-  Int_t    GetNModulesInTRU()    const { return fEMCGeometry->GetNModulesInTRU()    ; }
-  Int_t    GetNModulesInTRUEta() const { return fEMCGeometry->GetNModulesInTRUEta() ; }  
-  Int_t    GetNModulesInTRUPhi() const { return fEMCGeometry->GetNModulesInTRUPhi() ; }
-  Int_t    GetNTotalTRU()        const {return  fEMCGeometry->GetNTotalTRU()        ; }
-  // *MEFIX OLD TO BE REMOVED*
-
-  //
-  // Tranforms Eta-Phi Module index in TRU into Eta-Phi index in Super Module
-  void     GetModulePhiEtaIndexInSModuleFromTRUIndex(Int_t itru, Int_t iphitru, Int_t ietatru, 
-                                                     Int_t &ietaSM, Int_t &iphiSM) const;
-  Int_t   GetAbsTRUNumberFromNumberInSm(const Int_t row, const Int_t col, const Int_t sm) const ;
-
-       
-  void     BuildFastOR2DMap();
-  Bool_t   GetAbsFastORIndexFromTRU(const Int_t iTRU, const Int_t iADC, Int_t& id) const;
-  Bool_t                    GetAbsFastORIndexFromPositionInTRU(const Int_t iTRU, const Int_t iEta, const Int_t iPhi, Int_t& id) const; 
-  Bool_t                    GetAbsFastORIndexFromPositionInSM( const Int_t  iSM, const Int_t iEta, const Int_t iPhi, Int_t& id) const; 
-  Bool_t                    GetAbsFastORIndexFromPositionInEMCAL(                const Int_t iEta, const Int_t iPhi, Int_t& id) const;
-  Bool_t             GetTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iADC) const;
-  Bool_t   GetPositionInTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iEta, Int_t& iPhi) const;
-  Bool_t    GetPositionInSMFromAbsFastORIndex(const Int_t id, Int_t& iSM, Int_t& iEta, Int_t& iPhi) const;
-  Bool_t GetPositionInEMCALFromAbsFastORIndex(const Int_t id, Int_t& iEta, Int_t& iPhi) const;
-  Bool_t          GetFastORIndexFromCellIndex(const Int_t id, Int_t& idx) const;
-  Bool_t          GetCellIndexFromFastORIndex(const Int_t id, Int_t idx[4]) const;
-  Bool_t              GetTRUIndexFromSTUIndex(const Int_t id, Int_t& idx) const;
-  Int_t               GetTRUIndexFromSTUIndex(const Int_t id) const;
-  Bool_t           GetTRUIndexFromOnlineIndex(const Int_t id, Int_t& idx) const;
-  Int_t            GetTRUIndexFromOnlineIndex(const Int_t id) const;
-  Bool_t           GetOnlineIndexFromTRUIndex(const Int_t id, Int_t& idx) const;
-  Int_t            GetOnlineIndexFromTRUIndex(const Int_t id) const;
-  Bool_t            GetFastORIndexFromL0Index(const Int_t iTRU, const Int_t id, Int_t idx[], const Int_t size) const;
        
   ///////////////////
   // useful utilities
@@ -305,12 +268,70 @@ public:
   //Returns shift-rotational matrixes for different volumes
   const TGeoHMatrix * GetMatrixForSuperModule(Int_t smod)const ;
        
+  Bool_t GetAbsFastORIndexFromTRU(const Int_t iTRU, const Int_t iADC, Int_t& id) const { 
+    return fTriggerMapping->GetAbsFastORIndexFromTRU(iTRU, iADC, id);
+  }
+  Bool_t GetAbsFastORIndexFromPositionInTRU(const Int_t iTRU, const Int_t iEta, const Int_t iPhi, Int_t& id) const { 
+    return fTriggerMapping->GetAbsFastORIndexFromPositionInTRU(iTRU, iEta, iPhi, id);
+  }
+  Bool_t GetAbsFastORIndexFromPositionInSM(const Int_t  iSM, const Int_t iEta, const Int_t iPhi, Int_t& id) const { 
+    return fTriggerMapping->GetAbsFastORIndexFromPositionInSM( iSM, iEta, iPhi, id);
+  }
+  Bool_t GetAbsFastORIndexFromPositionInEMCAL(const Int_t iEta, const Int_t iPhi, Int_t& id) const { 
+    return fTriggerMapping->GetAbsFastORIndexFromPositionInEMCAL(iEta, iPhi, id);
+  }
+  Bool_t GetTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iADC) const { 
+    return fTriggerMapping->GetTRUFromAbsFastORIndex(id, iTRU, iADC);
+  }
+  Bool_t GetPositionInTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iEta, Int_t& iPhi) const { 
+    return fTriggerMapping->GetPositionInTRUFromAbsFastORIndex(id, iTRU, iEta, iPhi);
+  }
+  Bool_t GetPositionInSMFromAbsFastORIndex(const Int_t id, Int_t& iSM, Int_t& iEta, Int_t& iPhi) const { 
+    return fTriggerMapping->GetPositionInSMFromAbsFastORIndex(id, iSM, iEta, iPhi);
+  }
+  Bool_t GetPositionInEMCALFromAbsFastORIndex(const Int_t id, Int_t& iEta, Int_t& iPhi) const { 
+    return fTriggerMapping->GetPositionInEMCALFromAbsFastORIndex(id, iEta, iPhi);
+  }
+  Bool_t GetFastORIndexFromCellIndex(const Int_t id, Int_t& idx) const { 
+    return fTriggerMapping->GetFastORIndexFromCellIndex(id, idx);
+  }
+  Bool_t GetCellIndexFromFastORIndex(const Int_t id, Int_t idx[4]) const { 
+    return fTriggerMapping->GetCellIndexFromFastORIndex(id, idx);
+  }
+  Bool_t GetTRUIndexFromSTUIndex(const Int_t id, Int_t& idx) const { 
+    return fTriggerMapping->GetTRUIndexFromSTUIndex(id, idx);
+  }
+  Bool_t GetTRUIndexFromOnlineIndex(const Int_t id, Int_t& idx) const { 
+    return fTriggerMapping->GetTRUIndexFromOnlineIndex(id, idx);
+  }
+  Bool_t GetOnlineIndexFromTRUIndex(const Int_t id, Int_t& idx) const { 
+    return fTriggerMapping->GetOnlineIndexFromTRUIndex(id, idx);
+  }
+  Bool_t GetFastORIndexFromL0Index(const Int_t iTRU, const Int_t id, Int_t idx[], const Int_t size) const { 
+    return fTriggerMapping->GetFastORIndexFromL0Index(iTRU, id, idx, size);
+  }
+  Int_t  GetTRUIndexFromSTUIndex(const Int_t id) const { 
+    return fTriggerMapping->GetTRUIndexFromSTUIndex(id);
+  }
+  Int_t  GetTRUIndexFromOnlineIndex(const Int_t id) const { 
+    return fTriggerMapping->GetTRUIndexFromOnlineIndex(id);
+  }
+  Int_t  GetOnlineIndexFromTRUIndex(const Int_t id) const {
+    return fTriggerMapping->GetOnlineIndexFromTRUIndex(id);
+  }
+  Int_t  GetNTotalTRU() const { 
+    return fTriggerMapping->GetNTRU(); 
+  }
+
+  
 protected:
 
   void Init(void);                          // initializes the parameters of EMCAL
   
   AliEMCALEMCGeometry * fEMCGeometry;// Geometry object for Electromagnetic calorimeter
 
+  AliEMCALTriggerMapping* fTriggerMapping; // Trigger mapping
+  
   TString  fGeoName;                 // geometry name
   Int_t    *fEMCSMSystem;                 // geometry structure
   Int_t    fKey110DEG;               // for calculation abs cell id; 19-oct-05 
@@ -354,8 +375,6 @@ protected:
   Float_t  fShellThickness;             // Total thickness in (x,y) direction
   Float_t  fZLength;                        // Total length in z direction
   Float_t  fSampling;                       // Sampling factor
-
-  Int_t    fFastOR2DMap[48][124];    // FastOR 2D Map over full EMCal
        
   TGeoHMatrix* fkSModuleMatrix[AliEMCALGeoParams::fgkEMCALModules] ; //Orientations of EMCAL super modules
   Bool_t   fUseExternalMatrices;      // Use the matrices set in fkSModuleMatrix and not those in the geoManager
diff --git a/EMCAL/EMCALUtils/AliEMCALTriggerMapping.cxx b/EMCAL/EMCALUtils/AliEMCALTriggerMapping.cxx
new file mode 100644 (file)
index 0000000..82200f8
--- /dev/null
@@ -0,0 +1 @@
+//implementation file
diff --git a/EMCAL/EMCALUtils/AliEMCALTriggerMapping.h b/EMCAL/EMCALUtils/AliEMCALTriggerMapping.h
new file mode 100755 (executable)
index 0000000..a0a3ad1
--- /dev/null
@@ -0,0 +1,58 @@
+#ifndef ALIEMCALTRIGGERMAPPING_H
+#define ALIEMCALTRIGGERMAPPING_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/*
+Mapping ABC 
+Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+#ifndef ROOT_TObject
+#  include "TObject.h"
+#endif
+
+class AliEMCALGeometry;
+
+class AliEMCALTriggerMapping : public TObject 
+{
+public:
+           AliEMCALTriggerMapping() : fNTRU(0), fGeometry(0x0) {}
+           AliEMCALTriggerMapping(const Int_t ntru, const AliEMCALGeometry* geo) : fNTRU(ntru), fGeometry(geo) {}
+  virtual ~AliEMCALTriggerMapping() {}
+  
+  virtual Bool_t GetAbsFastORIndexFromTRU(const Int_t iTRU, const Int_t iADC, Int_t& id)                             const = 0;
+  virtual Bool_t GetAbsFastORIndexFromPositionInTRU(const Int_t iTRU, const Int_t iEta, const Int_t iPhi, Int_t& id) const = 0;
+  virtual Bool_t GetAbsFastORIndexFromPositionInSM(const Int_t  iSM, const Int_t iEta, const Int_t iPhi, Int_t& id)  const = 0;
+  virtual Bool_t GetAbsFastORIndexFromPositionInEMCAL(const Int_t iEta, const Int_t iPhi, Int_t& id)                 const = 0;
+  virtual Bool_t GetTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iADC)                                  const = 0;
+  virtual Bool_t GetPositionInTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iEta, Int_t& iPhi)           const = 0;
+  virtual Bool_t GetPositionInSMFromAbsFastORIndex(const Int_t id, Int_t& iSM, Int_t& iEta, Int_t& iPhi)             const = 0;
+  virtual Bool_t GetPositionInEMCALFromAbsFastORIndex(const Int_t id, Int_t& iEta, Int_t& iPhi)                      const = 0;
+  virtual Bool_t GetFastORIndexFromCellIndex(const Int_t id, Int_t& idx)                                             const = 0;
+  virtual Bool_t GetCellIndexFromFastORIndex(const Int_t id, Int_t idx[4])                                           const = 0;
+  virtual Bool_t GetTRUIndexFromSTUIndex(const Int_t id, Int_t& idx)                                                 const = 0;
+  virtual Bool_t GetTRUIndexFromOnlineIndex(const Int_t id, Int_t& idx)                                              const = 0;
+  virtual Bool_t GetOnlineIndexFromTRUIndex(const Int_t id, Int_t& idx)                                              const = 0;
+  virtual Bool_t GetFastORIndexFromL0Index(const Int_t iTRU, const Int_t id, Int_t idx[], const Int_t size)          const = 0;
+
+  virtual Int_t  GetTRUIndexFromSTUIndex(   const Int_t id)                                                          const = 0;
+  virtual Int_t  GetTRUIndexFromOnlineIndex(const Int_t id)                                                          const = 0;
+  virtual Int_t  GetOnlineIndexFromTRUIndex(const Int_t id)                                                          const = 0;
+  
+  virtual void  GetNTRU(Int_t& n) {n = fNTRU;}
+  virtual Int_t GetNTRU() {return fNTRU;}
+  
+protected:  
+  Int_t fNTRU;
+  const AliEMCALGeometry* fGeometry;
+  
+private:
+  AliEMCALTriggerMapping(const AliEMCALTriggerMapping& rhs);
+  AliEMCALTriggerMapping& operator=(const AliEMCALTriggerMapping& rhs);
+  
+  ClassDef(AliEMCALTriggerMapping,1)
+};
+#endif
+
diff --git a/EMCAL/EMCALUtils/AliEMCALTriggerMappingV1.cxx b/EMCAL/EMCALUtils/AliEMCALTriggerMappingV1.cxx
new file mode 100755 (executable)
index 0000000..6fc464b
--- /dev/null
@@ -0,0 +1,331 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+
+
+
+Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+
+#include "AliEMCALTriggerMapping.h"
+#include "AliEMCALTriggerMappingV1.h"
+#include "AliEMCALGeometry.h"
+#include "AliLog.h"
+
+ClassImp(AliEMCALTriggerMappingV1)
+
+//________________________________________________________________________________________________
+AliEMCALTriggerMappingV1::AliEMCALTriggerMappingV1() : AliEMCALTriggerMapping()
+{
+  // Ctor
+  
+  SetUniqueID(1);
+}
+//________________________________________________________________________________________________
+AliEMCALTriggerMappingV1::AliEMCALTriggerMappingV1(const Int_t ntru, const AliEMCALGeometry* geo) : AliEMCALTriggerMapping(ntru, geo)
+{
+  // Ctor
+  
+  SetUniqueID(1);
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetAbsFastORIndexFromTRU(const Int_t iTRU, const Int_t iADC, Int_t& id) const
+{
+  //Trigger mapping method, get  FastOr Index from TRU
+
+  if (iTRU > fNTRU - 1 || iTRU < 0 || iADC > 95 || iADC < 0) {
+    AliError("TRU out of range!");
+    return kFALSE;
+  }
+
+  id  = ( iTRU % 2 ) ? iADC%4 + 4 * (23 - int(iADC/4)) : (3 - iADC%4) + 4 * int(iADC/4);
+  id += iTRU * 96;
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iADC) const
+{
+  // Trigger mapping method, get TRU number from FastOr Index
+
+  if (id > fNTRU * 96 - 1 || id < 0) {
+    AliError("Fast-OR ID is out of range!");
+    return kFALSE;
+  }
+       
+  iTRU = id / 96;
+  iADC = id % 96;
+  iADC = ( iTRU % 2 ) ? iADC%4 + 4 * (23 - int(iADC/4)) : (3 - iADC%4) + 4 * int(iADC/4);
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetPositionInTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iEta, Int_t& iPhi) const
+{
+  // Trigger mapping method, get position in TRU from FasOr Index
+       
+  Int_t iADC = -1;     
+  if (!GetTRUFromAbsFastORIndex(id, iTRU, iADC)) return kFALSE;
+       
+  Int_t x = iADC / 4;
+  Int_t y = iADC % 4;
+  if ( iTRU % 2 ) { // C side 
+    iEta = 23 - x;
+    iPhi =      y;
+  }
+  else {            // A side
+    iEta =      x;
+    iPhi =  3 - y;
+  }
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetPositionInSMFromAbsFastORIndex(const Int_t id, Int_t& iSM, Int_t& iEta, Int_t& iPhi) const
+{
+  //Trigger mapping method, get position in Super Module from FasOr Index
+
+  Int_t iTRU = -1;
+  if (!GetPositionInTRUFromAbsFastORIndex(id, iTRU, iEta, iPhi)) return kFALSE;
+  if (iTRU % 2) { // C side
+    iSM  = 2 * (int(int(iTRU / 2) / 3)) + 1;
+  } else {        // A side
+    iSM  = 2 * (int(int(iTRU / 2) / 3));
+  }
+  iPhi += 4 * int((iTRU % 6) / 2);
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetPositionInEMCALFromAbsFastORIndex(const Int_t id, Int_t& iEta, Int_t& iPhi) const
+{
+  //Trigger mapping method, get position in EMCAL from FastOR index
+
+  Int_t iSM = -1;
+  if (GetPositionInSMFromAbsFastORIndex(id, iSM, iEta, iPhi)) {
+    if (iSM % 2) iEta += 24; 
+    iPhi += 12 * int(iSM / 2);
+    return kTRUE;
+  }
+  return kFALSE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetAbsFastORIndexFromPositionInTRU(const Int_t iTRU, const Int_t iEta, const Int_t iPhi, Int_t& id) const
+{
+  //Trigger mapping method, get Index if FastOr from Position in TRU
+  if (iTRU < 0 || iTRU > fNTRU - 1 || iEta < 0 || iEta > 23 || iPhi < 0 || iPhi > 3) {
+    AliError(Form("Out of range! iTRU=%d, iEta=%d, iPhi=%d", iTRU, iEta, iPhi));       
+    return kFALSE;
+  }
+  id =  iPhi  + 4 * iEta + iTRU * 96;
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetAbsFastORIndexFromPositionInSM(const Int_t  iSM, const Int_t iEta, const Int_t iPhi, Int_t& id) const
+{
+  // Trigger mapping method, from position in SM Index get FastOR index 
+
+  if (iSM < 0 || iSM >= 12 || iEta < 0 || iEta > 23 || iPhi < 0 || iPhi > 11) {
+    AliError(Form("Out of range! iSM=%d, iEta=%d, iPhi=%d", iSM, iEta, iPhi));
+    return kFALSE;
+  }
+  
+  Int_t x = iEta;
+  Int_t y = iPhi % 4;  
+  Int_t iOff = (iSM % 2) ? 1 : 0;
+  Int_t iTRU = 2 * int(iPhi / 4) + 6 * int(iSM / 2) + iOff;
+  if (GetAbsFastORIndexFromPositionInTRU(iTRU, x, y, id)) {
+    return kTRUE;
+  }
+  return kFALSE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetAbsFastORIndexFromPositionInEMCAL(const Int_t iEta, const Int_t iPhi, Int_t& id) const
+{
+  // Trigger mapping method, from position in EMCAL Index get FastOR index 
+
+  if (iEta < 0 || iEta > 47 || iPhi < 0 || iPhi > 59) {
+    AliError(Form("Out of range! iEta: %2d iPhi: %2d", iEta, iPhi));
+    return kFALSE;
+  }
+  
+  id = iEta * 48 + iPhi;
+  
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetFastORIndexFromCellIndex(const Int_t id, Int_t& idx) const
+{
+  // Trigger mapping method, from cell index get FastOR index 
+
+  Int_t iSupMod, nModule, nIphi, nIeta, iphim, ietam;
+  Bool_t isOK = fGeometry->GetCellIndex( id, iSupMod, nModule, nIphi, nIeta );
+  fGeometry->GetModulePhiEtaIndexInSModule( iSupMod, nModule, iphim, ietam );
+  
+  if (isOK && GetAbsFastORIndexFromPositionInSM(iSupMod, ietam, iphim, idx)) return kTRUE;
+  return kFALSE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetCellIndexFromFastORIndex(const Int_t id, Int_t idx[4]) const
+{
+  // Trigger mapping method, from FASTOR index get cell index 
+
+  Int_t iSM=-1, iEta=-1, iPhi=-1;
+  if (GetPositionInSMFromAbsFastORIndex(id, iSM, iEta, iPhi)) {
+    Int_t ix = 2 * iEta;
+    Int_t iy = 2 * iPhi;
+    for (Int_t i = 0; i < 2; i++) {
+      for (Int_t j = 0; j < 2; j++) {
+        idx[2 * i + j] = fGeometry->GetAbsCellIdFromCellIndexes(iSM, iy + i, ix + j);
+      }
+    }
+    return kTRUE;
+  }
+  return kFALSE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetTRUIndexFromSTUIndex(const Int_t id, Int_t& idx) const
+{
+  // STU mapping: TRU# 0 and 16 are missing 
+
+   if (id > 31 || id < 0) {
+     AliError(Form("TRU index out of range: %d",id));
+     return kFALSE;
+   }
+   
+   idx = GetTRUIndexFromSTUIndex(id);
+   return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Int_t AliEMCALTriggerMappingV1::GetTRUIndexFromSTUIndex(const Int_t id) const
+{
+  // STU mapping: TRU# 0 and 16 are missing 
+
+  if (id > 31 || id < 0) {
+    AliError(Form("TRU index out of range: %d",id));
+  }
+  return (id > 15) ? 2 * (31 - id) : 2 * (15 - id) + 1;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetTRUIndexFromOnlineIndex(const Int_t id, Int_t& idx) const
+{
+  //Trigger mapping method, from STU index get TRU index 
+
+   idx = GetOnlineIndexFromTRUIndex(id);
+   if (idx > fNTRU - 1 || idx < 0) {
+     AliError(Form("TRU index out of range: %d",idx));
+     return kFALSE;
+   }
+   return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Int_t AliEMCALTriggerMappingV1::GetTRUIndexFromOnlineIndex(const Int_t id) const
+{
+  //Trigger mapping method, from STU index get TRU index 
+       
+  if (id > fNTRU - 1 || id < 0) {
+    AliError(Form("TRU index out of range: %d",id));
+  }
+  if (id == 31) {
+    return 31;
+  }
+
+  //jump 4 TRUs for DCAL
+  Int_t tmp=0;
+  if(id > 31) tmp = id+4;
+  else        tmp = id;
+  Int_t idx = ((tmp% 6) < 3) ? 6 * int(tmp/ 6) + 2 * (tmp% 3) : 6 * int(tmp/ 6) + 2 * (2 - (tmp% 3)) + 1;
+  if(id > 31) idx-=4;
+  return idx;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetOnlineIndexFromTRUIndex(const Int_t id, Int_t& idx) const
+{
+  //Trigger mapping method, from STU index get TRU index 
+    idx = GetOnlineIndexFromTRUIndex(id);
+    if (idx > fNTRU-1 || idx < 0)
+   {
+     AliError(Form("TRU index out of range: %d",idx));
+     return kFALSE;
+   }
+   return kTRUE;
+}
+//________________________________________________________________________________________________
+Int_t AliEMCALTriggerMappingV1::GetOnlineIndexFromTRUIndex(const Int_t id) const
+{
+  //Trigger mapping method, from STU index get TRU index 
+       
+  if (id > fNTRU-1 || id < 0) 
+  {
+    AliError(Form("TRU index out of range: %d",id));
+  }
+  if (id == 31) {
+    return 31;
+  }
+
+  //jump 4 TRUs for DCAL
+  Int_t tmp=0;
+  if(id > 31) tmp = id+4;
+  else        tmp = id;
+  Int_t idx = (tmp % 2) ? int((6 - (tmp % 6)) / 2) + 3 * (2 * int(tmp / 6) + 1) : 3 * int(tmp / 6) + int(tmp / 2);
+  if(id > 31) idx-=4;
+  return idx;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV1::GetFastORIndexFromL0Index(const Int_t iTRU, const Int_t id, Int_t idx[], const Int_t size) const
+{
+  //Trigger mapping method, from L0 index get FastOR index 
+
+  if (size <= 0 || size > 4) {
+    AliError("Size not supported!");
+    return kFALSE;
+  }
+               
+  Int_t motif[4] = {0, 1, 4, 5};
+  switch (size) {
+    case 1: // Cosmic trigger
+      if (!GetAbsFastORIndexFromTRU(iTRU, id, idx[1])) return kFALSE;
+      break;
+    case 4: // 4 x 4
+      for (Int_t k = 0; k < 4; k++) {
+        Int_t iADC = motif[k] + 4 * int(id / 3) + (id % 3);
+                               
+        if (!GetAbsFastORIndexFromTRU(iTRU, iADC, idx[k])) return kFALSE;
+      }
+      break;
+    default:
+      break;
+  }
+       
+  return kTRUE;
+}
+
+
+
diff --git a/EMCAL/EMCALUtils/AliEMCALTriggerMappingV1.h b/EMCAL/EMCALUtils/AliEMCALTriggerMappingV1.h
new file mode 100755 (executable)
index 0000000..31f5159
--- /dev/null
@@ -0,0 +1,48 @@
+#ifndef ALIEMCALTRIGGERMAPPINGV1_H
+#define ALIEMCALTRIGGERMAPPINGV1_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/*
+Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+
+#include "AliEMCALTriggerMapping.h"
+class AliEMCALGeometry;
+class AliEMCALTriggerMappingV1 : public AliEMCALTriggerMapping 
+{
+public:
+       
+                      AliEMCALTriggerMappingV1();
+                      AliEMCALTriggerMappingV1(const Int_t ntru, const AliEMCALGeometry* geo);
+              virtual ~AliEMCALTriggerMappingV1() {}
+
+  Bool_t   GetAbsFastORIndexFromTRU(const Int_t iTRU, const Int_t iADC, Int_t& id) const;
+  Bool_t                    GetAbsFastORIndexFromPositionInTRU(const Int_t iTRU, const Int_t iEta, const Int_t iPhi, Int_t& id) const; 
+  Bool_t                    GetAbsFastORIndexFromPositionInSM( const Int_t  iSM, const Int_t iEta, const Int_t iPhi, Int_t& id) const; 
+  Bool_t                    GetAbsFastORIndexFromPositionInEMCAL(                const Int_t iEta, const Int_t iPhi, Int_t& id) const;
+  Bool_t                                GetTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iADC) const;
+  Bool_t   GetPositionInTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iEta, Int_t& iPhi) const;
+  Bool_t    GetPositionInSMFromAbsFastORIndex(const Int_t id, Int_t& iSM, Int_t& iEta, Int_t& iPhi) const;
+  Bool_t GetPositionInEMCALFromAbsFastORIndex(const Int_t id, Int_t& iEta, Int_t& iPhi) const;
+  Bool_t          GetFastORIndexFromCellIndex(const Int_t id, Int_t& idx) const;
+  Bool_t          GetCellIndexFromFastORIndex(const Int_t id, Int_t idx[4]) const;
+  Bool_t              GetTRUIndexFromSTUIndex(const Int_t id, Int_t& idx) const;
+  Int_t               GetTRUIndexFromSTUIndex(const Int_t id) const;
+  Bool_t           GetTRUIndexFromOnlineIndex(const Int_t id, Int_t& idx) const;
+  Int_t            GetTRUIndexFromOnlineIndex(const Int_t id) const;
+  Bool_t           GetOnlineIndexFromTRUIndex(const Int_t id, Int_t& idx) const;
+  Int_t            GetOnlineIndexFromTRUIndex(const Int_t id) const;
+  Bool_t            GetFastORIndexFromL0Index(const Int_t iTRU, const Int_t id, Int_t idx[], const Int_t size) const;
+       
+private:
+                           AliEMCALTriggerMappingV1(const AliEMCALTriggerMappingV1& rhs);
+                AliEMCALTriggerMappingV1& operator=(const AliEMCALTriggerMappingV1& rhs);
+       
+       ClassDef(AliEMCALTriggerMappingV1,1)
+};
+#endif
+
diff --git a/EMCAL/EMCALUtils/AliEMCALTriggerMappingV2.cxx b/EMCAL/EMCALUtils/AliEMCALTriggerMappingV2.cxx
new file mode 100644 (file)
index 0000000..8fab483
--- /dev/null
@@ -0,0 +1,476 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+
+
+
+Author: 
+H. YOKOYAMA Tsukuba University
+R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+
+#include "AliEMCALTriggerMapping.h"
+#include "AliEMCALTriggerMappingV2.h"
+#include "AliEMCALGeometry.h"
+#include "AliLog.h"
+
+ClassImp(AliEMCALTriggerMappingV2)
+
+//________________________________________________________________________________________________
+AliEMCALTriggerMappingV2::AliEMCALTriggerMappingV2() : AliEMCALTriggerMapping()
+{
+  // Ctor
+  SetUniqueID(2);
+  
+  for(Int_t iTRU=0; iTRU<46; iTRU++){
+    fTRUFastOROffsetX[iTRU] = 0 ;
+    fTRUFastOROffsetY[iTRU] = 0 ;
+    fnFastORInTRUPhi[ iTRU] = 0 ;
+    fnFastORInTRUEta[ iTRU] = 0 ;
+  }
+  for(Int_t iSM=0; iSM<20; iSM++){
+    fSMFastOROffsetX[ iSM]  = 0 ;
+    fSMFastOROffsetY[ iSM]  = 0 ;
+    fnFastORInSMPhi[  iSM]  = 0 ;
+    fnFastORInSMEta[  iSM]  = 0 ;
+  }
+  fnModuleInEMCALPhi  = 0 ;
+
+  Init_TRU_offset()  ;
+  Init_SM_offset()   ;
+}
+//________________________________________________________________________________________________
+AliEMCALTriggerMappingV2::AliEMCALTriggerMappingV2(const Int_t ntru, const AliEMCALGeometry* geo) : AliEMCALTriggerMapping(ntru, geo)
+{
+  // Ctor
+  SetUniqueID(2);
+  
+  for(Int_t iTRU=0; iTRU<46; iTRU++){
+    fTRUFastOROffsetX[iTRU] = geo.fTRUFastOROffsetX[iTRU] ;
+    fTRUFastOROffsetY[iTRU] = geo.fTRUFastOROffsetY[iTRU] ;
+    fnFastORInTRUPhi[ iTRU] = geo.fnFastORInTRUPhi[ iTRU] ;
+    fnFastORInTRUEta[ iTRU] = geo.fnFastORInTRUEta[ iTRU] ;
+  }
+  for(Int_t iSM=0; iSM<20; iSM++){
+    fSMFastOROffsetX[ iSM]  = geo.fSMFastOROffsetX[ iSM]  ;
+    fSMFastOROffsetY[ iSM]  = geo.fSMFastOROffsetY[ iSM]  ;
+    fnFastORInSMPhi[  iSM]  = geo.fnFastORInSMPhi[  iSM]  ;
+    fnFastORInSMEta[  iSM]  = geo.fnFastORInSMEta[  iSM]  ;
+  }
+  fnModuleInEMCALPhi  = geo.fnModuleInEMCALPhi  ;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetAbsFastORIndexFromTRU(const Int_t iTRU, const Int_t iADC, Int_t& id) const
+{
+  //Trigger mapping method, get  FastOr Index from TRU
+  if (iTRU > fNTotalTRU-1     || iTRU < 0 || 
+      iADC > fNModulesInTRU-1 || iADC < 0
+  ){
+    AliError(Form("Out of range! iTRU=%d, iADC=%d", iTRU, iADC));      
+    return kFALSE;
+  }
+  Int_t x = fTRUFastOROffsetX[iTRU] +    (iADC % fnFastORInTRUEta[iTRU])  ;
+  Int_t y = fTRUFastOROffsetY[iTRU] + int(iADC / fnFastORInTRUEta[iTRU])  ;
+  id      = y*fNEta*2 + x         ;
+  return kTRUE  ;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetAbsFastORIndexFromPositionInTRU(const Int_t iTRU, const Int_t iEta, const Int_t iPhi, Int_t& id) const
+{
+  //Trigger mapping method, get Index if FastOr from Position in TRU
+  if (iTRU > fNTotalTRU-1               || iTRU < 0 || 
+      iEta > fnFastORInTRUEta[iTRU] - 1 || iEta < 0 ||
+      iPhi > fnFastORInTRUPhi[iTRU] - 1 || iPhi < 0
+  ){
+    AliError(Form("Out of range! iTRU=%d, iEta=%d, iPhi=%d", iTRU, iEta, iPhi));       
+    return kFALSE;
+  }
+  Int_t x = fTRUFastOROffsetX[iTRU] + iEta  ;
+  Int_t y = fTRUFastOROffsetY[iTRU] + iPhi  ;
+  id      = y*fNEta*2 + x         ;
+  return kTRUE  ;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetAbsFastORIndexFromPositionInSM(const Int_t  iSM, const Int_t iEta, const Int_t iPhi, Int_t& id) const
+{
+  //Trigger mapping method, from position in SM Index get FastOR index 
+  if (iSM  > fNumberOfSuperModules-1  || iSM  < 0 || 
+      iEta > fnFastORInSMEta[iSM] -1  || iEta < 0 ||
+      iPhi > fnFastORInSMPhi[iSM] -1  || iPhi < 0
+  ){
+    AliError(Form("Out of range! iSM=%d, iEta=%d, iPhi=%d", iSM, iEta, iPhi)); 
+    return kFALSE;
+  }
+  Int_t x = fSMFastOROffsetX[iSM] + iEta  ;
+  Int_t y = fSMFastOROffsetY[iSM] + iPhi  ;
+  id      = y*fNEta*2 + x         ;
+  return kTRUE  ;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetAbsFastORIndexFromPositionInEMCAL(const Int_t iEta, const Int_t iPhi, Int_t& id) const
+{
+  //Trigger mapping method, from position in EMCAL Index get FastOR index 
+  if (
+      iEta > 2 * fNEta - 1          || iEta < 0 || 
+      iPhi > fnModuleInEMCALPhi - 1 || iPhi < 0  
+  ){
+    AliError(Form("Out of range! eta: %2d phi: %2d", iEta, iPhi));
+    return kFALSE;
+  }
+  id      = iPhi*fNEta*2 + iEta       ;
+  return kTRUE  ;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iADC) const
+{
+  //Trigger mapping method, get TRU number from FastOr Index
+  Int_t iEta_TRU , iPhi_TRU , iSM , iEta_SM , iPhi_SM ;
+  return GetInfoFromAbsFastORIndex(
+    id   , 
+    iTRU , iADC , iEta_TRU , iPhi_TRU , 
+    iSM  ,        iEta_SM  , iPhi_SM  
+    );
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetPositionInTRUFromAbsFastORIndex(const Int_t id, Int_t& iTRU, Int_t& iEta, Int_t& iPhi) const
+{
+  //Trigger mapping method, get position in TRU from FasOr Index
+  Int_t iADC , iSM , iEta_SM , iPhi_SM ;
+  return GetInfoFromAbsFastORIndex(
+    id   , 
+    iTRU , iADC , iEta     , iPhi     , 
+    iSM  ,        iEta_SM  , iPhi_SM  
+    );
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetPositionInSMFromAbsFastORIndex(const Int_t id, Int_t& iSM, Int_t& iEta, Int_t& iPhi) const
+{
+  //Trigger mapping method, get position in Super Module from FasOr Index
+  Int_t iTRU , iADC , iEta_TRU , iPhi_TRU ;
+  return GetInfoFromAbsFastORIndex(
+    id   , 
+    iTRU , iADC , iEta_TRU , iPhi_TRU , 
+    iSM  ,        iEta     , iPhi  
+    );
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetPositionInEMCALFromAbsFastORIndex(const Int_t id, Int_t& iEta, Int_t& iPhi) const
+{
+  //Trigger mapping method, get position in EMCAL from FastOR index
+  Int_t nModule = fNEta * 2 * fnModuleInEMCALPhi;
+  if (id > nModule-1 || id < 0){
+    AliError("Id out of range!");
+    return kFALSE;
+  }
+  iEta  = id % (2*fNEta) ;
+  iPhi  = id / (2*fNEta) ;
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetFastORIndexFromCellIndex(const Int_t id, Int_t& idx) const
+{
+  // Trigger mapping method, from cell index get FastOR index 
+
+  Int_t iSupMod, nModule, nIphi, nIeta, iphim, ietam;
+  Bool_t isOK = fGeometry->GetCellIndex( id, iSupMod, nModule, nIphi, nIeta );
+  fGeometry->GetModulePhiEtaIndexInSModule( iSupMod, nModule, iphim, ietam );
+  
+  if (isOK && GetAbsFastORIndexFromPositionInSM(iSupMod, ietam, iphim, idx)) return kTRUE;
+  return kFALSE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetCellIndexFromFastORIndex(const Int_t id, Int_t idx[4]) const
+{
+  //Trigger mapping method, from FASTOR index get cell index 
+  Int_t iSM=-1, iEta=-1, iPhi=-1;
+  if (GetPositionInSMFromAbsFastORIndex(id, iSM, iEta, iPhi))
+  {
+    Int_t ix = 2 * iEta;
+    Int_t iy = 2 * iPhi;
+    idx[0] = fGeometry->GetAbsCellIdFromCellIndexes(iSM, iy    , ix    );
+    idx[1] = fGeometry->GetAbsCellIdFromCellIndexes(iSM, iy    , ix + 1);
+    idx[2] = fGeometry->GetAbsCellIdFromCellIndexes(iSM, iy + 1, ix    );
+    idx[3] = fGeometry->GetAbsCellIdFromCellIndexes(iSM, iy + 1, ix + 1);
+    return kTRUE;
+  }
+  return kFALSE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetTRUIndexFromSTUIndex(const Int_t id, Int_t& idx) const
+{
+  //Trigger mapping method, from STU index get TRU index 
+  idx = GetTRUIndexFromSTUIndex(id);
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Int_t AliEMCALTriggerMappingV2::GetTRUIndexFromSTUIndex(const Int_t id) const
+{
+  //Trigger mapping method, from STU index get TRU index 
+  if (id > fNTotalTRU-1 || id < 0){
+    AliError(Form("TRU index out of range: %d",id));
+  }
+  return id ;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetTRUIndexFromOnlineIndex(const Int_t id, Int_t& idx) const
+{
+  //Trigger mapping method, from STU index get TRU index 
+  idx = GetTRUIndexFromOnlineIndex(id);
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Int_t AliEMCALTriggerMappingV2::GetTRUIndexFromOnlineIndex(const Int_t id) const
+{
+  //Trigger mapping method, from STU index get TRU index 
+  if (id > fNTotalTRU-1 || id < 0){
+    AliError(Form("TRU index out of range: %d",id));
+  }
+  return id;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetOnlineIndexFromTRUIndex(const Int_t id, Int_t& idx) const
+{
+  //Trigger mapping method, from STU index get TRU index 
+  idx = GetOnlineIndexFromTRUIndex(id);
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Int_t AliEMCALTriggerMappingV2::GetOnlineIndexFromTRUIndex(const Int_t id) const
+{
+  //Trigger mapping method, from STU index get TRU index 
+  if (id > fNTotalTRU-1 || id < 0){
+    AliError(Form("TRU index out of range: %d",id));
+  }
+  return id;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetFastORIndexFromL0Index(const Int_t iTRU, const Int_t id, Int_t idx[], const Int_t size) const
+{
+  //Trigger mapping method, from L0 index get FastOR index 
+
+  if (size <= 0 ||size > 4){
+    AliError("Size not supported!");
+    return kFALSE;
+  }
+               
+  Int_t motif[4];
+  motif[0] = 0;
+  motif[1] = 1;
+  motif[2] = fnFastORInTRUEta[iTRU]     ;
+  motif[3] = fnFastORInTRUEta[iTRU] + 1 ;
+  switch (size)
+  {
+    case 1: // Cosmic trigger
+      if (!GetAbsFastORIndexFromTRU(iTRU, id, idx[1])) return kFALSE;
+      break;
+    case 4: // 4 x 4
+      for (Int_t k = 0; k < 4; k++)
+      {
+        Int_t iADC = motif[k] + fnFastORInTRUEta[iTRU] * int(id/(fnFastORInTRUEta[iTRU]-1)) + (id%(fnFastORInTRUEta[iTRU]-1));
+                               
+        if (!GetAbsFastORIndexFromTRU(iTRU, iADC, idx[k])) return kFALSE;
+      }
+      break;
+    default:
+      break;
+  }
+       
+  return kTRUE;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::Init_TRU_offset(){
+  fTRUFastOROffsetX[0]   = 0 ;
+  fTRUFastOROffsetY[0]   = 0 ;
+  Int_t iTRU  = 0 ;
+
+  for(int iSM=0; iSM<fNumberOfSuperModules; iSM++){
+    Int_t       SM_type   = GetSMType(iSM);
+    Int_t       TRU_type  = 0             ;
+    
+    Int_t nTRU_inSM         = fNTRU                ;
+    Int_t nTRU_inSM_phi     = fNTRUPhi             ;
+    Int_t nTRU_inSM_eta     = fNTRUEta             ;
+    Int_t nModule_inTRU_phi = fNModulesInTRUPhi    ;
+    Int_t nModule_inTRU_eta = fNModulesInTRUEta    ;
+    
+    //kEMCAL_Standard -> default value
+    if(     SM_type == kEMCAL_3rd      ){
+      nTRU_inSM         = (Int_t)((Float_t)nTRU_inSM         / 3. );
+      nTRU_inSM_eta     = (Int_t)((Float_t)nTRU_inSM_eta     / 3. );
+      nModule_inTRU_phi = (Int_t)((Float_t)nModule_inTRU_phi / 3. );
+      nModule_inTRU_eta = nModule_inTRU_eta                  * 3   ;
+    }
+    else if(SM_type == kDCAL_Standard  ){
+      nTRU_inSM         = (Int_t)((Float_t)nTRU_inSM      * 2./3. );
+      nTRU_inSM_eta     = (Int_t)((Float_t)nTRU_inSM_eta  * 2./3. );
+    }
+    else if(SM_type == kDCAL_Ext       ){
+      nTRU_inSM         = (Int_t)((Float_t)nTRU_inSM         / 3. );
+      nTRU_inSM_eta     = (Int_t)((Float_t)nTRU_inSM_eta     / 3. );
+      nModule_inTRU_phi = (Int_t)((Float_t)nModule_inTRU_phi / 3. );
+      nModule_inTRU_eta =                  nModule_inTRU_eta * 3   ;
+    }
+
+    //TRU ieta/iphi offset calculation 
+    for(Int_t i=0; i<nTRU_inSM; i++){
+      fnFastORInTRUPhi[iTRU]  = nModule_inTRU_phi ;
+      fnFastORInTRUEta[iTRU]  = nModule_inTRU_eta ;
+      if((iTRU+1) >= fNTotalTRU)break;
+      
+      TRU_type  = 0 ;
+      if( i==nTRU_inSM-1 ){//last TRU in SM
+        if(      iSM%2==0 && SM_type==kDCAL_Standard ) TRU_type = 2  ;//left  DCAL 
+        else if( iSM%2==1 && SM_type==kDCAL_Standard ) TRU_type = 3  ;//right DCAL 
+        else if( iSM%2==1                            ) TRU_type = 1  ;//right EMCAL
+      }
+      if(      TRU_type == 0){
+        fTRUFastOROffsetX[iTRU+1]  = fTRUFastOROffsetX[iTRU] + nModule_inTRU_eta      ;
+        fTRUFastOROffsetY[iTRU+1]  = fTRUFastOROffsetY[iTRU]                          ;
+      }else if(TRU_type == 1){
+        fTRUFastOROffsetX[iTRU+1]  = 0                                                ;
+        fTRUFastOROffsetY[iTRU+1]  = fTRUFastOROffsetY[iTRU] + nModule_inTRU_phi      ;
+      }else if(TRU_type == 2){
+        fTRUFastOROffsetX[iTRU+1]  = fTRUFastOROffsetX[iTRU] + nModule_inTRU_eta * 3  ;
+        fTRUFastOROffsetY[iTRU+1]  = fTRUFastOROffsetY[iTRU]                          ;
+      }else if(TRU_type == 3){
+        fTRUFastOROffsetX[iTRU+1]  = 0                                                ;
+        fTRUFastOROffsetY[iTRU+1]  = fTRUFastOROffsetY[iTRU] + nModule_inTRU_phi      ;
+      }
+      iTRU++  ;
+    }//TRU loop
+  }//SM loop
+  
+  return kTRUE ;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::Init_SM_offset(){
+
+  fSMFastOROffsetX[0]  = 0 ;
+  fSMFastOROffsetY[0]  = 0 ;
+  fnModuleInEMCALPhi  = 0 ;
+
+  for(int iSM=0; iSM<fNumberOfSuperModules; iSM++){
+    Int_t SM_type = GetSMType(iSM);
+    
+    Int_t nModule_inSM_phi  = fNPhi    ;
+    Int_t nModule_inSM_eta  = fNEta    ;
+    
+    //kEMCAL_Standard:kEMCAL_Half -> default value
+    if(     SM_type == kEMCAL_3rd      ){
+      nModule_inSM_phi  = (Int_t)((Float_t)nModule_inSM_phi      / 3.);
+    }
+    else if(SM_type == kDCAL_Standard  ){
+      nModule_inSM_eta  = (Int_t)((Float_t)nModule_inSM_eta * 2. / 3.);
+    }
+    else if(SM_type == kDCAL_Ext       ){
+      nModule_inSM_phi  = (Int_t)((Float_t)nModule_inSM_phi      / 3.);
+    }
+
+    fnFastORInSMPhi[iSM]  = nModule_inSM_phi ;
+    fnFastORInSMEta[iSM]  = nModule_inSM_eta ;
+    if( (iSM+1) >= fNumberOfSuperModules)break  ;
+
+    if(iSM%2 == 1){//right SM
+      fSMFastOROffsetX[iSM+1]  = 0                                        ;
+      fSMFastOROffsetY[iSM+1]  = fSMFastOROffsetY[iSM] + nModule_inSM_phi ;
+    }
+    else{//left SM
+      fnModuleInEMCALPhi += nModule_inSM_phi  ;
+      if(SM_type == kDCAL_Standard){
+        fSMFastOROffsetX[iSM+1]  = fSMFastOROffsetX[iSM] + nModule_inSM_eta * 2 ;
+        fSMFastOROffsetY[iSM+1]  = fSMFastOROffsetY[iSM]                        ;
+      }else{
+        fSMFastOROffsetX[iSM+1]  = fSMFastOROffsetX[iSM] + nModule_inSM_eta     ;
+        fSMFastOROffsetY[iSM+1]  = fSMFastOROffsetY[iSM]                        ;
+      }
+    }
+  }//SM loop
+  return kTRUE ;
+}
+
+//________________________________________________________________________________________________
+Bool_t AliEMCALTriggerMappingV2::GetInfoFromAbsFastORIndex(
+    const Int_t id, 
+    Int_t& iTRU , Int_t& iADC , Int_t& iEta_TRU , Int_t& iPhi_TRU , 
+    Int_t& iSM  ,               Int_t& iEta_SM  , Int_t& iPhi_SM  
+    ) const
+{
+
+  Int_t nModule = fNEta * 2 * fnModuleInEMCALPhi;
+  if (id > nModule-1 || id < 0){
+    AliError("Id out of range!");
+    return kFALSE;
+  }
+       
+  Int_t x       = id % (fNEta * 2) ;
+  Int_t y       = id / (fNEta * 2) ;
+  if(y >= fNPhi*5 + 4)  y = y + 8 ;
+  
+  Int_t y_class     = int(y/fNModulesInTRUPhi)   ;
+  Int_t x_class     = int(x/fNModulesInTRUEta)   ;
+  iTRU = y_class*(fNTRUEta*2) + x_class ;
+  
+  Int_t Cside       = int(x/fNEta);//Cside SM
+  //y_class = 5 : EMCAL 1/3 SM
+  //y_class = 9 : DCAL  1/3 SM
+  Int_t DCAL_sepC   = (y_class>5 && y_class<9 && Cside==1)? 1 : 0 ;
+  Bool_t IsPHOS     = (y_class>5 && y_class<9 && (x_class==2 || x_class==3))? kTRUE : kFALSE ;
+
+  if(y_class==5 || y_class==9 ) iTRU = iTRU - (x_class%3) - Cside*2 ;
+  if(y_class> 5               ) iTRU = iTRU - 2 - (y_class-5)*2 - DCAL_sepC*2 ;
+
+  iADC = (y_class==5 || y_class==9)? (y%(fNModulesInTRUPhi/3))*(fNModulesInTRUEta*3) + (x%(fNModulesInTRUEta*3)) :
+                                     (y% fNModulesInTRUPhi   )* fNModulesInTRUEta    + (x% fNModulesInTRUEta   ) ;
+
+  iSM       = int(y/fNPhi)*2 + Cside  ; 
+  iEta_TRU  = (y_class==5 || y_class==9)? x%(fNModulesInTRUEta*3) : x%(fNModulesInTRUEta);
+  iPhi_TRU  = y%fNModulesInTRUPhi;
+  iEta_SM   = (DCAL_sepC == 1)? (x%fNEta - 8) : (x%fNEta);
+  iPhi_SM   = y%fNPhi;
+
+  if(IsPHOS){
+    iTRU      = -1  ;
+    iADC      = -1  ;
+    iSM       = -1  ;
+    iEta_TRU  = -1  ;
+    iPhi_TRU  = -1  ;
+    iEta_SM   = -1  ;
+    iPhi_SM   = -1  ;
+  }
+  return kTRUE;
+}
+
diff --git a/EMCAL/EMCALUtils/AliEMCALTriggerMappingV2.h b/EMCAL/EMCALUtils/AliEMCALTriggerMappingV2.h
new file mode 100644 (file)
index 0000000..f32f3e4
--- /dev/null
@@ -0,0 +1,138 @@
+#ifndef ALIEMCALTRIGGERMAPPINGV2_H
+#define ALIEMCALTRIGGERMAPPINGV2_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/*
+Author: 
+H. YOKOYAMA Tsukuba University
+R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+
+#include "AliEMCALTriggerMapping.h"
+class AliEMCALGeometry;
+class AliEMCALTriggerMappingV2 : public AliEMCALTriggerMapping 
+{
+public:
+
+  //********************************************
+  //static constant
+  //********************************************
+  static const Int_t  fNumberOfSuperModules = 20  ;//Total SM in EMCAL
+  static const Int_t  fNTotalTRU            = 46  ;//Total TRU in EMCAL
+  static const Int_t  fNTRU                 =  3  ;//#TRUs/SM  
+  static const Int_t  fNTRUEta              =  3  ;//#TRUs/SM in Eta  
+  static const Int_t  fNTRUPhi              =  1  ;//#TRUs/SM in Phi
+  static const Int_t  fNEta                 = 24  ;//#FastOR/SM in Eta
+  static const Int_t  fNPhi                 = 12  ;//#FastOR/SM in Phi 
+  static const Int_t  fNModulesInTRU        = 96  ;//#FastOR/TRU
+  static const Int_t  fNModulesInTRUEta     =  8  ;//#FastOR/TRU in Eta
+  static const Int_t  fNModulesInTRUPhi     = 12  ;//#FastOR/TRU in Phi
+  
+  //********************************************
+  //SM type 
+  //********************************************
+  enum fEMCSMType { 
+    kEMCAL_Standard = 0, 
+    kEMCAL_Half     = 1, 
+    kEMCAL_3rd      = 2, 
+    kDCAL_Standard  = 3, 
+    kDCAL_Ext       = 4 
+  }; // possible SM Type
+       
+
+  //********************************************
+  //constructor,destructor
+  //********************************************
+  AliEMCALTriggerMappingV2();
+  AliEMCALTriggerMappingV2(const Int_t ntru, const AliEMCALGeometry* geo);
+  virtual ~AliEMCALTriggerMappingV2() {}
+
+  //********************************************
+  //Get FastOR index from TRU/SM/EMCAL Geometry
+  //********************************************
+  Bool_t  GetAbsFastORIndexFromTRU(          const Int_t iTRU, const Int_t iADC, Int_t& id) const;
+  Bool_t  GetAbsFastORIndexFromPositionInTRU(const Int_t iTRU, const Int_t iEta, const Int_t iPhi, Int_t& id) const;   
+  Bool_t  GetAbsFastORIndexFromPositionInSM( const Int_t  iSM, const Int_t iEta, const Int_t iPhi, Int_t& id) const;   
+  Bool_t  GetAbsFastORIndexFromPositionInEMCAL(                const Int_t iEta, const Int_t iPhi, Int_t& id) const;
+
+  //********************************************
+  //Get TRU/SM/EMCAL Geometry from FastOR index
+  //********************************************
+  Bool_t  GetTRUFromAbsFastORIndex(             const Int_t id, Int_t& iTRU , Int_t& iADC) const;
+  Bool_t  GetPositionInTRUFromAbsFastORIndex(   const Int_t id, Int_t& iTRU , Int_t& iEta, Int_t& iPhi) const;
+  Bool_t  GetPositionInSMFromAbsFastORIndex(    const Int_t id, Int_t& iSM  , Int_t& iEta, Int_t& iPhi) const;
+  Bool_t  GetPositionInEMCALFromAbsFastORIndex( const Int_t id,               Int_t& iEta, Int_t& iPhi) const;
+
+  //********************************************
+  //Cell Index
+  //********************************************
+  Bool_t  GetFastORIndexFromCellIndex(const Int_t id, Int_t& idx) const;
+  Bool_t  GetCellIndexFromFastORIndex(const Int_t id, Int_t idx[4]) const;
+
+  //********************************************
+  //TRU index
+  //********************************************
+  Bool_t  GetTRUIndexFromSTUIndex(    const Int_t id, Int_t& idx) const;
+  Int_t   GetTRUIndexFromSTUIndex(    const Int_t id            ) const;
+  Bool_t  GetTRUIndexFromOnlineIndex( const Int_t id, Int_t& idx) const;
+  Int_t   GetTRUIndexFromOnlineIndex( const Int_t id            ) const;
+  Bool_t  GetOnlineIndexFromTRUIndex( const Int_t id, Int_t& idx) const;
+  Int_t   GetOnlineIndexFromTRUIndex( const Int_t id            ) const;
+  
+  //********************************************
+  //L0 Index
+  //********************************************
+  Bool_t  GetFastORIndexFromL0Index(const Int_t iTRU, const Int_t id, Int_t idx[], const Int_t size) const;
+       
+private:
+                
+  AliEMCALTriggerMappingV2(const AliEMCALTriggerMappingV2& rhs);
+  AliEMCALTriggerMappingV2& operator=(const AliEMCALTriggerMappingV2& rhs);
+       
+  //********************************************
+  //fastOR offset parameters
+  //********************************************
+  Int_t   fTRUFastOROffsetX[46] ;//FastOR offset[#of TRU]
+  Int_t   fTRUFastOROffsetY[46] ;//
+  Int_t   fnFastORInTRUPhi[ 46] ;//TRU size
+  Int_t   fnFastORInTRUEta[ 46] ;//
+  
+  Int_t   fSMFastOROffsetX[ 20] ;//FastOR offset[#of SM ]
+  Int_t   fSMFastOROffsetY[ 20] ;//
+  Int_t   fnFastORInSMPhi[  20] ;//SM size
+  Int_t   fnFastORInSMEta[  20] ;//
+
+  Int_t   fnModuleInEMCALPhi    ;//#FastOR/EMCAL in Phi
+
+  //********************************************
+  //Initialization of FastOR index offset of each SM/TRU
+  //********************************************
+  Bool_t Init_TRU_offset()  ;
+  Bool_t Init_SM_offset()   ;
+
+  //********************************************
+  //SM type
+  //********************************************
+  Int_t   GetSMType(Int_t iSM)      const {
+    if( iSM<0 || iSM >= fNumberOfSuperModules)return -1  ;
+    if( iSM < 10) return kEMCAL_Standard ;
+    if( iSM < 12) return kEMCAL_3rd      ;
+    if( iSM < 18) return kDCAL_Standard  ;
+    if( iSM < 20) return kDCAL_Ext       ;
+    return -1 ;
+  }
+  
+  Bool_t GetInfoFromAbsFastORIndex(
+    const Int_t id, 
+    Int_t& iTRU , Int_t& iADC , Int_t& iEta_TRU , Int_t& iPhi_TRU , 
+    Int_t& iSM  ,               Int_t& iEta_SM  , Int_t& iPhi_SM  
+    ) const;
+  
+  ClassDef(AliEMCALTriggerMappingV2,1)
+};
+#endif
+
index 4696aa7..4c2363f 100644 (file)
@@ -30,6 +30,9 @@ include_directories(${ROOT_INCLUDE_DIRS}
 set(SRCS
     AliEMCALCalibTimeDepCorrection.cxx
     AliEMCALEMCGeometry.cxx
+    AliEMCALTriggerMapping.cxx
+    AliEMCALTriggerMappingV1.cxx
+    AliEMCALTriggerMappingV2.cxx
     AliEMCALGeometry.cxx
     AliEMCALGeoParams.cxx
     AliEMCALHistoUtilities.cxx
old mode 100644 (file)
new mode 100755 (executable)
index 7e46ef8..ae4115a
@@ -6,6 +6,9 @@
 #pragma link C++ class AliEMCALGeoParams+;
 #pragma link C++ class AliEMCALGeometry+;
 #pragma link C++ class AliEMCALEMCGeometry+;
+#pragma link C++ class AliEMCALTriggerMapping+;
+#pragma link C++ class AliEMCALTriggerMappingV1+;
+#pragma link C++ class AliEMCALTriggerMappingV2+;
 #pragma link C++ class AliEMCALShishKebabTrd1Module+;
 #pragma link C++ class AliEMCALPIDUtils+;
 #pragma link C++ class AliEMCALHistoUtilities+;
index 567c0a9..a78b37d 100644 (file)
@@ -40,7 +40,6 @@ class TF1;
 class AliRawReader;
 #include "AliDetector.h"
 #include "AliEMCALGeometry.h" 
-#include "AliEMCALTrigger.h" 
 #include "AliEMCALRawUtils.h"
 #include "AliReconstructor.h"
 class AliEMCALTriggerData;
@@ -67,9 +66,6 @@ class AliEMCAL : public AliDetector {
   virtual void    Hits2SDigits();
   virtual Int_t   IsVersion(void) const = 0 ;   
   
-  virtual AliTriggerDetector* CreateTriggerDetector() const 
-    { return new AliEMCALTrigger(); }
-
    //  
   virtual AliLoader* MakeLoader(const char* topfoldername);
   virtual const TString Version() const {return TString(" ") ; }   
old mode 100644 (file)
new mode 100755 (executable)
index 70c2e9e..02a02ff
@@ -947,7 +947,7 @@ void AliEMCALDigitizer::Digits2FastOR(TClonesArray* digitsTMP, TClonesArray* dig
   
   if (AliDebugLevel()) printf("Number of TRG digits: %d\n",digitsTMP->GetEntriesFast());
   
-  Int_t     nSamples = geom->GetNTotalTRU();
+  Int_t     nSamples = 32;
   Int_t *timeSamples = new Int_t[nSamples];
   
   NextDigit = TIter(digitsTMP);
old mode 100644 (file)
new mode 100755 (executable)
index 82dceb8..7e243c9
@@ -61,8 +61,6 @@ const int kReturnCodeNoInfo = 9;
 const int kReturnCodeNoObject = 2;
 const int kReturnCodeNoEntries = 1;
 
-const int kNTRU = 62; // EMCAL  (10 SM + 2/3) + (DCAL 10 SM) * 3 TRU per SM
-
 ClassImp(AliEMCALPreprocessor)
   
 //_______________________________________________________________________________________
@@ -327,6 +325,7 @@ UInt_t AliEMCALPreprocessor::MapTemperature(TMap* dcsAliasMap)
 UInt_t AliEMCALPreprocessor::MapTriggerConfig(TMap* dcsAliasMap)
 { // extract DCS trigger info
        
+  const Int_t kNTRU = 46;
        
        AliInfo("Print DCS alias map content");
        dcsAliasMap->Print();
diff --git a/EMCAL/EMCALbase/AliEMCALTrigger.cxx b/EMCAL/EMCALbase/AliEMCALTrigger.cxx
deleted file mode 100644 (file)
index a8ed0f3..0000000
+++ /dev/null
@@ -1,1193 +0,0 @@
-/**************************************************************************
- * 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$ */
-
-//_________________________________________________________________________  
-//
-//  Class for trigger analysis.
-//  Digits are grouped in TRU's  (Trigger Units). A TRU consists of 384 
-//  modules ordered fNTRUPhi x fNTRUEta. The algorithm searches all possible 2x2 
-//  and nxn (n is a multiple of 2) cell combinations per each TRU,  adding the 
-//  digits amplitude and finding the maximum. If found, look if it is isolated.
-//  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.  
-//  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); //Arbitrary threshold values
-//  tr->SetL1GammaLowPtThreshold(1000);
-//  tr->SetL1GammaMediumPtThreshold(10000);
-//  tr->SetL1GammaHighPtThreshold(20000);
-//  ...
-//  tr->Trigger(); //Execute Trigger
-//  tr->Print(""); //Print results
-//
-//*-- Author: Gustavo Conesa & Yves Schutz (IFIC, CERN) 
-//////////////////////////////////////////////////////////////////////////////
-
-#include <cassert>
-
-// --- ROOT system ---
-#include <TTree.h>
-#include <TBranch.h>
-#include <TBrowser.h>
-#include <TH2F.h>
-
-// --- ALIROOT system ---
-#include "AliRun.h" 
-#include "AliRunLoader.h" 
-#include "AliTriggerInput.h"
-#include "AliEMCAL.h" 
-#include "AliEMCALLoader.h" 
-#include "AliEMCALDigit.h"
-#include "AliEMCALTrigger.h" 
-#include "AliEMCALGeometry.h"
-#include "AliEMCALRawUtils.h"
-#include "AliLog.h"
-#include "AliCaloConstants.h"
-#include "AliEMCALRawResponse.h"
-
-using namespace CALO;
-
-ClassImp(AliEMCALTrigger)
-
-TString AliEMCALTrigger::fgNameOfJetTriggers("EMCALJetTriggerL1");
-
-//______________________________________________________________________
-AliEMCALTrigger::AliEMCALTrigger()
-  : AliTriggerDetector(), fGeom(0),
-    f2x2MaxAmp(-1), f2x2ModulePhi(-1),  f2x2ModuleEta(-1),
-    f2x2SM(0),
-    fnxnMaxAmp(-1), fnxnModulePhi(-1),  fnxnModuleEta(-1),
-    fnxnSM(0),
-    fADCValuesHighnxn(0),fADCValuesLownxn(0),
-    fADCValuesHigh2x2(0),fADCValuesLow2x2(0),
-    fDigitsList(0),
-    fL0Threshold(100),fL1GammaLowPtThreshold(200),
-    fL1GammaMediumPtThreshold(500), fL1GammaHighPtThreshold(1000),
-    fPatchSize(1),  fIsolPatchSize(1), 
-    f2x2AmpOutOfPatch(-1), fnxnAmpOutOfPatch(-1), 
-    f2x2AmpOutOfPatchThres(100000),  fnxnAmpOutOfPatchThres(100000), 
-    fIs2x2Isol(kFALSE), fIsnxnIsol(kFALSE),  
-    fSimulation(kTRUE), fIsolateInSuperModule(kTRUE), fTimeKey(kFALSE),
-    fAmpTrus(0),fTimeRtrus(0),fAmpSMods(0),
-    fTriggerPosition(6), fTriggerAmplitudes(4), 
-    fNJetPatchPhi(3), fNJetPatchEta(3), fNJetThreshold(3), fL1JetThreshold(0), fJetMaxAmp(0),
-    fAmpJetMatrix(0), fJetMatrixE(0), fAmpJetMax(6,1), fVZER0Mult(0.)
-{
-  //ctor 
-  fADCValuesHighnxn = 0x0; //new Int_t[fTimeBins];
-  fADCValuesLownxn  = 0x0; //new Int_t[fTimeBins];
-  fADCValuesHigh2x2 = 0x0; //new Int_t[fTimeBins];
-  fADCValuesLow2x2  = 0x0; //new Int_t[fTimeBins];
-
-  SetName("EMCAL");
-  // Define jet threshold - can not change from outside now
-  // fNJetThreshold  = 7; // For MB Pythia suppression
-  fNJetThreshold  = 10;   // Hijing  
-  fL1JetThreshold = new Double_t[fNJetThreshold];
-  if(fNJetThreshold == 7) {
-    fL1JetThreshold[0] =  5./0.0153;
-    fL1JetThreshold[1] =  8./0.0153;
-    fL1JetThreshold[2] = 10./0.0153;
-    fL1JetThreshold[3] = 12./0.0153;
-    fL1JetThreshold[4] = 13./0.0153;
-    fL1JetThreshold[5] = 14./0.0153;
-    fL1JetThreshold[6] = 15./0.0153;
-  } else if(fNJetThreshold == 10) {
-    Double_t thGev[10]={5.,8.,10., 12., 13.,14.,15., 17., 20., 25.};
-    for(Int_t i=0; i<fNJetThreshold; i++) fL1JetThreshold[i] =  thGev[i]/0.0153;
-  } else {
-    fL1JetThreshold[0] =  5./0.0153;
-    fL1JetThreshold[1] = 10./0.0153;
-    fL1JetThreshold[2] = 15./0.0153;
-    fL1JetThreshold[3] = 20./0.0153;
-    fL1JetThreshold[4] = 25./0.0153;
-  }
-  //
-  CreateInputs();
-
-  fInputs.SetName("TriggersInputs");   
-   //Print("") ; 
-}
-
-//____________________________________________________________________________
-AliEMCALTrigger::~AliEMCALTrigger() {
-       
-  //dtor
-       
-  if(GetTimeKey()) {
-    delete [] fADCValuesHighnxn; 
-    delete [] fADCValuesLownxn;
-    delete [] fADCValuesHigh2x2;
-    delete [] fADCValuesLow2x2;
-  }
-  if(fAmpTrus)      {fAmpTrus->Delete();   delete fAmpTrus;}
-  if(fTimeRtrus)    {fTimeRtrus->Delete(); delete fTimeRtrus;}
-  if(fAmpSMods)     {fAmpSMods->Delete();  delete fAmpSMods;}
-  if(fAmpJetMatrix) delete fAmpJetMatrix;
-  if(fJetMatrixE)   delete fJetMatrixE;
-  if(fL1JetThreshold) delete [] fL1JetThreshold;
-}
-
-//----------------------------------------------------------------------
-void AliEMCALTrigger::CreateInputs()
-{
-   // inputs 
-   
-   // Do not create inputs again!!
-   if( fInputs.GetEntriesFast() > 0 ) return;
-
-   // Second parameter should be detector name = "EMCAL"
-   TString det("EMCAL"); // Apr 29, 2008
-   fInputs.AddLast( new AliTriggerInput( det+"_L0",          det, 0x02) );
-   fInputs.AddLast( new AliTriggerInput( det+"_GammaHPt_L1", det, 0x04 ) );
-   fInputs.AddLast( new AliTriggerInput( det+"_GammaMPt_L1", det, 0x08 ) );
-   fInputs.AddLast( new AliTriggerInput( det+"_GammaLPt_L1", det, 0x016 ) );
-   fInputs.AddLast( new AliTriggerInput( det+"_JetHPt_L1", det, 0x032 ) );
-   fInputs.AddLast( new AliTriggerInput( det+"_JetMPt_L1", det, 0x048 ) );
-   fInputs.AddLast( new AliTriggerInput( det+"_JetLPt_L1", det, 0x064 ) );
-
-   if(fNJetThreshold<=0) return;
-   // Jet Trigger(s)
-   UInt_t level = 0x032;
-   for(Int_t i=0; i<fNJetThreshold; i++ ) {
-     TString name(GetNameOfJetTrigger(i));
-     TString title("EMCAL Jet triger L1 :"); // unused now
-     // 0.0153 - hard coded now
-     title += Form("Th %i(%5.1f GeV) :", (Int_t)fL1JetThreshold[i], fL1JetThreshold[i] * 0.0153); 
-     title += Form("patch %ix%i~(%3.2f(#phi)x%3.2f(#eta)) ", 
-                fNJetPatchPhi, fNJetPatchEta, 0.11*(fNJetPatchPhi), 0.11*(fNJetPatchEta)); 
-     fInputs.AddLast( new AliTriggerInput(name, det, UChar_t(level)) );
-     level *= 2;
-   }
-}
-
-//____________________________________________________________________________
-Bool_t AliEMCALTrigger::IsPatchIsolated(Int_t iPatchType, const TClonesArray * ampmatrixes, const Int_t iSM, const Int_t mtru, const Float_t maxamp, const Int_t maxphi, const Int_t maxeta) {
-
-  // Nov 8, 2007 
-  // EMCAL RTU size is 4modules(phi) x 24modules (eta)
-  // So maximum size of patch is 4modules x 4modules (EMCAL L0 trigger). 
-  // Calculate if the maximum patch found is isolated, find amplitude around maximum (2x2 or nxn) patch, 
-  // inside isolation patch . iPatchType = 0 means calculation for 2x2 patch, 
-  // iPatchType = 1 means calculation for nxn patch.
-  // In the next table there is an example of the different options of patch size and isolation patch size:
-  //                                                           Patch Size (fPatchSize)
-  //                                           0                          1              
-  //          fIsolPatchSize    0             2x2 (not overlap)   4x4 (overlapped)       
-  //                            1             4x4                      8x8               
-                          
-  Bool_t b = kFALSE;
-  if(!ampmatrixes) return kFALSE;
-  
-  // Get matrix of TRU or Module with maximum amplitude patch.
-  Int_t itru = mtru + iSM * fGeom->GetNTRU(); //number of tru, min 0 max 3*22=66.
-  TMatrixD * ampmatrix   = 0x0;
-  Int_t colborder = 0;
-  Int_t rowborder = 0;
-  static int keyPrint = 0;
-  if(keyPrint) AliDebug(2,Form(" IsPatchIsolated : iSM %i mtru %i itru %i maxphi %i maxeta %i \n", iSM, mtru, itru, maxphi, maxeta));
-  
-  if(fIsolateInSuperModule){ // ?
-    ampmatrix = dynamic_cast<TMatrixD *>(ampmatrixes->At(iSM)) ;
-    rowborder = fGeom->GetNPhi();
-    colborder = fGeom->GetNZ();
-    AliDebug(2,"Isolate trigger in Module");
-  } else{
-    ampmatrix = dynamic_cast<TMatrixD *>(ampmatrixes->At(itru)) ;
-    rowborder = fGeom->GetNModulesInTRUPhi();
-    colborder = fGeom->GetNModulesInTRUEta();
-    AliDebug(2,"Isolate trigger in TRU");
-  }
-  if(iSM>9) rowborder /= 2; // half size in phi
-  
-  if(!ampmatrixes || !ampmatrix){
-    AliError("Could not recover the matrix with the amplitudes");
-    return kFALSE;
-  }
-  
-  //Define patch modules - what is this ??
-  Int_t isolmodules   = fIsolPatchSize*(1+iPatchType);
-  Int_t ipatchmodules = 2*(1+fPatchSize*iPatchType);
-  Int_t minrow      = maxphi - isolmodules;
-  Int_t mincol      = maxeta - isolmodules;
-  Int_t maxrow      = maxphi + isolmodules + ipatchmodules;
-  Int_t maxcol      = maxeta + isolmodules + ipatchmodules;
-
-  minrow =  minrow<0?0 :minrow;
-  mincol =  mincol<0?0 :mincol;
-
-  maxrow =  maxrow>rowborder?rowborder :maxrow;
-  maxcol =  maxcol>colborder?colborder :maxcol;
-  
-  //printf("%s\n",Form("Number of added Isol Modules %d, Patch Size %d",isolmodules, ipatchmodules));
-  //printf("%s\n",Form("Patch: minrow %d, maxrow %d, mincol %d, maxcol %d",minrow,maxrow,mincol,maxcol));
-  //  AliDebug(2,Form("Number of added Isol Modules %d, Patch Size %d",isolmodules, ipatchmodules));
-  //AliDebug(2,Form("Patch: minrow %d, maxrow %d, mincol %d, maxcol %d",minrow,maxrow,mincol,maxcol));
-  
-  //Add amplitudes in all isolation patch
-  Float_t amp = 0.;
-  for(Int_t irow = minrow ; irow <  maxrow; irow ++)
-    for(Int_t icol = mincol ; icol < maxcol ; icol ++)
-      amp += (*ampmatrix)(irow,icol);
-  
-  AliDebug(2,Form("Type %d, Maximum amplitude %f, patch+isol square %f",iPatchType, maxamp, amp));
-
-  if(amp < maxamp){
-    //    AliError(Form("Bad sum: Type %d, Maximum amplitude %f, patch+isol square %f",iPatchType, maxamp, amp));
-    //    ampmatrix->Print();
-    return kFALSE;
-  } else {
-    amp-=maxamp; //Calculate energy in isolation patch that do not comes from maximum patch.
-  }
-  
-  AliDebug(2, Form("Maximum amplitude %f, Out of patch %f",maxamp, amp));
-
-  //Fill isolation amplitude data member and say if patch is isolated.
-  if(iPatchType == 0){ //2x2 case
-    f2x2AmpOutOfPatch = amp;   
-    if(amp < f2x2AmpOutOfPatchThres) b=kTRUE;
-  } else  if(iPatchType == 1){ //nxn case
-    fnxnAmpOutOfPatch = amp;   
-    if(amp < fnxnAmpOutOfPatchThres) b=kTRUE;
-  }
-
-  if(keyPrint) AliDebug(2,Form(" IsPatchIsolated - OUT \n"));
-
-  return b;
-
-}
-
-/*
-//____________________________________________________________________________
-void AliEMCALTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus, const Int_t isupermod,TMatrixD &ampmax2, TMatrixD &ampmaxn){
-  
-  //Sums energy of all possible 2x2 (L0) and nxn (L1) modules per each TRU. 
-  //Fast signal in the experiment is given by 2x2 modules, 
-  //for this reason we loop inside the TRU modules by 2. 
-
-  //Declare and initialize variables
-  Int_t nCellsPhi  = fGeom->GetNCellsInTRUPhi();
-  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  = fGeom->GetNCellsInTRUEta();
-  Int_t nTRU  = fGeom->GetNTRU();
-  // 24(mod)*2(tower)/3 TRU, cells in Eta in one TRU
-  //Int_t nTRU          = geom->GeNTRU();//3 TRU per super module
-
-  Float_t amp2 = 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;
-      ampmaxn(i,j) = -1;
-    }
-  }
-
-  //Create matrix that will contain 2x2 amplitude sums
-  //used to calculate the nxn sums
-  TMatrixD tru2x2(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 * 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*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 cells for use in nxn sums
-       tru2x2(irow/2,icol/2) = amp2 ;
-       //Select 2x2 maximum sums to select L0 
-       if(amp2 > ampmax2(0,mtru)){
-         ampmax2(0,mtru) = amp2 ; 
-         ampmax2(1,mtru) = irow;
-         ampmax2(2,mtru) = icol;
-       }
-      }
-    }
-    
-    //Find most recent time in the selected 2x2 cell
-    ampmax2(3,mtru) = 1 ;
-    Int_t row2 =  static_cast <Int_t> (ampmax2(1,mtru));
-    Int_t col2 =  static_cast <Int_t> (ampmax2(2,mtru));
-    for(Int_t i = 0; i<2; i++){
-      for(Int_t j = 0; j<2; j++){
-       if((*amptru)(row2+i,col2+j) > 0 &&  (*timeRtru)(row2+i,col2+j)> 0){       
-         if((*timeRtru)(row2+i,col2+j) <  ampmax2(3,mtru)  )
-           ampmax2(3,mtru) =  (*timeRtru)(row2+i,col2+j);
-       }
-      }
-    }
-
-    //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 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){//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 AliEMCALTrigger::MakeSlidingTowers(const TClonesArray * amptrus, const TClonesArray * timeRtrus, 
-                                        const Int_t isupermod,TMatrixD &ampmax2, TMatrixD &ampmaxn){
-  
-  // Output from module (2x2 cells from one module)
-  Int_t nModulesPhi  = fGeom->GetNModulesInTRUPhi(); // now 4 modules (3 div in phi)
-  if(isupermod > 9)
-    nModulesPhi =  nModulesPhi / 2 ; // Half size SM. Not Final.
-  // 
-  Int_t nModulesEta  = fGeom->GetNModulesInTRUEta(); // now 24 modules (no division in eta)
-  Int_t nTRU         = fGeom->GetNTRU();
-  static int keyPrint = 0;
-  if(keyPrint) AliDebug(2,Form("MakeSlidingTowers : nTRU %i nModulesPhi %i nModulesEta %i ", 
-                               nTRU, nModulesPhi, nModulesEta ));
-  
-  Float_t amp2 = 0 ;
-  Float_t ampn = 0 ; 
-  for(Int_t i = 0; i < 4; i++){
-    for(Int_t j = 0; j < nTRU; j++){
-      ampmax2(i,j) = ampmaxn(i,j) = -1;
-    }
-  }
-  
-  // Create matrix that will contain 2x2 amplitude sums
-  // used to calculate the nxn sums
-  TMatrixD tru2x2(nModulesPhi/2,nModulesEta/2);
-  
-  // Loop over all TRUS in a supermodule
-  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*nTRU ; // Number of TRU in Supermodule !!
-    
-    if(!amptru || !timeRtru){
-      AliError("Amplitude or Time TRU matrix not available");
-      return;
-    }
-    
-    // Sliding 2x2, add 2x2 amplitudes (NOT OVERLAP)
-    for(Int_t irow = 0 ; irow <  nModulesPhi; irow +=2){ 
-      for(Int_t icol = 0 ; icol < nModulesEta ; icol +=2){
-        amp2 = (*amptru)(irow,icol) +(*amptru)(irow+1,icol)+
-        (*amptru)(irow,icol+1)+(*amptru)(irow+1,icol+1);
-        
-        //Fill matrix with added 2x2 towers for use in nxn sums
-        tru2x2(irow/2,icol/2) = amp2 ;
-        //Select 2x2 maximum sums to select L0 
-        if(amp2 > ampmax2(0,mtru)){
-          ampmax2(0,mtru) = amp2 ; 
-          ampmax2(1,mtru) = irow;
-          ampmax2(2,mtru) = icol;
-        }
-      }
-    }
-    
-    ampmax2(3,mtru) = 0.;
-    if(GetTimeKey()) {
-      // Find most recent time in the selected 2x2 towers
-      Int_t row2 =  static_cast <Int_t> (ampmax2(1,mtru));
-      Int_t col2 =  static_cast <Int_t> (ampmax2(2,mtru));
-      for(Int_t i = 0; i<2; i++){
-        for(Int_t j = 0; j<2; j++){
-          if((*amptru)(row2+i,col2+j) > 0 &&  (*timeRtru)(row2+i,col2+j)> 0){    
-            if((*timeRtru)(row2+i,col2+j) >  ampmax2(3,mtru)  )
-              ampmax2(3,mtru) =  (*timeRtru)(row2+i,col2+j); // max time
-          }
-        }
-      }
-    }
-    
-    //Sliding nxn, add nxn amplitudes  (OVERLAP)
-    if(fPatchSize > 0){
-      for(Int_t irow = 0 ; irow <  nModulesPhi/2; irow++){ 
-        for(Int_t icol = 0 ; icol < nModulesEta/2; icol++){
-          ampn = 0;
-          if( (irow+fPatchSize) < nModulesPhi/2 && (icol+fPatchSize) < nModulesEta/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;
-              ampmaxn(2,mtru) = icol;
-            }
-          }
-        }
-      }
-      
-      ampmaxn(3,mtru) = 0.; // Was 1 , I don't know why
-      if(GetTimeKey()) {
-        //Find most recent time in selected nxn cell
-        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) < nModulesPhi && (coln+j) < nModulesEta){//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); // max time
-              }
-            }
-          }
-        }
-      }
-    } else { // copy 2x2 to nxn  
-      ampmaxn(0,mtru) =  ampmax2(0,mtru); 
-      ampmaxn(1,mtru) =  ampmax2(1,mtru);
-      ampmaxn(2,mtru) =  ampmax2(2,mtru);
-      ampmaxn(3,mtru) =  ampmax2(3,mtru);
-    }
-  }
-  if(keyPrint) AliDebug(2,Form(" : MakeSlidingTowers -OUt \n"));
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::Print(const Option_t * opt) const 
-{
-  
-  //Prints main parameters
-  
-  if(! opt)
-    return;
-  AliTriggerInput* in = 0x0 ;
-  AliInfo(Form(" fSimulation %i (input option) : #digits %i\n", fSimulation, fDigitsList->GetEntries()));
-  AliInfo(Form(" fTimeKey    %i  \n ", fTimeKey));
-
-  AliInfo(Form("\t Maximum Amplitude after Sliding Cell, \n")) ; 
-  AliInfo(Form("\t -2x2 cells sum (not overlapped): %10.2f, in Super Module %d\n",
-         f2x2MaxAmp,f2x2SM)) ; 
-  AliInfo(Form("\t -2x2 from row %d to row %d and from column %d to column %d\n", f2x2ModulePhi, f2x2ModulePhi+2, f2x2ModuleEta, f2x2ModuleEta+2)); 
-  AliInfo(Form("\t -2x2 Isolation Patch %d x %d, Amplitude out of 2x2 patch is %f, threshold %f, Isolated? %d \n", 2*fIsolPatchSize+2, 2*fIsolPatchSize+2,  f2x2AmpOutOfPatch,  f2x2AmpOutOfPatchThres,static_cast<Int_t> (fIs2x2Isol))); 
-  if(fPatchSize > 0){
-    AliInfo(Form("\t Patch Size, n x n: %d x %d cells\n",2*(fPatchSize+1), 2*(fPatchSize+1)));
-    AliInfo(Form("\t -nxn cells sum (overlapped)    : %10.2f, in Super Module %d\n", fnxnMaxAmp,fnxnSM)); 
-    AliInfo(Form("\t -nxn from row %d to row %d and from column %d to column %d\n", fnxnModulePhi, fnxnModulePhi+4*fPatchSize, fnxnModuleEta, fnxnModuleEta+4*fPatchSize)) ; 
-    AliInfo(Form("\t -nxn Isolation Patch %d x %d, Amplitude out of nxn patch is %f, threshold %f, Isolated? %d \n", 4*fIsolPatchSize+2*(fPatchSize+1),4*fIsolPatchSize+2*(fPatchSize+1) ,  fnxnAmpOutOfPatch,  fnxnAmpOutOfPatchThres,static_cast<Int_t> (fIsnxnIsol) )); 
-  }
-  
-  AliInfo(Form("\t Isolate in SuperModule? %d\n", fIsolateInSuperModule)) ;  
-  AliInfo(Form("\t Threshold for LO %10.2f\n", fL0Threshold));  
-
-  in = (AliTriggerInput*)fInputs.FindObject( "EMCAL_L0" );
-  if(in->GetValue())
-    AliInfo(Form("\t *** EMCAL LO is set ***\n")); 
-  
-  AliInfo(Form("\t Gamma Low Pt Threshold for L1 %10.2f\n", fL1GammaLowPtThreshold));
-  in = (AliTriggerInput*)fInputs.FindObject( "EMCAL_GammaLPt_L1" );
-  if(in->GetValue())
-    AliInfo(Form("\t *** EMCAL Gamma Low Pt for L1 is set ***\n"));
-
-  AliInfo(Form("\t Gamma Medium Pt Threshold for L1 %10.2f\n", fL1GammaMediumPtThreshold));  
-  in = (AliTriggerInput*) fInputs.FindObject( "EMCAL_GammaMPt_L1" );
-  if(in->GetValue())
-    AliInfo(Form("\t *** EMCAL Gamma Medium Pt for L1 is set ***\n"));
-
-  AliInfo(Form("\t Gamma High Pt Threshold for L1 %10.2f\n", fL1GammaHighPtThreshold));  
-  in = (AliTriggerInput*) fInputs.FindObject( "EMCAL_GammaHPt_L1" );
-  if(in->GetValue())
-    AliInfo(Form("\t *** EMCAL Gamma High Pt for L1 is set ***\n")) ;
-
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::SetTriggers(const TClonesArray * ampmatrix,const Int_t iSM, 
-                                 const TMatrixD &ampmax2, 
-                                 const TMatrixD &ampmaxn)  
-{
-  //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 maxn[] = {-1,-1,-1,-1} ;
-  Int_t   mtru2  = -1 ;
-  Int_t   mtrun  = -1 ;
-
-  Int_t nTRU = fGeom->GetNTRU();
-
-  //Find maximum summed amplitude of all the TRU 
-  //in a Super Module
-    for(Int_t i = 0 ; i < nTRU ; i++){
-      if(max2[0] < ampmax2(0,i) ){
-       max2[0] =  ampmax2(0,i) ; // 2x2 summed max amplitude
-       max2[1] =  ampmax2(1,i) ; // corresponding phi position in TRU
-       max2[2] =  ampmax2(2,i) ; // corresponding eta position in TRU
-       max2[3] =  ampmax2(3,i) ; // corresponding most recent time
-       mtru2   = 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
-       mtrun   = i ;
-      }
-    }
-
-  //--------Set max amplitude if larger than in other Super Modules------------
-  Float_t maxtimeR2 = -1 ;
-  Float_t maxtimeRn = -1 ;
-  static AliEMCALRawUtils rawUtil;
-  // Int_t nTimeBins = rawUtil.GetRawFormatTimeBins() ;
-  Int_t nTimeBins = TIMEBINS;  //changed by PTH
-
-  //Set max of 2x2 amplitudes and select L0 trigger
-  if(max2[0] > f2x2MaxAmp ){
-    //    if(max2[0] > 5) printf(" L0 : iSM %i: max2[0] %5.0f :  max2[3] %5.0f  (maxtimeR2) \n", 
-    //                    iSM, max2[0], max2[3]);
-    f2x2MaxAmp  = max2[0] ;
-    f2x2SM      = iSM ;
-    maxtimeR2   = max2[3] ;
-    fGeom->GetModulePhiEtaIndexInSModuleFromTRUIndex(mtru2, 
-                                                 static_cast<Int_t>(max2[1]),
-                                                 static_cast<Int_t>(max2[2]),
-                                                  f2x2ModulePhi,f2x2ModuleEta);
-    
-    //Isolated patch?
-    if(fIsolateInSuperModule)
-      fIs2x2Isol =  IsPatchIsolated(0, ampmatrix, iSM, mtru2,  f2x2MaxAmp, f2x2ModulePhi,f2x2ModuleEta) ;
-    else
-      fIs2x2Isol =  IsPatchIsolated(0, ampmatrix, iSM, mtru2,  f2x2MaxAmp,  static_cast<Int_t>(max2[1]), static_cast<Int_t>(max2[2])) ;
-
-    if(GetTimeKey()) {
-    //Transform digit amplitude in Raw Samples
-      if (fADCValuesLow2x2 == 0) {
-        fADCValuesLow2x2  = new Int_t[nTimeBins];
-        fADCValuesHigh2x2 = new Int_t[nTimeBins];
-      }
-      //printf(" maxtimeR2 %12.5e (1)\n", maxtimeR2);
-      //  rawUtil.RawSampledResponse(maxtimeR2 * AliEMCALRawUtils::GetRawFormatTimeBin(), 
-      //                                f2x2MaxAmp, fADCValuesHigh2x2, fADCValuesLow2x2) ; 
-       
-      //  rawUtil.RawSampledResponse(maxtimeR2*TIMEBINMAX/TIMEBINS, 
-      //                                f2x2MaxAmp, fADCValuesHigh2x2, fADCValuesLow2x2) ; 
-      
-      AliEMCALRawResponse::RawSampledResponse( maxtimeR2*TIMEBINMAX/TIMEBINS, 
-                                              f2x2MaxAmp, fADCValuesHigh2x2, fADCValuesLow2x2) ; 
-
-    // Set Trigger Inputs, compare ADC time bins until threshold is attained
-    // Set L0
-      for(Int_t i = 0 ; i < nTimeBins ; i++){
-      //      printf(" fADCValuesHigh2x2[%i] %i : %i \n", i, fADCValuesHigh2x2[i], fADCValuesLow2x2[i]); 
-        if(fADCValuesHigh2x2[i] >= fL0Threshold          || fADCValuesLow2x2[i] >= fL0Threshold){
-         SetInput("EMCAL_L0") ;
-         break;
-        }
-      }
-    } else {
-      // Nov 5 - no analysis of time information
-      if(f2x2MaxAmp >= fL0Threshold) { // should add the low amp too
-        SetInput("EMCAL_L0");
-      }
-    }
-  }
-  
-  //------------Set max of nxn amplitudes and select L1 trigger---------
-  if(maxn[0] > fnxnMaxAmp ){
-    fnxnMaxAmp  = maxn[0] ;
-    fnxnSM      = iSM ;
-    maxtimeRn   = maxn[3] ;
-    fGeom->GetModulePhiEtaIndexInSModuleFromTRUIndex(mtrun, 
-                                                 static_cast<Int_t>(maxn[1]),
-                                                 static_cast<Int_t>(maxn[2]),
-                                                 fnxnModulePhi,fnxnModuleEta) ; 
-    
-    //Isolated patch?
-    if(fIsolateInSuperModule)
-      fIsnxnIsol =  IsPatchIsolated(1, ampmatrix, iSM, mtrun,  fnxnMaxAmp, fnxnModulePhi, fnxnModuleEta) ;
-    else
-      fIsnxnIsol =  IsPatchIsolated(1, ampmatrix, iSM, mtrun,  fnxnMaxAmp,  static_cast<Int_t>(maxn[1]), static_cast<Int_t>(maxn[2])) ;
-    
-    if(GetTimeKey()) {
-    //Transform digit amplitude in Raw Samples
-      if (fADCValuesLownxn == 0) {
-        fADCValuesHighnxn = new Int_t[nTimeBins];
-        fADCValuesLownxn  = new Int_t[nTimeBins];
-      }
-      //  rawUtil.RawSampledResponse(maxtimeRn * AliEMCALRawUtils::GetRawFormatTimeBin(), 
-      //   fnxnMaxAmp, fADCValuesHighnxn, fADCValuesLownxn) ;
-
-      //rawUtil.RawSampledResponse(maxtimeRn*TIMEBINMAX/TIMEBINS, 
-      //                                fnxnMaxAmp, fADCValuesHighnxn, fADCValuesLownxn) ;
-
-      AliEMCALRawResponse::RawSampledResponse (maxtimeRn*TIMEBINMAX/TIMEBINS, 
-                                              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(fADCValuesHighnxn[i] >= fL1GammaLowPtThreshold  || fADCValuesLownxn[i] >= fL1GammaLowPtThreshold){
-         SetInput("EMCAL_GammaLPt_L1") ;
-         break; 
-        }
-      }
-    
-    //SetL1 Medium
-      for(Int_t i = 0 ; i < nTimeBins ; i++){
-        if(fADCValuesHighnxn[i] >= fL1GammaMediumPtThreshold || fADCValuesLownxn[i] >= fL1GammaMediumPtThreshold){
-         SetInput("EMCAL_GammaMPt_L1") ;
-         break;
-        }
-      }
-    
-    //SetL1 High
-      for(Int_t i = 0 ; i < nTimeBins ; i++){
-        if(fADCValuesHighnxn[i] >= fL1GammaHighPtThreshold || fADCValuesLownxn[i] >= fL1GammaHighPtThreshold){
-         SetInput("EMCAL_GammaHPt_L1") ;
-         break;
-        }
-      }
-    } else {
-      // Nov 5 - no analysis of time information
-      if(fnxnMaxAmp >= fL1GammaLowPtThreshold) { // should add the low amp too
-       SetInput("EMCAL_GammaLPt_L1") ; //SetL1 Low
-      }
-      if(fnxnMaxAmp >= fL1GammaMediumPtThreshold) { // should add the low amp too
-       SetInput("EMCAL_GammaMPt_L1") ; //SetL1 Medium
-      }
-      if(fnxnMaxAmp >= fL1GammaHighPtThreshold) { // should add the low amp too
-       SetInput("EMCAL_GammaHPt_L1") ; //SetL1 High
-      }
-    }
-  }
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::FillTRU(const TClonesArray * digits, TClonesArray * ampmatrix, TClonesArray * ampmatrixsmod, TClonesArray * timeRmatrix) {
-
-//  Orders digits ampitudes list in fNTRU TRUs (384 cells) per supermodule. 
-//  Each TRU is a TMatrixD, and they are kept in TClonesArrays. The number of 
-//  TRU in phi is fNTRUPhi, and the number of TRU in eta is fNTRUEta.
-//  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. Also fill a matrix with all amplitudes in supermodule for isolation studies. 
-//  Initilize and declare variables
-//  List of TRU matrices initialized to 0.
-//  printf("<I> AliEMCALTrigger::FillTRU() started : # digits %i\n", digits->GetEntriesFast());
-
-// Nov 2, 2007.
-// One input per EMCAL module so size of matrix is reduced by 4 (2x2 division case) 
-
-  Int_t nPhi        = fGeom->GetNPhi();
-  Int_t nZ          = fGeom->GetNZ();
-  Int_t nTRU        = fGeom->GetNTRU();
-  //  Int_t nTRUPhi     = fGeom->GetNTRUPhi();
-  Int_t nModulesPhi  = fGeom->GetNModulesInTRUPhi();
-  Int_t nModulesPhi2 = fGeom->GetNModulesInTRUPhi();
-  Int_t nModulesEta  = fGeom->GetNModulesInTRUEta();
-  //  printf("<I> AliEMCALTrigger::FillTRU() nTRU %i  nTRUPhi %i : nModulesPhi %i nModulesEta %i \n", 
-  //    nTRU, nTRUPhi, nModulesPhi, nModulesEta);
-
-  Int_t id       = -1; 
-  Float_t amp    = -1;
-  Float_t timeR  = -1;
-  Int_t iSupMod  = -1;
-  Int_t nModule  = -1;
-  Int_t nIphi    = -1;
-  Int_t nIeta    = -1;
-  Int_t iphi     = -1;
-  Int_t ieta     = -1;
-  // iphim, ietam - module indexes in SM 
-  Int_t iphim    = -1;
-  Int_t ietam    = -1;
-
-  //List of TRU matrices initialized to 0.
-  Int_t nSup = fGeom->GetNumberOfSuperModules();
-  for(Int_t k = 0; k < nTRU*nSup; k++){
-    TMatrixD amptrus(nModulesPhi,nModulesEta) ;
-    TMatrixD timeRtrus(nModulesPhi,nModulesEta) ;
-    // Do we need to initialise? I think TMatrixD does it by itself...
-    for(Int_t i = 0; i < nModulesPhi; i++){
-      for(Int_t j = 0; j < nModulesEta; j++){
-       amptrus(i,j) = 0.0;
-       timeRtrus(i,j) = 0.0;
-      }
-    }
-    new((*ampmatrix)[k])   TMatrixD(amptrus) ;
-    new((*timeRmatrix)[k]) TMatrixD(timeRtrus) ; 
-  }
-  
-  // List of Modules matrices initialized to 0.
-  for(Int_t k = 0; k < nSup ; k++){
-    int mphi = nPhi;
-    //    if(nSup>9) mphi = nPhi/2; // the same size
-    TMatrixD  ampsmods( mphi, nZ);
-    for(Int_t i = 0; i <  mphi; i++){
-      for(Int_t j = 0; j < nZ; j++){
-       ampsmods(i,j)   = 0.0;
-      }
-    }
-    new((*ampmatrixsmod)[k]) TMatrixD(ampsmods) ;
-  }
-
-  AliEMCALDigit * dig ;
-  
-  //Digits loop to fill TRU matrices with amplitudes.
-  for(Int_t idig = 0 ; idig < digits->GetEntriesFast() ; idig++){
-    
-    dig = dynamic_cast<AliEMCALDigit *>(digits->At(idig)) ;
-    if(dig){
-      amp    = Float_t(dig->GetAmplitude()); // Energy of the digit (arbitrary units)
-      id     = dig->GetId() ;          // Id label of the cell
-      timeR  = dig->GetTimeR() ;       // Earliest time of the digit
-      if(amp<=0.0) AliDebug(1,Form(" id %i amp %f \n", id, amp));
-      // printf(" FILLTRU : timeR %10.5e time %10.5e : amp %10.5e \n", timeR, dig->GetTime(), amp);
-      // Get eta and phi cell position in supermodule
-      Bool_t bCell = fGeom->GetCellIndex(id, iSupMod, nModule, nIphi, nIeta) ;
-      if(!bCell)
-        AliError(Form("%i Wrong cell id number %i ", idig, id)) ;
-      
-      fGeom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
-      // iphim, ietam - module indexes in SM
-      fGeom->GetModuleIndexesFromCellIndexesInSModule(iSupMod,iphi,ieta, iphim, ietam, nModule); 
-      //if(iSupMod >9) 
-      //printf("iSupMod %i nModule %i iphi %i  ieta %i  iphim %i  ietam %i \n",
-      //iSupMod,nModule, iphi, ieta, iphim, ietam); 
-      
-      // Check to which TRU in the supermodule belongs the cell. 
-      // Supermodules are divided in a TRU matrix of dimension 
-      // (fNTRUPhi,fNTRUEta).
-      // Each TRU is a cell matrix of dimension (nModulesPhi,nModulesEta)
-      
-      // First calculate the row and column in the supermodule 
-      // of the TRU to which the cell belongs.
-      Int_t row   = iphim / nModulesPhi;
-      Int_t col   = ietam / nModulesEta;
-      //Calculate label number of the TRU
-      Int_t itru  = fGeom->GetAbsTRUNumberFromNumberInSm(row, col, iSupMod);
-      
-      //Fill TRU matrix with cell values
-      TMatrixD * amptrus   = dynamic_cast<TMatrixD *>(ampmatrix->At(itru)) ;
-      TMatrixD * timeRtrus = dynamic_cast<TMatrixD *>(timeRmatrix->At(itru)) ;
-      
-      if(!amptrus || !timeRtrus){
-        AliError("Could not recover the TRU matrix with amplitudes or times");
-      }
-      else{
-        //Calculate row and column of the module inside the TRU with number itru
-        Int_t irow = iphim - row * nModulesPhi;
-        if(iSupMod > 9)
-          irow = iphim - row *  nModulesPhi2; // size of matrix the same
-        Int_t icol = ietam - col * nModulesEta;
-      
-        (*amptrus)(irow,icol)  += amp ;
-        if((*timeRtrus)(irow,icol) <0.0 || (*timeRtrus)(irow,icol) <= timeR){ // ??
-          (*timeRtrus)(irow,icol) = timeR ;
-        }
-      }
-      //printf(" ieta %i iphi %i iSM %i || col %i row %i : itru %i -> amp %f\n", 
-      //          ieta, iphi, iSupMod, col, row, itru, amp);     
-      //####################SUPERMODULE MATRIX ##################
-      TMatrixD * ampsmods   = dynamic_cast<TMatrixD *>(ampmatrixsmod->At(iSupMod)) ;
-      if(!ampsmods){
-        AliError("Could not recover the matrix per SM");
-        continue;
-      }
-      (*ampsmods)(iphim,ietam)  += amp ;
-      //    printf(" id %i iphim %i ietam %i SM %i : irow %i icol %i itru %i : amp %6.0f\n", 
-      //id, iphim, ietam, iSupMod, irow, icol, itru, amp); 
-    }
-    else AliError("Could not recover the digit");
-  }
-  //assert(0);
-  //printf("<I> AliEMCALTrigger::FillTRU() is ended \n");
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::Trigger() 
-{
-  //Main Method to select triggers.
-  TH1::AddDirectory(0);
-
-  AliRunLoader *runLoader = AliRunLoader::Instance();
-  AliEMCALLoader *emcalLoader = 0;
-  if(runLoader) {
-    emcalLoader = dynamic_cast<AliEMCALLoader*>(runLoader->GetDetectorLoader("EMCAL"));
-  }
-  //Load EMCAL Geometry
-  if (runLoader && runLoader->GetAliRun()){
-    AliEMCAL* emcal = dynamic_cast<AliEMCAL*>(runLoader->GetAliRun()->GetDetector("EMCAL"));
-    if(emcal)fGeom = emcal->GetGeometry();
-  }
-  
-  if (!fGeom)   
-    fGeom = AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());          
-
-  if (!fGeom)
-    AliFatal("Did not get geometry from EMCALLoader");
-  
-  //Define parameters
-  Int_t nSuperModules = fGeom->GetNumberOfSuperModules() ; //12 SM in EMCAL and 6/10 DCAL SMs
-  Int_t nTRU       = fGeom->GetNTRU();    // 3 TRU per super module
-
-  //Intialize data members each time the trigger is called in event loop
-  f2x2MaxAmp = -1; f2x2ModulePhi = -1;  f2x2ModuleEta = -1;
-  fnxnMaxAmp = -1; fnxnModulePhi = -1;  fnxnModuleEta = -1;
-
-  // Take the digits list if simulation
-  if(fSimulation && runLoader && emcalLoader){ // works than run seperate macros
-    runLoader->LoadDigits("EMCAL");
-    fDigitsList = emcalLoader->Digits() ;
-    runLoader->LoadSDigits("EMCAL");
-  }
-  // Digits list should be set by method SetDigitsList(TClonesArray * digits)
-  if(!fDigitsList)
-    AliFatal("Digits not found !") ;
-  
-  //Take the digits list 
-  
-  // Delete old if unzero
-  if(fAmpTrus)     {fAmpTrus->Delete();   delete fAmpTrus;}
-  if(fTimeRtrus)   {fTimeRtrus->Delete(); delete fTimeRtrus;}
-  if(fAmpSMods)    {fAmpSMods->Delete();  delete fAmpSMods;}
-  // Fill TRU and SM matrix    
-  fAmpTrus   = new TClonesArray("TMatrixD",nTRU);
-  fAmpTrus->SetName("AmpTrus");
-  fTimeRtrus = new TClonesArray("TMatrixD",nTRU);
-  fTimeRtrus->SetName("TimeRtrus");
-  fAmpSMods  = new TClonesArray("TMatrixD",nSuperModules);
-  fAmpSMods->SetName("AmpSMods");
-  
-  FillTRU(fDigitsList, fAmpTrus, fAmpSMods, fTimeRtrus);
-
-  // Jet stuff - only one case, no freedom here
-  if(fGeom->GetNEtaSubOfTRU() == 6) {
-    if(fAmpJetMatrix) {delete fAmpJetMatrix; fAmpJetMatrix=0;}
-    if(fJetMatrixE)   {delete fJetMatrixE; fJetMatrixE=0;}
-
-    fAmpJetMatrix = new TMatrixD(17,12); // 17-phi(row), 12-eta(col)
-    fJetMatrixE = new TH2F("fJetMatrixE"," E of max patch in (#phi,#eta)", 
-    17, 80.*TMath::DegToRad(), (180.+20.*2/3.)*TMath::DegToRad(), 12, -0.7, 0.7);
-    for(Int_t row=0; row<fAmpJetMatrix->GetNrows(); row++) {
-      for(Int_t col=0; col<fAmpJetMatrix->GetNcols(); col++) {
-        (*fAmpJetMatrix)(row,col) = 0.;
-      }
-    }
-    FillJetMatrixFromSMs(fAmpSMods, fAmpJetMatrix, fGeom);
-  }
-  if(!CheckConsistentOfMatrixes()) assert(0);
-
-  // Do Tower Sliding and select Trigger
-  // Initialize varible that will contain maximum amplitudes and 
-  // its corresponding tower position in eta and phi, and time.
-  TMatrixD ampmax2(4,nTRU) ; // 0-max amp, 1-irow, 2-icol, 3-timeR
-  TMatrixD ampmaxn(4,nTRU) ;
-  
-  for(Int_t iSM = 0 ; iSM < nSuperModules ; iSM++) {
-    //Do 2x2 and nxn sums, select maximums. 
-
-    MakeSlidingTowers(fAmpTrus, fTimeRtrus, iSM, ampmax2, ampmaxn);
-    
-    // Set the trigger
-    if(fIsolateInSuperModule) // here some discripency between tru and SM
-      SetTriggers(fAmpSMods,iSM,ampmax2,ampmaxn) ;
-    if(!fIsolateInSuperModule)
-      SetTriggers(fAmpTrus,iSM,ampmax2,ampmaxn) ;
-  }
-  
-  // Do patch sliding and select Jet Trigger
-  // 0-max amp-meanFromVZERO(if), 1-irow, 2-icol, 3-timeR, 
-  // 4-max amp , 5-meanFromVZERO (Nov 25, 2007)
-  // fAmpJetMax(6,1)
-  MakeSlidingPatch((*fAmpJetMatrix), fNJetPatchPhi, fAmpJetMax); // no timing information here
-
-  //Print();
-  // fDigitsList = 0;
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::GetTriggerInfo(TArrayF &triggerPosition, TArrayF &triggerAmplitudes) const
-{
-  // Template - should be defined; Nov 5, 2007
-  triggerPosition[0]   = 0.; 
-  triggerAmplitudes[0] = 0.;
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::FillJetMatrixFromSMs(TClonesArray *ampmatrixsmod, TMatrixD* jetMat, AliEMCALGeometry *g)
-{
-  // Nov 5, 2007
-  // Fill matrix for jet trigger from SM matrixes of modules
-  //
-  static int keyPrint = 0;
-
-  if(ampmatrixsmod==0 || jetMat==0 || g==0) return;
-  Double_t amp = 0.0, ampSum=0.0;
-
-  Int_t nEtaModSum = g->GetNZ()   / g->GetNEtaSubOfTRU(); // should be 4 
-  Int_t nPhiModSum = g->GetNPhi() / g->GetNTRUPhi();      // should be 4 
-
-  if(keyPrint) AliDebug(2,Form("%s",Form(" AliEMCALTrigger::FillJetMatrixFromSMs | nEtaModSum %i : nPhiModSum %i \n", nEtaModSum, nPhiModSum)));
-  Int_t jrow=0, jcol=0;  // indexes of jet matrix
-  Int_t nEtaSM=0, nPhiSM=0;
-  for(Int_t iSM=0; iSM<ampmatrixsmod->GetEntries(); iSM++) {
-    TMatrixD * ampsmods   = dynamic_cast<TMatrixD *>(ampmatrixsmod->At(iSM));
-    
-    if(!ampsmods) return;
-    
-    Int_t nrow = ampsmods->GetNrows();
-    Int_t ncol = ampsmods->GetNcols();
-    //printf("%s",Form(" ######## SM %i : nrow %i : ncol %i ##### \n", iSM, nrow, ncol));
-    for(Int_t row=0; row<nrow; row++) {
-      for(Int_t col=0; col<ncol; col++) {
-        amp  = (*ampsmods)(row,col);
-        nPhiSM = iSM / 2; 
-        nEtaSM = iSM % 2;
-        if       (amp>0.0) {
-           if(keyPrint) AliDebug(2,Form("%s",Form(" ** nPhiSm %i : nEtaSM %i : row %2.2i : col %2.2i -> ", nPhiSM, nEtaSM, row, col))); 
-          if(nEtaSM == 0) { // positive Z
-            jrow = 3*nPhiSM + row/nPhiModSum;
-            jcol = 6 + col / nEtaModSum;
-         } else {         // negative Z
-            if(iSM<=9) jrow = 3*nPhiSM + 2 - row/nPhiModSum;
-            else       jrow = 3*nPhiSM + 1 - row/nPhiModSum; // half size 
-            jcol = 5 - col / nEtaModSum;
-         }
-         if(keyPrint) AliDebug(2,Form("%s",Form(" jrow %2.2i : jcol %2.2i : amp %f (jetMat) \n", jrow, jcol, amp))); 
-
-          (*jetMat)(jrow,jcol) += amp;
-          ampSum += amp; // For controling
-        } else if(amp<0.0) {
-          AliDebug(1,Form(" jrow %2.2i : jcol %2.2i : amp %f (jetMat: amp<0) \n", jrow, jcol, amp)); 
-         assert(0);
-        }
-      }
-    }
-  } // cycle on SM
-  if(ampSum <= 0.0) AliDebug(1,Form("ampSum %f (<=0.0) ", ampSum));
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::MakeSlidingPatch(const TMatrixD &jm, const Int_t nPatchSize, TMatrixD &ampJetMax)
-{
-  // Sliding patch : nPatchSize x nPatchSize (OVERLAP)
-  static int keyPrint = 0;
-  if(keyPrint) AliDebug(2,Form(" AliEMCALTrigger::MakeSlidingPatch() was started \n"));
-  Double_t ampCur = 0.0, e=0.0;
-  ampJetMax(0,0)  = 0.0;
-  ampJetMax(3,0)  = 0.0; // unused now
-  ampJetMax(4,0)  = ampJetMax(5,0)  = 0.0;
-  for(Int_t row=0; row<fAmpJetMatrix->GetNrows(); row ++) {
-    for(Int_t col=0; col<fAmpJetMatrix->GetNcols(); col++) {
-      ampCur = 0.;
-      // check on patch size
-      if( (row+nPatchSize-1) <  fAmpJetMatrix->GetNrows() && (col+nPatchSize-1) < fAmpJetMatrix->GetNcols()){
-        for(Int_t i = 0 ; i < nPatchSize ; i++) {
-         for(Int_t j = 0 ; j < nPatchSize ; j++) {
-            ampCur += jm(row+i, col+j);
-          }
-        } // end cycle on patch
-        if(ampCur > ampJetMax(0,0)){
-         ampJetMax(0,0) = ampCur; 
-         ampJetMax(1,0) = row;
-         ampJetMax(2,0) = col;
-        }
-      } // check on patch size
-    }
-  }
-  if(keyPrint) AliDebug(2,Form(" ampJetMax %i row %2i->%2i col %2i->%2i \n", Int_t(ampJetMax(0,0)), Int_t(ampJetMax(1,0)), Int_t(ampJetMax(1,0))+nPatchSize-1, Int_t(ampJetMax(2,0)), Int_t(ampJetMax(2,0))+nPatchSize-1));
-
-  Double_t eCorrJetMatrix=0.0;
-  if(fVZER0Mult > 0.0) {
-  // Correct patch energy (adc) and jet patch matrix energy
-    Double_t meanAmpBG = GetMeanEmcalPatchEnergy(Int_t(fVZER0Mult), nPatchSize)/0.0153;
-    ampJetMax(4,0) = ampJetMax(0,0);
-    ampJetMax(5,0) = meanAmpBG;
-
-    Double_t eCorr     = ampJetMax(0,0) - meanAmpBG; 
-    AliDebug(2,Form(" ampJetMax(0,0) %f meanAmpBG %f  eCorr %f : ampJetMax(4,0) %f \n",
-          ampJetMax(0,0), meanAmpBG, eCorr, ampJetMax(5,0)));
-    ampJetMax(0,0)     = eCorr;
-    // --
-    eCorrJetMatrix = GetMeanEmcalEnergy(Int_t(fVZER0Mult)) / 208.;
-  }
-  // Fill patch energy matrix
-  for(int row=Int_t(ampJetMax(1,0)); row<Int_t(ampJetMax(1,0))+nPatchSize; row++) {
-    for(int col=Int_t(ampJetMax(2,0)); col<Int_t(ampJetMax(2,0))+nPatchSize; col++) {
-      e = Double_t(jm(row,col)*0.0153);  // 0.0153 - hard coded now
-      if(eCorrJetMatrix > 0.0) { // BG subtraction case
-        e -= eCorrJetMatrix;
-        fJetMatrixE->SetBinContent(row+1, col+1, e);
-      } else if(e > 0.0) {
-        fJetMatrixE->SetBinContent(row+1, col+1, e);
-      }
-    }
-  }
-  // PrintJetMatrix();
-  // Set the jet trigger(s), multiple threshold now, Nov 19,2007
-  for(Int_t i=0; i<fNJetThreshold; i++ ) {
-    if(ampJetMax(0,0) >= fL1JetThreshold[i]) {
-      SetInput(GetNameOfJetTrigger(i)); 
-    }
-  }
-}
-
-//____________________________________________________________________________
-Double_t AliEMCALTrigger::GetEmcalSumAmp() const 
-{ 
-  // Return sum of amplidutes from EMCal
-  // Used calibration coefficeint for transition to energy
-  return fAmpJetMatrix ?fAmpJetMatrix->Sum() :0.0;
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::PrintJetMatrix() const
-{
-  //  fAmpJetMatrix : (17,12); // 17-phi(row), 12-eta(col)
-  if(fAmpJetMatrix == 0) return;
-
-  AliInfo(Form("\n ####  jetMatrix : (%i,%i) ##### \n ", 
-              fAmpJetMatrix->GetNrows(), fAmpJetMatrix->GetNcols()));
-  PrintMatrix(*fAmpJetMatrix);
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::PrintAmpTruMatrix(Int_t ind) const
-{
- // Print matrix with TRU patches
-  TMatrixD * tru = dynamic_cast<TMatrixD *>(fAmpTrus->At(ind));
-  if(tru == 0) return;
-  AliInfo(Form("\n ####  Amp TRU matrix(%i) : (%i,%i) ##### \n ", 
-        ind, tru->GetNrows(), tru->GetNcols()));
-  PrintMatrix(*tru);
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::PrintAmpSmMatrix(Int_t ind) const
-{
-       // Print matrix with SM amplitudes
-       TMatrixD * sm = dynamic_cast<TMatrixD *>(fAmpSMods->At(ind));
-  if(sm == 0) return;
-  AliInfo(Form("\n ####  Amp SM matrix(%i) : (%i,%i) ##### \n ", 
-        ind, sm->GetNrows(), sm->GetNcols()));
-  PrintMatrix(*sm);
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::PrintMatrix(const TMatrixD &mat) const
-{
-  //Print matrix object
-  for(Int_t col=0; col<mat.GetNcols(); col++) AliInfo(Form(" %3i ", col));
-  AliInfo(Form("\n -- \n"));
-  for(Int_t row=0; row<mat.GetNrows(); row++) {
-    AliInfo(Form(" row:%2i ", row));
-    for(Int_t col=0; col<mat.GetNcols(); col++) {
-      AliInfo(Form(" %4i", (Int_t)mat(row,col)));
-    }
-    AliInfo("\n");
-  }
-}
-
-//____________________________________________________________________________
-Bool_t AliEMCALTrigger::CheckConsistentOfMatrixes(const Int_t pri)
-{
-  // Check consitency of matrices
-  Double_t sumSM = 0.0, smCur=0.0;
-  Double_t sumTru=0.0,  sumTruInSM = 0.0, truSum=0.0;
-  //  Bool_t key = kTRUE;
-  for(Int_t i=0; i<fAmpSMods->GetEntries(); i++) {
-    TMatrixD * sm = dynamic_cast<TMatrixD *>(fAmpSMods->At(i));
-    if(sm) {
-      smCur  = sm->Sum();
-      sumSM += smCur;
-
-      sumTruInSM = 0.0;
-      for(Int_t itru=0; itru<3; itru++) { // Cycle on tru inside SM
-        Int_t ind = 3*i + itru;
-        TMatrixD *tru = dynamic_cast<TMatrixD *>(fAmpTrus->At(ind)); 
-        if(tru) {
-          truSum = tru->Sum();
-         sumTruInSM += truSum;
-        }
-      }
-      sumTru += sumTruInSM;
-
-      if(sumTruInSM != smCur) {
-        AliDebug(1,Form(" sm %i : smCur %f -> sumTruInSM %f \n", i, smCur, sumTruInSM));
-        return kFALSE;
-      }
-    }
-  }
-  Double_t sumJetMat = fAmpJetMatrix->Sum();
-       if(pri || TMath::Abs(sumSM-sumTru)>0.0001 || TMath::Abs(sumSM-sumJetMat) > 0.0001) 
-   AliDebug(1,Form(" sumSM %f : sumTru %f : sumJetMat %f \n", sumSM, sumTru, sumJetMat)); 
-       if(TMath::Abs(sumSM - sumTru)>0.0001 || TMath::Abs(sumSM-sumJetMat) > 0.0001) return kFALSE; 
-  else                                       return kTRUE; 
-}
-
-//____________________________________________________________________________
-void AliEMCALTrigger::Browse(TBrowser* b)
-{
-  //Browse.
-  if(&fInputs)      b->Add(&fInputs);
-  if(fAmpTrus)      b->Add(fAmpTrus);
-  if(fTimeRtrus)    b->Add(fTimeRtrus);
-  if(fAmpSMods)     b->Add(fAmpSMods);
-  if(fAmpJetMatrix) b->Add(fAmpJetMatrix);
-  if(fJetMatrixE)   b->Add(fJetMatrixE);
-  //  if(c) b->Add(c);
-}
diff --git a/EMCAL/EMCALbase/AliEMCALTrigger.h b/EMCAL/EMCALbase/AliEMCALTrigger.h
deleted file mode 100644 (file)
index 5bd7a37..0000000
+++ /dev/null
@@ -1,245 +0,0 @@
-#ifndef ALIEMCALTRIGGER_H
-#define ALIEMCALTRIGGER_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id$ */
-
-//___________________________________________________________
-//  Class for trigger analysis.
-//
-//  -- Author: Gustavo Conesa & Yves Schutz (IFIC, SUBATECH, CERN)
-//  Digits are grouped in TRU's (Trigger Units). A TRU consist of 384 cells 
-//  ordered fNTRUPhi x fNTRUEta matrix. 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.  It is found is maximum is isolated. 
-//  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. 
-//  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 
-//  been taken. If different, then this must to be changed. 
-//  Usage:
-//
-//  //Inside the event loop
-//  AliEMCALTrigger *tr = new AliEMCALTrigger();//Init Trigger
-//  tr->SetL0Threshold(100);
-//  tr->SetL1GammaLowPtThreshold(1000);
-//  tr->SetL1GammaMediumPtThreshold(10000);
-//  tr->SetL1GammaHighPtThreshold(20000);
-//  ....
-//  tr->Trigger();  //Execute Trigger
-//  tr->Print("");  //Print data members after calculation.
-//
-//*-- Author: Gustavo Conesa & Yves Schutz (IFIC, SUBATECH, CERN)
-//* -- Author: Aleksei Pavlinov, WSU, Detroit, USA
-// Nov 2, 2007
-// One TRU card receives 96 analogue sums from 12 FEE cards.
-// One sum is correcponding output from on module.      
-// This patch has size 12x8 modules (24x16 modules).
-// Each SM has 3 TRU cards.
-
-// --- ROOT system ---
-
-class TClonesArray ;
-class TTree;
-
-#include <TMatrixD.h>
-#include <TArrayF.h>
-
-// --- AliRoot header files ---
-#include "AliTriggerDetector.h"
-
-class TBrowser;
-class AliEMCALGeometry ;
-class TH2F;
-
-class AliEMCALTrigger : public AliTriggerDetector {
-  
- public:   
-
-  AliEMCALTrigger() ; //  ctor
-  virtual ~AliEMCALTrigger(); //virtual dtor
-
-
-  virtual void    CreateInputs(); //Define trigger inputs for Central Trigger Processor
-  void            Print(const Option_t * opt ="") const ;  
-  virtual void    Trigger();  //Make EMCAL trigger
-
-  //Getters
-  Float_t  Get2x2MaxAmplitude()  const { return f2x2MaxAmp ; }
-  Float_t  GetnxnMaxAmplitude()  const { return fnxnMaxAmp ; }
-  Int_t    Get2x2ModulePhi()     const { return f2x2ModulePhi ; }
-  Int_t    GetnxnModulePhi()     const { return fnxnModulePhi ; }
-  Int_t    Get2x2ModuleEta()     const { return f2x2ModuleEta ; }
-  Int_t    GetnxnModuleEta()     const { return fnxnModuleEta ; }
-  Int_t    Get2x2SuperModule()   const { return f2x2SM ; }
-  Int_t    GetnxnSuperModule()   const { return fnxnSM ; }
-
-  Int_t *  GetADCValuesLowGainMax2x2Sum()  const { return fADCValuesLow2x2; }
-  Int_t *  GetADCValuesHighGainMax2x2Sum() const { return fADCValuesHigh2x2; }
-  Int_t *  GetADCValuesLowGainMaxnxnSum()  const { return fADCValuesLownxn; }
-  Int_t *  GetADCValuesHighGainMaxnxnSum() const { return fADCValuesHighnxn; }
-
-  Float_t  GetL0Threshold()              const { return fL0Threshold ; } 
-  Float_t  GetL1GammaLowPtThreshold()    const { return fL1GammaLowPtThreshold ; }
-  Float_t  GetL1GammaMediumPtThreshold() const { return fL1GammaMediumPtThreshold ; }
-  Float_t  GetL1GammaHighPtThreshold()   const { return fL1GammaHighPtThreshold ; }
-
-  Int_t    GetPatchSize()              const { return fPatchSize ; }
-  Int_t    GetIsolPatchSize()          const { return fIsolPatchSize ; }
-
-  Float_t  Get2x2AmpOutOfPatch()       const { return  f2x2AmpOutOfPatch ; }
-  Float_t  GetnxnAmpOutOfPatch()       const { return  fnxnAmpOutOfPatch ; }
-  Float_t  Get2x2AmpOutOfPatchThres()  const { return  f2x2AmpOutOfPatchThres ; }
-  Float_t  GetnxnAmpOutOfPatchThres()  const { return  fnxnAmpOutOfPatchThres ; } 
-
-  Bool_t   Is2x2Isol()                 const { return  fIs2x2Isol ; }
-  Bool_t   IsnxnIsol()                 const { return  fIsnxnIsol ; }
-
-  Bool_t    IsSimulation()              const { return fSimulation ; }
-  Bool_t    IsIsolatedInSuperModule()   const { return fIsolateInSuperModule ; }
-  Bool_t    GetTimeKey()                const { return fTimeKey;}
-  TH2F*     GetJetMatrixE()             const { return fJetMatrixE;}
-  Double_t  GetEmcalSumAmp()            const;
-  
-  Int_t     GetNJetThreshold()   const {return fNJetThreshold;}
-  Double_t* GetL1JetThresholds() const {return fL1JetThreshold;}
-  TMatrixD  GetAmpJetMax()       const {return fAmpJetMax;}
-
-  void PrintJetMatrix() const;                  // *MENU*
-  void PrintAmpTruMatrix(Int_t ind) const;      // *MENU*
-  void PrintAmpSmMatrix(Int_t ind) const;       // *MENU*
-  void PrintMatrix(const TMatrixD &mat) const;  // *MENU*
-  Bool_t CheckConsistentOfMatrixes(const Int_t pri=0); // *MENU*
-
-
-  //Setters
-  void     SetDigitsList(TClonesArray * digits)          
-   {fDigitsList  = digits ; }
-
-  void     SetL0Threshold(Int_t amp)     
-    {fL0Threshold            = amp; }
-  void     SetL1GammaLowPtThreshold(Int_t amp) 
-    {fL1GammaLowPtThreshold    = amp; } 
-  void     SetL1GammaMediumPtThreshold(Int_t amp) 
-    {fL1GammaMediumPtThreshold = amp; } 
-  void     SetL1GammaHighPtThreshold(Int_t amp)
-    {fL1GammaHighPtThreshold   = amp; }
-
-  void SetPatchSize(Int_t ps)                {fPatchSize = ps ; }
-  void SetIsolPatchSize(Int_t ps)          {fIsolPatchSize = ps ; }
-  void Set2x2AmpOutOfPatchThres(Float_t th) { f2x2AmpOutOfPatchThres = th; }
-  void SetnxnAmpOutOfPatchThres(Float_t th) { fnxnAmpOutOfPatchThres = th; }
-  void SetSimulation(Bool_t sim )          {fSimulation = sim ; }
-  void SetIsolateInSuperModule(Bool_t isol )          {fIsolateInSuperModule = isol ; }
-  void SetTimeKey(Bool_t timeKey) {fTimeKey = timeKey;}
-  void SetJetPatchSize(const Int_t patchSize) {fNJetPatchPhi = fNJetPatchEta = patchSize;}
-  void SetJetParameters(const Int_t patchSize, Double_t* jetThreshold)
-  { // unused now
-    fNJetPatchPhi = fNJetPatchEta = patchSize; 
-    fL1JetThreshold = jetThreshold;
-  }
-  void SetVZER0Multiplicity(Double_t mult) {fVZER0Mult = mult;}
-
-  //
-  virtual void Browse(TBrowser* b);
-  virtual Bool_t  IsFolder() const {return kTRUE;}
-
-  // Name of Jet trigger(s)
-  Char_t* GetNameOfJetTrigger(const Int_t i) {return Form("%s_Th_%2.2i",fgNameOfJetTriggers.Data(),i);}
-  static TString GetNameOfJetTriggers() {return fgNameOfJetTriggers;}
-  static TString fgNameOfJetTriggers; //Name of jet triggers
-  // Estimation on EMCal energy from VZERO multiplicity
-  // 0.0153 is coefficient from adc to energy
-  // Dec 4, 2007
-  // 1  p0           2.52248e-02   3.24364e-05   9.29319e-01  -2.34036e-06
-  static Double_t GetMeanEmcalEnergy(const Int_t mult) {return 2.52248e-02*Double_t(mult);}
-  static Double_t GetMeanEmcalPatchEnergy(const Int_t mult, Int_t patchSize) 
-  {return GetMeanEmcalEnergy(mult)*Double_t(patchSize)*Double_t(patchSize)/208.;}
- private:
-
-  void FillTRU(const TClonesArray * digits, TClonesArray * ampmatrix, TClonesArray * ampmatrixsmod, TClonesArray * timeRmatrix); 
-
-  Bool_t IsPatchIsolated(Int_t iPatchType, const TClonesArray * ampmods, const Int_t imod, const Int_t mtru, const Float_t maxamp, const Int_t maxphi, const Int_t maxeta) ;
-  
-  void MakeSlidingTowers(const TClonesArray * amptrus, const TClonesArray * timeRtrus,
-  const Int_t supermod, TMatrixD &ampmax2, TMatrixD &ampmaxn) ; 
-  
-  void SetTriggers(const TClonesArray * amptrus,const Int_t iSM, const TMatrixD &ampmax2, const TMatrixD &ampmaxn) ;
-  void GetTriggerInfo(TArrayF &triggerPosition, TArrayF &triggerAmplitudes) const; 
-  // Jet staff
-  void FillJetMatrixFromSMs(TClonesArray *ampmatrixsmod, TMatrixD * const jetMat, AliEMCALGeometry * const g); 
-  // no timing information here
-  void MakeSlidingPatch(const TMatrixD &jm, const Int_t nPatchSize, TMatrixD &ampJetMax);
-
- private: 
-  AliEMCALGeometry *fGeom;    //!
-
-  Float_t f2x2MaxAmp ;         //! Maximum 2x2 added amplitude (not overlapped) 
-  Int_t   f2x2ModulePhi ;      //! upper right cell, row(phi)   
-  Int_t   f2x2ModuleEta ;      //! and column(eta)  
-  Int_t   f2x2SM ;             //! Super Module where maximum is found
-  Float_t fnxnMaxAmp ;         //! Maximum nxn added amplitude (overlapped)
-  Int_t   fnxnModulePhi ;      //! upper right cell, row(phi)   
-  Int_t   fnxnModuleEta ;      //! and column(eta)
-  Int_t   fnxnSM ;             //! Super Module where maximum is found
-
-  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 " "
-
-  TClonesArray* fDigitsList;   //! Array of digits 
-
-  Float_t fL0Threshold ;              // L0 trigger energy threshold
-  Float_t fL1GammaLowPtThreshold ;    // L1 gamma Low pT trigger energy threshold
-  Float_t fL1GammaMediumPtThreshold ; // L1 gamma Medium pT trigger energy threshold
-  Float_t fL1GammaHighPtThreshold ;   // L1 gamma High pT trigger energy threshold
-
-  Int_t fPatchSize;          // Trigger patch factor, to be multiplied to 2x2 cells
-                             //  0 means 2x2, 1 means 4x4 (max size 4x4 now)
-  Int_t fIsolPatchSize ;     //  Isolation patch size, number of rows or columns to add to 
-                             //  the 2x2 or nxn maximum amplitude patch. 
-                             //  1 means a patch around max amplitude of 2x2 of 4x4 and around         
-                             //  max ampl patch of 4x4 of 8x8 
-    
-  Float_t f2x2AmpOutOfPatch;      //  Amplitude in isolation cone minus maximum amplitude of the reference 2x2 patch
-  Float_t fnxnAmpOutOfPatch;      //  Amplitude in isolation cone minus maximum amplitude of the reference nxn patch
-  Float_t f2x2AmpOutOfPatchThres; //  Threshold to select a trigger as isolated on f2x2AmpOutOfPatch value
-  Float_t fnxnAmpOutOfPatchThres; //  Threshold to select a trigger as isolated on fnxnAmpOutOfPatch value
-  Float_t fIs2x2Isol;             //  2x2 Patch is isolated if f2x2AmpOutOfPatchThres threshold is passed
-  Float_t fIsnxnIsol ;            //  nxn Patch is isolated if fnxnAmpOutOfPatchThres threshold is passed
-
-
-  Bool_t  fSimulation ;           // Flag to do the trigger during simulation or reconstruction
-  Bool_t  fIsolateInSuperModule;  // Flag to isolate trigger patch in SuperModule or in TRU acceptance
-  Bool_t  fTimeKey;               // Flag to take into account the digits time information  
-  // 
-  TClonesArray *fAmpTrus;         //! Array of amplides of TRU matrixes
-  TClonesArray *fTimeRtrus;       //! Array of recent times  (unused now)
-  TClonesArray *fAmpSMods;        //! Array of amplides of SM  matrixes
-  // Information for EMCAL ESD
-  TArrayF fTriggerPosition;       // Triggered patch position
-  TArrayF fTriggerAmplitudes;     // Triggered patch amplitude
-  // Jet staf
-  Int_t     fNJetPatchPhi;       // size of jet pathch in phi(row)   direction  (nJetPatchPhi*4 module) 
-  Int_t     fNJetPatchEta;       // size of jet pathch in eta(column) direction (nJetPatchEta*4 module)
-  Int_t     fNJetThreshold;      // number of jet threshold
-  Double_t  *fL1JetThreshold;    //[fNJetThreshold] array of L1 jet energy threshold (this is not Et)
-  Double_t  fJetMaxAmp;          // Max amp from patch (fNJetPatchPhi*fNJetPatchEta)
-  TMatrixD* fAmpJetMatrix;       //-> Jet trigger matrix : (nphi(17), neta(12))
-  TH2F*     fJetMatrixE;         //-> temporary solution for getting coordinate informatin
-  TMatrixD  fAmpJetMax;          // 6 elements
-  // VZER0 
-  Double_t  fVZER0Mult;              // multiplicity (V0A+V0c)
-  
-  const AliEMCALTrigger & operator = (const AliEMCALTrigger & ) ;
-  AliEMCALTrigger(const AliEMCALTrigger & trig) ; // cpy ctor
-  
-  ClassDef(AliEMCALTrigger, 2)
-} ;
-    
-    
-#endif //ALIEMCALTRIGGER_H
-    
index d0a2b13..586068e 100644 (file)
@@ -288,11 +288,7 @@ void AliEMCALTriggerRawDigitMaker::PostProcess()
        Int_t idx;
        
        AliEMCALTriggerRawDigit* dig = 0x0;
-       
-       TVector2 sizeL1gsubr, sizeL1gpatch, sizeL1jsubr, sizeL1jpatch;
-       
-       fDCSConfig->GetTriggerDCSConfig()->GetSTUDCSConfig()->GetSegmentation(sizeL1gsubr, sizeL1gpatch, sizeL1jsubr, sizeL1jpatch);
-       
+
        fRawReader->Reset();
        fRawReader->Select("EMCAL",44); 
 
@@ -370,6 +366,9 @@ void AliEMCALTriggerRawDigitMaker::PostProcess()
                
                Int_t iTRU, x, y;
 
+               TVector2 sizeL1gsubr, sizeL1gpatch, sizeL1jsubr, sizeL1jpatch;
+               fDCSConfig->GetTriggerDCSConfig()->GetSTUDCSConfig()->GetSegmentation(sizeL1gsubr, sizeL1gpatch, sizeL1jsubr, sizeL1jpatch);
+
                if (fSTURawStream->GetRawData())
                {
                        if (AliDebugLevel()) printf("| STU => TRU raw data are there!\n");
index 870182d..863eb09 100644 (file)
@@ -60,7 +60,6 @@ set(SRCS
     AliEMCALSimParam.cxx
     AliEMCALSpaceFrame.cxx
     AliEMCALSurvey.cxx
-    AliEMCALTrigger.cxx
     AliEMCALTriggerData.cxx
     AliEMCALTriggerDCSConfig.cxx
     AliEMCALTriggerDCSConfigDB.cxx
old mode 100644 (file)
new mode 100755 (executable)
index 11d0a02..639696b
@@ -36,7 +36,6 @@
 #pragma link C++ class AliEMCALCalibMapAPDVal+;
 #pragma link C++ class AliEMCALSuperModuleCalibMapAPD+;
 #pragma link C++ class AliEMCALRawDigit+;
-#pragma link C++ class AliEMCALTrigger+;
 #pragma link C++ class AliEMCALTriggerSTURawStream+;
 #pragma link C++ class AliEMCALRawUtils+;
 #pragma link C++ class AliEMCAL+;