update from S.Aiolo to do time cuts and calibrations if needed
authorloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Sep 2011 15:05:28 +0000 (15:05 +0000)
committerloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Sep 2011 15:05:28 +0000 (15:05 +0000)
EMCAL/AliEMCALClusterizerFixedWindow.cxx
PWG4/UserTasks/EmcalTasks/AliAnalysisTaskEMCALClusterizeFast.cxx
PWG4/UserTasks/EmcalTasks/AliAnalysisTaskEMCALClusterizeFast.h

index a91a5b4..00d9caf 100644 (file)
@@ -271,7 +271,7 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
   
   Int_t nTotalClus = nClusters * maxiShiftEta * maxiShiftPhi;
   
-  if (!fClustersArray){
+  if (!fClustersArray) {
     fClustersArray = new AliEMCALDigit**[nTotalClus];
     for (Int_t i = 0; i < nTotalClus; i++)
     {
@@ -279,22 +279,44 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
     }
   }
   
-  AliEMCALDigit *digit = 0;
+  // Set up TObjArray with pointers to digits to work on calibrated digits 
+  TObjArray *digitsC = new TObjArray();
+  AliEMCALDigit *digit;
+  Float_t dEnergyCalibrated = 0.0, ehs = 0.0, time = 0.0;
+  TIter nextdigit(fDigitsArr);
+  while ((digit = dynamic_cast<AliEMCALDigit*>(nextdigit()))) { // calibrate and clean up digits
+    dEnergyCalibrated =  digit->GetAmplitude();
+    time              =  digit->GetTime();
+    Calibrate(dEnergyCalibrated, time, digit->GetId());
+    digit->SetCalibAmp(dEnergyCalibrated);
+    digit->SetTime(time);
+    if (dEnergyCalibrated < fMinECut) {
+      continue;
+    }
+    else if (!fGeom->CheckAbsCellId(digit->GetId())) {
+      continue;
+    }
+    else {
+      ehs += dEnergyCalibrated;
+      digitsC->AddLast(digit);
+    }
+  } 
   
+  AliDebug(1,Form("MakeClusters: Number of digits %d  -> (e %f), ehs %f\n",
+                  fDigitsArr->GetEntries(),fMinECut,ehs));
+   
   for (Int_t ishiftPhi = 0; ishiftPhi < maxiShiftPhi; ishiftPhi++){
     Int_t nClusPhi = (nPhiDigits - fShiftPhi * ishiftPhi) / fNphi;
     
-    for (Int_t ishiftEta = 0; ishiftEta < maxiShiftEta; ishiftEta++){
+    for (Int_t ishiftEta = 0; ishiftEta < maxiShiftEta; ishiftEta++) {
       
       Int_t nClusEta = (nEtaDigits - fShiftEta * ishiftEta) / fNeta; 
       
       Int_t iTotalClus = nClusters * (ishiftPhi * maxiShiftEta + ishiftEta);
       
-      TIter nextdigit(fDigitsArr);
-      
-      nextdigit.Reset();
-      
-      while ((digit = static_cast<AliEMCALDigit*>(nextdigit()))){
+      TIter nextdigitC(digitsC);
+      while ((digit = dynamic_cast<AliEMCALDigit*>(nextdigitC()))) { // scan over the list of digitsC
+        
         fGeom->GetCellIndex (digit->GetId(), nSupMod, nModule, nIphi, nIeta);
         fGeom->GetCellPhiEtaIndexInSModule (nSupMod, nModule, nIphi, nIeta, iphi, ieta);
         
@@ -373,17 +395,7 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
       for (Int_t iDigit = 0; iDigit < nDigitsCluster; iDigit++){
         if (fClustersArray[iCluster][iDigit] == NULL) continue;
         digit = fClustersArray[iCluster][iDigit];
-        Float_t dEnergyCalibrated = digit->GetAmplitude();
-        Float_t time              = digit->GetTime();
-        Calibrate(dEnergyCalibrated,time,digit->GetId());
-        if (dEnergyCalibrated < fMinECut) {
-          continue;
-        }
-        if (!fGeom->CheckAbsCellId(digit->GetId())) {
-          continue;
-        }
-        digit->SetCalibAmp(dEnergyCalibrated);
-        recPoint->AddDigit(*digit, dEnergyCalibrated, kFALSE); //Time or TimeR?
+        recPoint->AddDigit(*digit, digit->GetCalibAmp(), kFALSE); //Time or TimeR?
         fClustersArray[iCluster][iDigit] = NULL;
       }
     }
index 5bcf8bd..d25b5bf 100644 (file)
@@ -80,9 +80,7 @@ AliAnalysisTaskEMCALClusterizeFast::AliAnalysisTaskEMCALClusterizeFast()
     fShiftPhi(2),
     fShiftEta(2),
     fTRUShift(0),
-    fClusterizeFastORs(0),
-    fMinFastORtime(0),
-    fMaxFastORtime(20)
+    fClusterizeFastORs(0)
 { 
   // Constructor
 }
@@ -119,9 +117,7 @@ AliAnalysisTaskEMCALClusterizeFast::AliAnalysisTaskEMCALClusterizeFast(const cha
     fShiftPhi(2),
     fShiftEta(2),
     fTRUShift(0),
-    fClusterizeFastORs(0),
-    fMinFastORtime(0),
-    fMaxFastORtime(20)
+    fClusterizeFastORs(0)
 { 
   // Constructor
 
@@ -290,9 +286,6 @@ void AliAnalysisTaskEMCALClusterizeFast::FillDigitsArray()
         triggerTime = trgtimes[0];
       }
       
-      if (triggerTime < fMinFastORtime || triggerTime > fMaxFastORtime)
-        continue;
-      
       Int_t triggerCol = 0, triggerRow = 0;
       triggers->GetPosition(triggerCol, triggerRow);
       
@@ -377,6 +370,8 @@ void AliAnalysisTaskEMCALClusterizeFast::RecPoints2Clusters(TClonesArray *clus)
   AliVCaloCells *cells = InputEvent()->GetEMCALCells();
   AliEMCALGeometry *geom = AliEMCALGeometry::GetInstance(fGeomName);
   
+  AliDebug(1, Form("total no of clusters %d", fClusterArr->GetEntriesFast())); 
+  
   Int_t Ncls = fClusterArr->GetEntriesFast();
   for(Int_t i=0, nout=clus->GetEntries(); i < Ncls; ++i) {
     AliEMCALRecPoint *recpoint = static_cast<AliEMCALRecPoint*>(fClusterArr->At(i));
@@ -404,6 +399,8 @@ void AliAnalysisTaskEMCALClusterizeFast::RecPoints2Clusters(TClonesArray *clus)
     Float_t g[3];
     gpos.GetXYZ(g);
     
+    AliDebug(1, Form("energy %f", recpoint->GetEnergy()));
+    
     AliVCluster *c = static_cast<AliVCluster*>(clus->New(nout++));
     c->SetType(AliVCluster::kEMCALClusterv1);
     c->SetE(recpoint->GetEnergy());
@@ -416,16 +413,17 @@ void AliAnalysisTaskEMCALClusterizeFast::RecPoints2Clusters(TClonesArray *clus)
     c->SetNExMax(recpoint->GetNExMax()); //number of local maxima
     Float_t elipAxis[2];
     recpoint->GetElipsAxis(elipAxis);
-    c->SetM02(elipAxis[0]*elipAxis[0]) ;
-    c->SetM20(elipAxis[1]*elipAxis[1]) ;
-    if (fRecoUtils && fRecoUtils->IsBadChannelsRemovalSwitchedOn()) {
-      fRecoUtils->RecalculateClusterDistanceToBadChannel(geom, cells, c);
-    } else {
-      if (fPedestalData) 
-        recpoint->EvalDistanceToBadChannels(fPedestalData);
+    c->SetM02(elipAxis[0]*elipAxis[0]);
+    c->SetM20(elipAxis[1]*elipAxis[1]);
+    if (fPedestalData) {
       c->SetDistanceToBadChannel(recpoint->GetDistanceToBadTower()); 
+    } 
+    else {
+      if (fRecoUtils && fRecoUtils->IsBadChannelsRemovalSwitchedOn()) {
+        fRecoUtils->RecalculateClusterDistanceToBadChannel(geom, cells, c);
+      } 
     }
-
+  
     if (esdobjects) {
       AliESDCaloCluster *cesd = static_cast<AliESDCaloCluster*>(c);
       cesd->SetCellsAbsId(absIds);
@@ -455,7 +453,7 @@ void AliAnalysisTaskEMCALClusterizeFast::RecPoints2Clusters(TClonesArray *clus)
       if (trackIndex >= 0) {
         Float_t dR, dZ;
         fRecoUtils->GetMatchedResiduals(i,dR, dZ);
-        c->AddTrackMatched(0x0); //esdevent->GetTrack(trackIndex));
+        c->AddTrackMatched(0x0);   //esdevent->GetTrack(trackIndex));
         c->SetTrackDistance(dR,dZ); // not implemented
         c->SetEmcCpvDistance(dR);
         c->SetChi2(dZ);
@@ -670,8 +668,7 @@ void AliAnalysisTaskEMCALClusterizeFast::Init()
   } else {
     fClusterizer->SetInputCalibrated(kTRUE);   
   }
-  if (!fClusterizeFastORs)
-    fClusterizer->SetCaloCalibPedestal(fPedestalData);
+  fClusterizer->SetCaloCalibPedestal(fPedestalData);
   fClusterizer->SetJustClusters(kTRUE);
   fClusterizer->SetDigitsArr(fDigitsArr);
   fClusterizer->SetOutput(0);
index cf88b9b..876e547 100644 (file)
@@ -46,7 +46,6 @@ class AliAnalysisTaskEMCALClusterizeFast : public AliAnalysisTaskSE {
   Int_t                  GetShiftEta()                                const   { return fShiftEta                     ; }
   Bool_t                 GetTRUShift()                                const   { return fTRUShift                     ; }
   Bool_t                 GetClusterizeFastORs()                       const   { return fClusterizeFastORs            ; }
-  void                   GetFastORtimeCut(Int_t &lower, Int_t &upper) const   { lower = fMinFastORtime               ; upper = fMaxFastORtime     ; }
   void                   JustUnfold(Bool_t yesno)                             { fJustUnfold                  = yesno ; }
   void                   LoadOwnGeometryMatrices(Bool_t b)                    { fLoadGeomMatrices            = b     ; }
   void                   SetAODBranchName(const char *name)                   { fOutputAODBrName             = name  ; }
@@ -70,7 +69,6 @@ class AliAnalysisTaskEMCALClusterizeFast : public AliAnalysisTaskSE {
   void                   SetShiftEta(Int_t n)                                 { fShiftEta                    = n     ; }
   void                   SetTRUShift(Bool_t yes)                              { fTRUShift                    = yes   ; }
   void                   SetClusterizeFastORs(Bool_t yes)                     { fClusterizeFastORs           = yes   ; if (yes) fOverwrite = kFALSE; }
-  void                   SetFastORtimeCut(Int_t lower, Int_t upper)           { fMinFastORtime               = lower ; fMaxFastORtime = upper      ; }
 
  protected:
   virtual void           Clusterize();
@@ -111,8 +109,6 @@ class AliAnalysisTaskEMCALClusterizeFast : public AliAnalysisTaskSE {
   Int_t                  fShiftEta;                       // ShiftEta (for FixedWindowsClusterizer)
   Bool_t                 fTRUShift;                       // Shifting inside a TRU (true) or through the whole calorimeter (false) (for FixedWindowsClusterizer)
   Bool_t                 fClusterizeFastORs;              // If true, clusterize FastORs instead of cells
-  Int_t                  fMinFastORtime;                  // Lower FastOR time cut
-  Int_t                  fMaxFastORtime;                  // Upper FastOR time cut
 
  private:
   AliAnalysisTaskEMCALClusterizeFast(const AliAnalysisTaskEMCALClusterizeFast&);            // not implemented