Creation of TClonesArray in constructor only, instead of per-event.
authorkharlov <kharlov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 16 May 2008 20:07:13 +0000 (20:07 +0000)
committerkharlov <kharlov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 16 May 2008 20:07:13 +0000 (20:07 +0000)
Cleanup of memory leaks.

PHOS/AliPHOSClusterizer.cxx
PHOS/AliPHOSClusterizerv1.cxx
PHOS/AliPHOSPID.cxx
PHOS/AliPHOSReconstructor.cxx
PHOS/AliPHOSReconstructor.h
PHOS/AliPHOSTrigger.cxx
PHOS/AliPHOSTrigger.h

index 4e3bf42..f88550f 100644 (file)
@@ -103,11 +103,6 @@ void AliPHOSClusterizer::SetOutput(TTree * clustersTree)
   // and set the corresponding branch addresses
   fTreeR = clustersTree;
 
-//   fEMCRecPoints->Clear();
-//   fCPVRecPoints->Clear();
-  fEMCRecPoints->Delete();
-  fCPVRecPoints->Delete();
-
   AliDebug(9, "Making array for EMC clusters");
   Int_t split = 0;
   Int_t bufsize = 32000;
index 71b0a19..6fb8aa3 100644 (file)
@@ -264,6 +264,8 @@ void AliPHOSClusterizerv1::Digits2Clusters(Option_t *option)
     AliInfo(Form("took %f seconds for Clusterizing\n",
                 gBenchmark->GetCpuTime("PHOSClusterizer"))); 
   }
+  fEMCRecPoints->Delete();
+  fCPVRecPoints->Delete();
 }
 
 //____________________________________________________________________________
index aade740..c6eaaaf 100644 (file)
@@ -97,6 +97,10 @@ AliPHOSPID::~AliPHOSPID()
     fCPVRecPoints->Delete();
     delete fCPVRecPoints;
   }
+  if (fRecParticles) {
+    fRecParticles->Delete();
+    delete fRecParticles;
+  }
 }
 
 //____________________________________________________________________________
index 0081287..8cd835e 100644 (file)
@@ -57,6 +57,8 @@ ClassImp(AliPHOSReconstructor)
 Bool_t AliPHOSReconstructor::fgDebug = kFALSE ; 
 AliPHOSRecoParam* AliPHOSReconstructor::fgkRecoParamEmc =0;  // EMC rec. parameters
 AliPHOSRecoParam* AliPHOSReconstructor::fgkRecoParamCpv =0;  // CPV rec. parameters
+TClonesArray*     AliPHOSReconstructor::fgDigitsArray = 0;   // Array of PHOS digits
+TObjArray*        AliPHOSReconstructor::fgEMCRecPoints = 0;   // Array of EMC rec.points
 
 //____________________________________________________________________________
 AliPHOSReconstructor::AliPHOSReconstructor() :
@@ -78,6 +80,8 @@ AliPHOSReconstructor::AliPHOSReconstructor() :
   fClusterizer = new AliPHOSClusterizerv1      (fGeom);
   fTSM         = new AliPHOSTrackSegmentMakerv1(fGeom);
   fPID         = new AliPHOSPIDv1              (fGeom);
+  fgDigitsArray = new TClonesArray("AliPHOSDigit",100);
+  fgEMCRecPoints= new TObjArray(100) ;
 }
 
 //____________________________________________________________________________
@@ -88,6 +92,8 @@ AliPHOSReconstructor::AliPHOSReconstructor() :
   delete fClusterizer;
   delete fTSM;
   delete fPID;
+  delete fgDigitsArray;
+  delete fgEMCRecPoints;
 } 
 
 //____________________________________________________________________________
@@ -130,11 +136,6 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
   else 
     fPID->TrackSegments2RecParticles("") ;
 
-
-  // This function creates AliESDtracks from AliPHOSRecParticles
-  //         and
-  // writes them to the ESD
-
   TClonesArray *recParticles  = fPID->GetRecParticles();
   Int_t nOfRecParticles = recParticles->GetEntriesFast();
   
@@ -150,8 +151,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
     AliError("can't get the branch with the PHOS digits !");
     return;
   }
-  TClonesArray *digitsArray    = new TClonesArray("AliPHOSDigit",100);
-  branch->SetAddress(&digitsArray);
+  branch->SetAddress(&fgDigitsArray);
   branch->GetEntry(0);
 
   // Get the clusters array
@@ -162,8 +162,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
     return;
   }
 
-  TObjArray *emcRecPoints = new TObjArray(100) ;
-  emcbranch->SetAddress(&emcRecPoints);
+  emcbranch->SetAddress(&fgEMCRecPoints);
   emcbranch->GetEntry(0);
 
   //#########Calculate trigger and set trigger info###########
@@ -171,7 +170,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
   AliPHOSTrigger tr ;
   //   tr.SetPatchSize(1);//create 4x4 patches
   tr.SetSimulation(kFALSE);
-  tr.Trigger(digitsArray);
+  tr.Trigger(fgDigitsArray);
   
   Float_t maxAmp2x2  = tr.Get2x2MaxAmplitude();
   Float_t maxAmpnxn  = tr.GetnxnMaxAmplitude();
@@ -225,7 +224,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
   //############# Fill CaloCells ###########
   //########################################
 
-  Int_t nDigits = digitsArray->GetEntries();
+  Int_t nDigits = fgDigitsArray->GetEntries();
   Int_t idignew = 0 ;
   AliDebug(1,Form("%d digits",nDigits));
 
@@ -236,7 +235,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
 
   // Add to CaloCells only EMC digits with non-zero energy 
   for (Int_t idig = 0 ; idig < nDigits ; idig++) {
-    const AliPHOSDigit * dig = (const AliPHOSDigit*)digitsArray->At(idig);
+    const AliPHOSDigit * dig = (const AliPHOSDigit*)fgDigitsArray->At(idig);
     if(dig->GetId() <= knEMC && dig->GetEnergy() > 0 ){
       //printf("i %d; id %d; amp %f; time %e\n",
       //idignew,dig->GetId(),dig->GetEnergy(), dig->GetTime());
@@ -259,7 +258,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
     AliPHOSTrackSegment *ts    = static_cast<AliPHOSTrackSegment *>(fTSM->GetTrackSegments()
                                                                    ->At(rp->GetPHOSTSIndex()));
 
-    AliPHOSEmcRecPoint  *emcRP = static_cast<AliPHOSEmcRecPoint *>(emcRecPoints->At(ts->GetEmcIndex()));
+    AliPHOSEmcRecPoint  *emcRP = static_cast<AliPHOSEmcRecPoint *>(fgEMCRecPoints->At(ts->GetEmcIndex()));
     AliESDCaloCluster   *ec    = new AliESDCaloCluster() ; 
     
     Float_t xyz[3];
@@ -277,7 +276,7 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
     Double_t *fracList   = new Double_t[cellMult];
 
     for (Int_t iCell=0; iCell<cellMult; iCell++) {
-      AliPHOSDigit *digit = static_cast<AliPHOSDigit *>(digitsArray->At(digitsList[iCell]));
+      AliPHOSDigit *digit = static_cast<AliPHOSDigit *>(fgDigitsArray->At(digitsList[iCell]));
       absIdList[iCell] = (UShort_t)(digit->GetId());
       if (digit->GetEnergy() > 0)
        fracList[iCell] = rpElist[iCell]/digit->GetEnergy();
@@ -326,11 +325,9 @@ void AliPHOSReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
     delete [] fracList;
     delete [] absIdList;
   }
-  digitsArray ->Delete();
-  delete digitsArray;
-  emcRecPoints->Delete();
-  delete emcRecPoints;
-  recParticles->Delete();
+  fgDigitsArray ->Delete();
+  fgEMCRecPoints->Delete();
+  recParticles  ->Delete();
 }
 
 //____________________________________________________________________________
index ad32c43..14b1c7a 100644 (file)
@@ -125,8 +125,10 @@ private:
   AliPHOSClusterizerv1     *fClusterizer;    //! PHOS clusterizer
   AliPHOSTrackSegmentMaker *fTSM;            //! PHOS TrackSegmentMaker
   AliPHOSPID               *fPID;            //! PHOS PID maker
+  static TClonesArray      *fgDigitsArray;   //! Array of PHOS digits
+  static TObjArray         *fgEMCRecPoints;  //! Array of EMC rec.points
 
-  ClassDef(AliPHOSReconstructor,6)  // PHOS Reconstruction class
+  ClassDef(AliPHOSReconstructor,7)  // PHOS Reconstruction class
 
 }; 
 
index ba2bbc4..9cde799 100644 (file)
@@ -62,6 +62,7 @@ AliPHOSTrigger::AliPHOSTrigger()
     fnxnMaxAmp(-1), fnxnCrystalPhi(-1),  fnxnCrystalEta(-1), fnxnSM(0),
     fADCValuesHighnxn(0), fADCValuesLownxn(0),
     fADCValuesHigh2x2(0), fADCValuesLow2x2(0), fDigitsList(0),
+    fAmptrus(0), fAmpmods(0), fTimeRtrus(0),
     fL0Threshold(50), fL1JetLowPtThreshold(200),   fL1JetMediumPtThreshold(500),  
     fL1JetHighPtThreshold(1000),
     fNTRU(8), fNTRUZ(2), fNTRUPhi(4), 
@@ -82,7 +83,9 @@ AliPHOSTrigger::AliPHOSTrigger()
   SetName("PHOS");
   CreateInputs();
   
-  //Print("") ; 
+  fAmptrus   = new TClonesArray("TMatrixD",1000);
+  fAmpmods   = new TClonesArray("TMatrixD",1000);
+  fTimeRtrus = new TClonesArray("TMatrixD",1000);
 }
 
 //____________________________________________________________________________
@@ -101,6 +104,7 @@ AliPHOSTrigger::AliPHOSTrigger(const AliPHOSTrigger & trig) :
   fADCValuesHigh2x2(trig.fADCValuesHigh2x2),
   fADCValuesLow2x2(trig.fADCValuesLow2x2),
   fDigitsList(trig.fDigitsList),
+  fAmptrus(trig.fAmptrus), fAmpmods(trig.fAmpmods), fTimeRtrus(trig.fTimeRtrus),
   fL0Threshold(trig.fL0Threshold),
   fL1JetLowPtThreshold(trig.fL1JetLowPtThreshold),
   fL1JetMediumPtThreshold(trig.fL1JetMediumPtThreshold), 
@@ -134,6 +138,9 @@ AliPHOSTrigger::~AliPHOSTrigger()
   if(fADCValuesHigh2x2)delete []  fADCValuesHigh2x2;
   if(fADCValuesLow2x2)delete [] fADCValuesLow2x2;
   // fDigitsList is now ours...
+  if(fAmptrus)   { fAmptrus->Delete()  ; delete fAmptrus  ; }
+  if(fAmpmods)   { fAmpmods->Delete()  ; delete fAmpmods  ; }
+  if(fTimeRtrus) { fTimeRtrus->Delete(); delete fTimeRtrus; }
 }
 
 //_________________________________________________________________________
@@ -160,7 +167,7 @@ void AliPHOSTrigger::CreateInputs()
 }
 
 //____________________________________________________________________________
-void AliPHOSTrigger::FillTRU(const TClonesArray * digits, const AliPHOSGeometry * geom, TClonesArray * ampmatrixtru, TClonesArray * ampmatrixmod, TClonesArray * timeRmatrixtru) const {
+void AliPHOSTrigger::FillTRU(const TClonesArray * digits, const AliPHOSGeometry * geom) const {
 
   //Orders digits ampitudes list and times in fNTRU TRUs (28x16 crystals) 
   //per module. Each TRU is a TMatrixD, and they are kept in TClonesArrays. 
@@ -189,8 +196,8 @@ void AliPHOSTrigger::FillTRU(const TClonesArray * digits, const AliPHOSGeometry
        timeRtrus(i,j) = 0.0;
       }
     }
-    new((*ampmatrixtru)[k])   TMatrixD(amptrus) ;
-    new((*timeRmatrixtru)[k]) TMatrixD(timeRtrus) ; 
+    new((*fAmptrus)[k])   TMatrixD(amptrus) ;
+    new((*fTimeRtrus)[k]) TMatrixD(timeRtrus) ; 
   }
 
   //List of Modules matrices initialized to 0.
@@ -204,7 +211,7 @@ void AliPHOSTrigger::FillTRU(const TClonesArray * digits, const AliPHOSGeometry
        ampmods(i,j)   = 0.0;
       }
     }
-    new((*ampmatrixmod)[k])   TMatrixD(ampmods) ;
+    new((*fAmpmods)[k])   TMatrixD(ampmods) ;
   }
   
   AliPHOSDigit * dig ;
@@ -239,8 +246,8 @@ void AliPHOSTrigger::FillTRU(const TClonesArray * digits, const AliPHOSGeometry
       Int_t itru  = (row-1) + (col-1)*fNTRUPhi + (relid[0]-1)*fNTRU ;
 
       //Fill TRU matrix with crystal values
-      TMatrixD * amptrus   = dynamic_cast<TMatrixD *>(ampmatrixtru->At(itru)) ;
-      TMatrixD * timeRtrus = dynamic_cast<TMatrixD *>(timeRmatrixtru->At(itru)) ;
+      TMatrixD * amptrus   = dynamic_cast<TMatrixD *>(fAmptrus  ->At(itru)) ;
+      TMatrixD * timeRtrus = dynamic_cast<TMatrixD *>(fTimeRtrus->At(itru)) ;
 
       //Calculate row and column of the crystal inside the TRU with number itru
       Int_t irow = (relid[2]-1) - (row-1) *  fNCrystalsPhi;    
@@ -250,7 +257,7 @@ void AliPHOSTrigger::FillTRU(const TClonesArray * digits, const AliPHOSGeometry
       (*timeRtrus)(irow,icol) = timeR ;
 
       //####################MODULE MATRIX ##################
-      TMatrixD * ampmods   = dynamic_cast<TMatrixD *>(ampmatrixmod->At(relid[0]-1)) ;
+      TMatrixD * ampmods   = dynamic_cast<TMatrixD *>(fAmpmods->At(relid[0]-1)) ;
       (*ampmods)(relid[2]-1,relid[3]-1)   = amp ;
     }
   }
@@ -275,7 +282,7 @@ void AliPHOSTrigger::GetCrystalPhiEtaIndexInModuleFromTRUIndex(const Int_t itru,
 }
 
 //____________________________________________________________________________
-Bool_t AliPHOSTrigger::IsPatchIsolated(Int_t iPatchType, const TClonesArray * ampmatrixes, const Int_t imod, const Int_t mtru, const Float_t maxamp, const Int_t maxphi, const Int_t maxeta) {
+Bool_t AliPHOSTrigger::IsPatchIsolated(Int_t iPatchType, const Int_t imod, const Int_t mtru, const Float_t maxamp, const Int_t maxphi, const Int_t maxeta) {
 
   //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, 
@@ -298,13 +305,13 @@ Bool_t AliPHOSTrigger::IsPatchIsolated(Int_t iPatchType, const TClonesArray * am
   Int_t rowborder = 0;
 
   if(fIsolateInModule){
-    ampmatrix = dynamic_cast<TMatrixD *>(ampmatrixes->At(imod)) ;
+    ampmatrix = dynamic_cast<TMatrixD *>(fAmpmods->At(imod)) ;
     rowborder = fNCrystalsPhi*fNTRUPhi;
     colborder = fNCrystalsZ*fNTRUZ;
     AliDebug(2,"Isolate trigger in Module");
   }
   else{
-    ampmatrix = dynamic_cast<TMatrixD *>(ampmatrixes->At(itru)) ;
+    ampmatrix = dynamic_cast<TMatrixD *>(fAmptrus->At(itru)) ;
     rowborder = fNCrystalsPhi;
     colborder = fNCrystalsZ;
     AliDebug(2,"Isolate trigger in TRU");
@@ -360,7 +367,8 @@ Bool_t AliPHOSTrigger::IsPatchIsolated(Int_t iPatchType, const TClonesArray * am
 
 
 //____________________________________________________________________________
-void AliPHOSTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus, const Int_t imod, TMatrixD &ampmax2, TMatrixD &ampmaxn){
+void AliPHOSTrigger::MakeSlidingCell(const Int_t imod, TMatrixD &ampmax2, TMatrixD &ampmaxn)
+{
   //Sums energy of all possible 2x2 (L0) and nxn (L1) crystals per each TRU. 
   //Fast signal in the experiment is given by 2x2 crystals, 
   //for this reason we loop inside the TRU crystals by 2. 
@@ -384,8 +392,8 @@ void AliPHOSTrigger::MakeSlidingCell(const TClonesArray * amptrus, const TClones
     
   //Loop over all TRUS in a module
   for(Int_t itru = 0 + imod  * fNTRU ; itru < (imod+1)*fNTRU ; itru++){
-    TMatrixD * amptru   = dynamic_cast<TMatrixD *>(amptrus->At(itru)) ;
-    TMatrixD * timeRtru = dynamic_cast<TMatrixD *>(timeRtrus->At(itru)) ;
+    TMatrixD * amptru   = dynamic_cast<TMatrixD *>(fAmptrus  ->At(itru)) ;
+    TMatrixD * timeRtru = dynamic_cast<TMatrixD *>(fTimeRtrus->At(itru)) ;
     Int_t mtru = itru-imod*fNTRU ; //Number of TRU in Module
     
     //Sliding 2x2, add 2x2 amplitudes (NOT OVERLAP)
@@ -515,7 +523,7 @@ void AliPHOSTrigger::Print(const Option_t * opt) const
 }
 
 //____________________________________________________________________________
-void AliPHOSTrigger::SetTriggers(const TClonesArray * ampmatrix, const Int_t iMod, const TMatrixD & ampmax2, const TMatrixD & ampmaxn)  
+void AliPHOSTrigger::SetTriggers(const Int_t iMod, 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. It finds if maximum amplitudes are isolated.
@@ -565,9 +573,9 @@ void AliPHOSTrigger::SetTriggers(const TClonesArray * ampmatrix, const Int_t iMo
     
     //Isolated patch?
     if(fIsolateInModule)
-      fIs2x2Isol =  IsPatchIsolated(0, ampmatrix, iMod, mtru2,  f2x2MaxAmp, f2x2CrystalPhi,f2x2CrystalEta) ;
+      fIs2x2Isol =  IsPatchIsolated(0, iMod, mtru2,  f2x2MaxAmp, f2x2CrystalPhi,f2x2CrystalEta) ;
     else
-      fIs2x2Isol =  IsPatchIsolated(0, ampmatrix, iMod, mtru2,  f2x2MaxAmp,  static_cast<Int_t>(max2[1]), static_cast<Int_t>(max2[2])) ;
+      fIs2x2Isol =  IsPatchIsolated(0, iMod, mtru2,  f2x2MaxAmp,  static_cast<Int_t>(max2[1]), static_cast<Int_t>(max2[2])) ;
 
     //Transform digit amplitude in Raw Samples
     if (fADCValuesLow2x2 == 0) {
@@ -603,9 +611,9 @@ void AliPHOSTrigger::SetTriggers(const TClonesArray * ampmatrix, const Int_t iMo
     
     //Isolated patch?
     if(fIsolateInModule)
-      fIsnxnIsol =  IsPatchIsolated(1, ampmatrix, iMod, mtrun,  fnxnMaxAmp, fnxnCrystalPhi, fnxnCrystalEta) ;
+      fIsnxnIsol =  IsPatchIsolated(1, iMod, mtrun,  fnxnMaxAmp, fnxnCrystalPhi, fnxnCrystalEta) ;
     else
-      fIsnxnIsol =  IsPatchIsolated(1, ampmatrix, iMod, mtrun,  fnxnMaxAmp,  static_cast<Int_t>(maxn[1]), static_cast<Int_t>(maxn[2])) ;
+      fIsnxnIsol =  IsPatchIsolated(1, iMod, mtrun,  fnxnMaxAmp,  static_cast<Int_t>(maxn[1]), static_cast<Int_t>(maxn[2])) ;
 
     //Transform digit amplitude in Raw Samples
     if (fADCValuesHighnxn == 0) {
@@ -682,10 +690,10 @@ void AliPHOSTrigger::DoIt()
     AliFatal("Digits not found !") ;
   
   //Fill TRU Matrix  
-  TClonesArray * amptrus   = new TClonesArray("TMatrixD",1000);
-  TClonesArray * ampmods   = new TClonesArray("TMatrixD",1000);
-  TClonesArray * timeRtrus = new TClonesArray("TMatrixD",1000);
-  FillTRU(fDigitsList,geom,amptrus, ampmods,timeRtrus) ;
+//   TClonesArray * amptrus   = new TClonesArray("TMatrixD",1000);
+//   TClonesArray * ampmods   = new TClonesArray("TMatrixD",1000);
+//   TClonesArray * timeRtrus = new TClonesArray("TMatrixD",1000);
+  FillTRU(fDigitsList,geom) ;
 
   //Do Crystal Sliding and select Trigger
   //Initialize varible that will contain maximum amplitudes and 
@@ -696,20 +704,17 @@ void AliPHOSTrigger::DoIt()
   for(Int_t imod = 0 ; imod < nModules ; imod++) {
 
     //Do 2x2 and nxn sums, select maximums. 
-    MakeSlidingCell(amptrus, timeRtrus, imod, ampmax2, ampmaxn);
+    MakeSlidingCell(imod, ampmax2, ampmaxn);
     //Set the trigger
-    if(fIsolateInModule)
-      SetTriggers(ampmods,imod,ampmax2,ampmaxn) ;
-    else
-      SetTriggers(amptrus,imod,ampmax2,ampmaxn) ;
+    SetTriggers(imod,ampmax2,ampmaxn) ;
   }
 
-  amptrus->Delete();
-  delete amptrus; amptrus=0;
-  ampmods->Delete();
-  delete ampmods; ampmods=0;
-  timeRtrus->Delete();
-  delete timeRtrus; timeRtrus=0;
+  fAmptrus->Delete();
+//   delete amptrus; amptrus=0;
+  fAmpmods->Delete();
+//   delete ampmods; ampmods=0;
+  fTimeRtrus->Delete();
+//   delete timeRtrus; timeRtrus=0;
   //Print();
 
 }
index bacc11f..9e65e1c 100644 (file)
@@ -118,13 +118,13 @@ class AliPHOSTrigger : public AliTriggerDetector {
 
   AliPHOSTrigger & operator = (const AliPHOSTrigger & trig) ;//cpy assignment
 
-  void FillTRU(const TClonesArray * digits, const AliPHOSGeometry * geom, TClonesArray * amptru, TClonesArray * ampmod, TClonesArray * timeRtru) const ;
+  void FillTRU(const TClonesArray * digits, const AliPHOSGeometry * geom) const ;
 
-  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) ;
+  Bool_t IsPatchIsolated(Int_t iPatchType, const Int_t imod, const Int_t mtru, const Float_t maxamp, const Int_t maxphi, const Int_t maxeta) ;
 
-  void MakeSlidingCell(const TClonesArray * amptrus, const TClonesArray * timeRtrus, Int_t mod, TMatrixD &ampmax2, TMatrixD &ampmaxn) ;
+  void MakeSlidingCell(Int_t mod, TMatrixD &ampmax2, TMatrixD &ampmaxn) ;
 
-  void SetTriggers(const TClonesArray * amptrus, Int_t iMod, const TMatrixD &ampmax2,const TMatrixD &ampmaxn) ;
+  void SetTriggers(Int_t iMod, const TMatrixD &ampmax2,const TMatrixD &ampmaxn) ;
 
   void DoIt() ; 
  
@@ -144,7 +144,11 @@ class AliPHOSTrigger : public AliTriggerDetector {
   Int_t*   fADCValuesHigh2x2 ; //! " high gain " 2x2 "
   Int_t*   fADCValuesLow2x2  ; //! " low gaing " "
 
-  TClonesArray* fDigitsList ;  //Array of digits 
+  TClonesArray* fDigitsList ;  //  Array of digits 
+  TClonesArray* fAmptrus    ;  //! Array of matrices with amplitudes per TRU
+  TClonesArray* fAmpmods    ;  //! Array of matrices with amplitudes per module
+  TClonesArray* fTimeRtrus  ;  //! Array of matrices with time
+  
  
   Float_t fL0Threshold ;             //! L0 trigger energy threshold
   Float_t fL1JetLowPtThreshold ;     //! L1 Low  pT trigger threshold
@@ -174,7 +178,7 @@ class AliPHOSTrigger : public AliTriggerDetector {
   Bool_t  fSimulation ;           //! Flag to do the trigger during simulation or reconstruction
   Bool_t  fIsolateInModule;       //! Flag to isolate trigger patch in Module or in TRU acceptance
 
-  ClassDef(AliPHOSTrigger,4)
+  ClassDef(AliPHOSTrigger,5)
 } ;