Cleanup
authorloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 1 Sep 2011 10:28:31 +0000 (10:28 +0000)
committerloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 1 Sep 2011 10:28:31 +0000 (10:28 +0000)
EMCAL/AliEMCALClusterizerFixedWindow.cxx
EMCAL/AliEMCALClusterizerFixedWindow.h
PWG4/CaloCalib/AliAnalysisTaskEMCALClusterizeFast.cxx

index 4a4f89f..5399946 100644 (file)
 ClassImp(AliEMCALClusterizerFixedWindow)
 
 //__________________________________________________________________________________________
-AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow()
-  : AliEMCALClusterizer(), 
-    fNphi(4), 
-    fNeta(4), 
-    fShiftPhi(2), 
-    fShiftEta(2),
-    fTRUshift(0),
-    fClustersArray(0)
+  AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow()
+    : AliEMCALClusterizer(), 
+      fNphi(4), 
+      fNeta(4), 
+      fShiftPhi(2), 
+      fShiftEta(2),
+      fTRUshift(0),
+      fClustersArray(0)
 {
-       // Constructor
+  // Constructor
 }
 
 //__________________________________________________________________________________________
@@ -81,7 +81,7 @@ AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry*
 //__________________________________________________________________________________________
 AliEMCALClusterizerFixedWindow::~AliEMCALClusterizerFixedWindow()
 {
-       // Destructor
+  // Destructor
   
   delete fClustersArray;
 }
@@ -145,81 +145,80 @@ void AliEMCALClusterizerFixedWindow::SetTRUshift(Bool_t b)
 //__________________________________________________________________________________________
 void AliEMCALClusterizerFixedWindow::Digits2Clusters(Option_t * option)
 {
-       // Steering method to perform clusterization for the current event 
+  // Steering method to perform clusterization for the current event 
        
-       if (strstr(option,"tim"))
-               gBenchmark->Start("EMCALClusterizer"); 
+  if (strstr(option,"tim"))
+    gBenchmark->Start("EMCALClusterizer"); 
        
-       if (strstr(option,"print"))
-               Print(""); 
+  if (strstr(option,"print"))
+    Print(""); 
        
-       //Get calibration parameters from file or digitizer default values.
-       GetCalibrationParameters();
+  //Get calibration parameters from file or digitizer default values.
+  GetCalibrationParameters();
        
-       //Get dead channel map from file or digitizer default values.
-       GetCaloCalibPedestal();
+  //Get dead channel map from file or digitizer default values.
+  GetCaloCalibPedestal();
        
-       MakeClusters();  //only the real clusters
+  MakeClusters();  //only the real clusters
        
-       if (fToUnfold) {
-               fClusterUnfolding->SetInput(fNumberOfECAClusters,fRecPoints,fDigitsArr);
-               fClusterUnfolding->MakeUnfolding();
-       }
+  if (fToUnfold) {
+    fClusterUnfolding->SetInput(fNumberOfECAClusters,fRecPoints,fDigitsArr);
+    fClusterUnfolding->MakeUnfolding();
+  }
        
-       //Evaluate position, dispersion and other RecPoint properties for EC section 
-       for (Int_t index = 0; index < fRecPoints->GetEntries(); index++) { 
-               AliEMCALRecPoint * rp = dynamic_cast<AliEMCALRecPoint *>(fRecPoints->At(index));
-               if (rp) {
-                       rp->EvalAll(fECAW0,fDigitsArr,fJustClusters);
-                       AliDebug(5, Form("MAX INDEX %d ", rp->GetMaximalEnergyIndex()));
-                       //For each rec.point set the distance to the nearest bad crystal
-                       if (fCaloPed)
-                               rp->EvalDistanceToBadChannels(fCaloPed);
-               }
-       }
+  //Evaluate position, dispersion and other RecPoint properties for EC section 
+  for (Int_t index = 0; index < fRecPoints->GetEntries(); index++) { 
+    AliEMCALRecPoint * rp = dynamic_cast<AliEMCALRecPoint *>(fRecPoints->At(index));
+    if (rp) {
+      rp->EvalAll(fECAW0,fDigitsArr,fJustClusters);
+      AliDebug(5, Form("MAX INDEX %d ", rp->GetMaximalEnergyIndex()));
+      //For each rec.point set the distance to the nearest bad crystal
+      if (fCaloPed)
+        rp->EvalDistanceToBadChannels(fCaloPed);
+    }
+  }
   
   fRecPoints->Sort();
        
-  // Constantin To Do
-       //for (Int_t index = 0; index < fRecPoints->GetEntries(); index++) {
-       //      AliEMCALRecPoint *rp = dynamic_cast<AliEMCALRecPoint *>(fRecPoints->At(index));
-       //      if (rp) {
-       //              rp->SetIndexInList(index);
-       //      }
-       //      else AliFatal("RecPoint NULL!!");
-       //}
+  for (Int_t index = 0; index < fRecPoints->GetEntries(); index++) {
+    AliEMCALRecPoint *rp = dynamic_cast<AliEMCALRecPoint *>(fRecPoints->At(index));
+    if (rp) {
+      rp->SetIndexInList(index);
+    }
+    else AliFatal("RecPoint NULL!!");
+  }
        
-       if (fTreeR)
-               fTreeR->Fill();
+  if (fTreeR)
+    fTreeR->Fill();
        
-       if (strstr(option,"deb") || strstr(option,"all"))  
-               PrintRecPoints(option);
+  if (strstr(option,"deb") || strstr(option,"all"))  
+    PrintRecPoints(option);
        
-       AliDebug(1,Form("EMCAL Clusterizer found %d Rec Points",fRecPoints->GetEntriesFast()));
+  AliDebug(1,Form("EMCAL Clusterizer found %d Rec Points",fRecPoints->GetEntriesFast()));
        
-       if (strstr(option,"tim")) {
-               gBenchmark->Stop("EMCALClusterizer");
-               printf("Exec took %f seconds for Clusterizing", 
-                          gBenchmark->GetCpuTime("EMCALClusterizer"));
-       }    
+  if (strstr(option,"tim")) {
+    gBenchmark->Stop("EMCALClusterizer");
+    printf("Exec took %f seconds for Clusterizing", 
+           gBenchmark->GetCpuTime("EMCALClusterizer"));
+  }    
 }
 
 //__________________________________________________________________________________________
 void AliEMCALClusterizerFixedWindow::MakeClusters()
 {
-       // Make clusters
+  // Make clusters
        
-       if (fGeom == 0) 
-               AliFatal("Did not get geometry from EMCALLoader");
+  if (fGeom == 0) 
+    AliFatal("Did not get geometry from EMCALLoader");
        
-       fNumberOfECAClusters = 0;
-       fRecPoints->Delete();
+  fNumberOfECAClusters = 0;
+  fRecPoints->Delete();
        
-       Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0, iphi=0, ieta=0;
+  Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0, iphi=0, ieta=0;
        
-       // Defining geometry and clusterization parameter
-       Int_t nEtaDigitsSupMod = fGeom->GetNEta() * fGeom->GetNETAdiv(); // always 48?;
-       Int_t nPhiDigitsSupMod = fGeom->GetNPhi() * fGeom->GetNPHIdiv(); // always 24?;
+  // Defining geometry and clusterization parameter
+  Int_t nEtaDigitsSupMod = fGeom->GetNEta() * fGeom->GetNETAdiv(); // always 48?;
+  Int_t nPhiDigitsSupMod = fGeom->GetNPhi() * fGeom->GetNPHIdiv(); // always 24?;
   
   Int_t nTRUPhi = 1;
   Int_t nTRUEta = 1;
@@ -236,34 +235,34 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
 
   // Check if clusterizer parameter are compatible with calorimeter geometry
   if (nEtaDigits < fNeta){
-               AliFatal(Form("Error: fNeta = %d is greater than nEtaDigits = %d.",fNeta,nEtaDigits));
-               return;
-       }
-       if (nPhiDigits < fNphi){
-               AliFatal(Form("Error: fNphi = %d is greater than nPhiDigits = %d.",fNphi,nPhiDigits));
-               return;
-       }
-       if (nEtaDigits % fShiftEta != 0){
-               AliFatal(Form("Error: fShiftEta = %d is such that clusters cannot slide the whole calorimeter (nEtaDigits = %d).",fShiftEta,nEtaDigits));
-               return;
-       }
-       if (nPhiDigits % fShiftPhi != 0){
-               AliFatal(Form("Error: fShiftPhi = %d is such that clusters cannot slide the whole calorimeter (nPhiDigits = %d).",fShiftPhi,nPhiDigits));
-               return;
-       }
-       if (fNeta % fShiftEta != 0){
-               AliFatal(Form("Error: fShiftEta = %d is not divisor of fNeta = %d.",fShiftEta,fNeta));
-               return;
-       }
-       if (fNphi % fShiftPhi != 0){
-               AliFatal(Form("Error: fShiftPhi = %d is not divisor of fNphi = %d).",fShiftPhi,fNphi));
-               return;
-       }
+    AliFatal(Form("Error: fNeta = %d is greater than nEtaDigits = %d.",fNeta,nEtaDigits));
+    return;
+  }
+  if (nPhiDigits < fNphi){
+    AliFatal(Form("Error: fNphi = %d is greater than nPhiDigits = %d.",fNphi,nPhiDigits));
+    return;
+  }
+  if (nEtaDigits % fShiftEta != 0){
+    AliFatal(Form("Error: fShiftEta = %d is such that clusters cannot slide the whole calorimeter (nEtaDigits = %d).",fShiftEta,nEtaDigits));
+    return;
+  }
+  if (nPhiDigits % fShiftPhi != 0){
+    AliFatal(Form("Error: fShiftPhi = %d is such that clusters cannot slide the whole calorimeter (nPhiDigits = %d).",fShiftPhi,nPhiDigits));
+    return;
+  }
+  if (fNeta % fShiftEta != 0){
+    AliFatal(Form("Error: fShiftEta = %d is not divisor of fNeta = %d.",fShiftEta,fNeta));
+    return;
+  }
+  if (fNphi % fShiftPhi != 0){
+    AliFatal(Form("Error: fShiftPhi = %d is not divisor of fNphi = %d).",fShiftPhi,fNphi));
+    return;
+  }
   
   Int_t maxiShiftPhi = fNphi / fShiftPhi;
   Int_t maxiShiftEta = fNeta / fShiftEta;
        
-       Int_t nDigitsCluster = fNphi * fNeta;
+  Int_t nDigitsCluster = fNphi * fNeta;
   
   Int_t nClusEtaNoShift = nEtaDigits / fNeta;
   Int_t nClusPhiNoShift = nPhiDigits / fNphi;
@@ -356,38 +355,38 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
       
     } // loop on eta shift
     
-       } // loop on phi shift
+  } // loop on phi shift
        
   Int_t iRecPoint = 0;
-       for (Int_t iCluster = 0; iCluster < nTotalClus; iCluster++){
+  for (Int_t iCluster = 0; iCluster < nTotalClus; iCluster++){
     
-               if (fClustersArray[iCluster] == NULL) continue;
+    if (fClustersArray[iCluster] == NULL) continue;
                
-               (*fRecPoints)[iRecPoint] = new AliEMCALRecPoint("");
-               AliEMCALRecPoint *recPoint = dynamic_cast<AliEMCALRecPoint*> (fRecPoints->At(iRecPoint));
+    (*fRecPoints)[iRecPoint] = new AliEMCALRecPoint("");
+    AliEMCALRecPoint *recPoint = dynamic_cast<AliEMCALRecPoint*> (fRecPoints->At(iRecPoint));
                
-               if (recPoint) {
-                       iRecPoint++;       
-                       recPoint->SetClusterType(AliVCluster::kEMCALClusterv1);
-      recPoint->SetIndexInList(iCluster);
+    if (recPoint) {
+      iRecPoint++;       
+      recPoint->SetClusterType(AliVCluster::kEMCALClusterv1);
+      recPoint->SetUniqueID(iCluster);
 
-                       for (Int_t iDigit = 0; iDigit < nDigitsCluster; iDigit++){
-                               if (fClustersArray[iCluster][iDigit] == NULL) continue;
-                               digit = fClustersArray[iCluster][iDigit];
+      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());
-                               digit->SetCalibAmp(dEnergyCalibrated);
-                               recPoint->AddDigit(*digit, dEnergyCalibrated, kFALSE); //Time or TimeR?
+        digit->SetCalibAmp(dEnergyCalibrated);
+        recPoint->AddDigit(*digit, dEnergyCalibrated, kFALSE); //Time or TimeR?
         fClustersArray[iCluster][iDigit] = NULL;
-                       }
-               }
+      }
+    }
     
     delete[] fClustersArray[iCluster];
     fClustersArray[iCluster] = NULL;
-       }
+  }
   
-       AliDebug(1, Form("MakeClusters: Number of digits %d  -> (e %f)\n", fDigitsArr->GetEntries(),fMinECut));
+  AliDebug(1, Form("MakeClusters: Number of digits %d  -> (e %f)\n", fDigitsArr->GetEntries(),fMinECut));
        
-       AliDebug(1, Form("total no of clusters %d from %d digits", fNumberOfECAClusters, fDigitsArr->GetEntriesFast())); 
+  AliDebug(1, Form("total no of clusters %d from %d digits", fNumberOfECAClusters, fDigitsArr->GetEntriesFast())); 
 }
index 8a09879..0b499b9 100644 (file)
@@ -15,43 +15,40 @@ class AliEMCALRecPoint;
 class AliEMCALDigit;
 
 class AliEMCALClusterizerFixedWindow : public AliEMCALClusterizer {
-public:
-       AliEMCALClusterizerFixedWindow() ;         
-       AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry);
-       AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * pedestal);
-       virtual ~AliEMCALClusterizerFixedWindow();
+ public:
+  AliEMCALClusterizerFixedWindow() ;         
+  AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry);
+  AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * pedestal);
+  virtual ~AliEMCALClusterizerFixedWindow();
        
-public:
-       virtual void            Digits2Clusters(Option_t *option);
-       virtual const char     *Version() const { return "clu-FixedWindow"; }  
-
-  Int_t                             GetNphi ()                                          const { return fNphi;             }
-       Int_t                             GetNeta ()                                          const { return fNeta;             }
-  Int_t                             GetShiftPhi ()                                      const { return fShiftPhi;         }
-  Int_t                             GetShiftEta ()                                      const { return fShiftEta;         }
-  Bool_t                            GetTRUshift()                                       const { return fTRUshift;         }
-       void                              SetNphi (Int_t n);
-       void                              SetNeta (Int_t n);
-  void                              SetShiftPhi (Int_t s);
-  void                              SetShiftEta (Int_t s);
-  void                              SetTRUshift(Bool_t b);
+  virtual void            Digits2Clusters(Option_t *option);
+  virtual const char     *Version() const { return "clu-FixedWindow"; }  
+
+  Int_t                   GetNphi ()                                          const { return fNphi;             }
+  Int_t                   GetNeta ()                                          const { return fNeta;             }
+  Int_t                   GetShiftPhi ()                                      const { return fShiftPhi;         }
+  Int_t                   GetShiftEta ()                                      const { return fShiftEta;         }
+  Bool_t                  GetTRUshift()                                       const { return fTRUshift;         }
+  void                    SetNphi (Int_t n);
+  void                    SetNeta (Int_t n);
+  void                    SetShiftPhi (Int_t s);
+  void                    SetShiftEta (Int_t s);
+  void                    SetTRUshift(Bool_t b);
   
 protected:
        virtual void MakeClusters(); 
   
-       Int_t                               fNphi;                // Fixed window number of cells in phi direction
-       Int_t                               fNeta;                // Fixed window number of cells in eta direction
-  Int_t                               fShiftPhi;            // Shifting number of cells in phi direction
-  Int_t                               fShiftEta;            // Shifting number of cells in eta direction
-  Bool_t                              fTRUshift;            // Allows shifting inside a TRU (true) of through the whole calorimeter (false)
-  AliEMCALDigit                    ***fClustersArray;       //!Temporary array that contains clusters
+  Int_t                   fNphi;                // Fixed window number of cells in phi direction
+  Int_t                   fNeta;                // Fixed window number of cells in eta direction
+  Int_t                   fShiftPhi;            // Shifting number of cells in phi direction
+  Int_t                   fShiftEta;            // Shifting number of cells in eta direction
+  Bool_t                  fTRUshift;            // Allows shifting inside a TRU (true) of through the whole calorimeter (false)
+  AliEMCALDigit        ***fClustersArray;       //!Temporary array that contains clusters
        
 private:
-       AliEMCALClusterizerFixedWindow(const AliEMCALClusterizerFixedWindow &);                 // not implemented
-       AliEMCALClusterizerFixedWindow & operator = (const AliEMCALClusterizerFixedWindow &);   // not implemented
-       
+  AliEMCALClusterizerFixedWindow(const AliEMCALClusterizerFixedWindow &);                 // not implemented
+  AliEMCALClusterizerFixedWindow & operator = (const AliEMCALClusterizerFixedWindow &);   // not implemented
 
-       ClassDef(AliEMCALClusterizerFixedWindow,4)   // Clusterizer implementation version 1
+  ClassDef(AliEMCALClusterizerFixedWindow,4)   // Clusterizer implementation version 1
 };
-
 #endif // AliEMCALCLUSTERIZERFIXEDWINDOW_H
index d59ba10..dd71759 100644 (file)
@@ -239,12 +239,9 @@ void AliAnalysisTaskEMCALClusterizeFast::FillDigitsArray()
   
   fDigitsArr->Clear("C");
   
-  if (fCreatePattern){
-    
+  if (fCreatePattern) {
     AliEMCALGeometry *fGeom = AliEMCALGeometry::GetInstance(fGeomName);
-
     Int_t maxd = fGeom->GetNCells() / 4;
-    
     for (Int_t idigit = 0; idigit < maxd; idigit++){
       if (idigit % 24 == 12) idigit += 12;
       AliEMCALDigit *digit = static_cast<AliEMCALDigit*>(fDigitsArr->New(idigit));
@@ -254,14 +251,12 @@ void AliAnalysisTaskEMCALClusterizeFast::FillDigitsArray()
       digit->SetIndexInList(idigit);
       digit->SetType(AliEMCALDigit::kHG);
       digit->SetAmplitude(0.1);
-      
     }
-    
-  }
-  else if (fClusterizeFastORs){
+
+  } else if (fClusterizeFastORs) {
     
     AliEMCALGeometry *fGeom = AliEMCALGeometry::GetInstance(fGeomName);
-    
+  
     AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
     if (!esd){
       AliError("Cannot get the ESD event");
@@ -318,10 +313,8 @@ void AliAnalysisTaskEMCALClusterizeFast::FillDigitsArray()
         idigit++;
       }
     }
-  }
-       else{
-               
-    // Fill digits from cells.
+
+  } else { // Fill digits from cells.
     
     AliVCaloCells *cells = InputEvent()->GetEMCALCells();
     Double_t avgE = 0; // for background subtraction
@@ -362,7 +355,7 @@ void AliAnalysisTaskEMCALClusterizeFast::FillDigitsArray()
         }
       }
     }
-       }
+  }
 }
 
 //________________________________________________________________________________________
@@ -412,7 +405,6 @@ void AliAnalysisTaskEMCALClusterizeFast::RecPoints2Clusters(TClonesArray *clus)
     c->SetDispersion(recpoint->GetDispersion());
     c->SetEmcCpvDistance(-1);            //not yet implemented
     c->SetChi2(-1);                      //not yet implemented
-    recpoint->EvalAll(1, fDigitsArr, kTRUE);
     c->SetTOF(recpoint->GetTime()) ;     //time-of-flight
     c->SetNExMax(recpoint->GetNExMax()); //number of local maxima
     Float_t elipAxis[2];
@@ -431,7 +423,7 @@ void AliAnalysisTaskEMCALClusterizeFast::RecPoints2Clusters(TClonesArray *clus)
       AliESDCaloCluster *cesd = static_cast<AliESDCaloCluster*>(c);
       cesd->SetCellsAbsId(absIds);
       cesd->SetCellsAmplitudeFraction(ratios);
-      cesd->SetID(recpoint->GetIndexInList());
+      cesd->SetID(recpoint->GetUniqueID());
     } else {
       AliAODCaloCluster *caod = static_cast<AliAODCaloCluster*>(c);
       caod->SetCellsAbsId(absIds);
@@ -453,14 +445,14 @@ void AliAnalysisTaskEMCALClusterizeFast::RecPoints2Clusters(TClonesArray *clus)
     for(Int_t i=0; i < Nclus; ++i) {
       AliAODCaloCluster *c = static_cast<AliAODCaloCluster*>(clus->At(i));
       Int_t trackIndex = fRecoUtils->GetMatchedTrackIndex(i);
-      if(trackIndex >= 0) {
+      if (trackIndex >= 0) {
         Float_t dR, dZ;
         fRecoUtils->GetMatchedResiduals(i,dR, dZ);
         c->AddTrackMatched(0x0); //esdevent->GetTrack(trackIndex));
         c->SetTrackDistance(dR,dZ); // not implemented
         c->SetEmcCpvDistance(dR);
         c->SetChi2(dZ);
-        if(DebugLevel() > 1) 
+        if (DebugLevel() > 1) 
           AliInfo(Form("Matched Track index %d to new cluster %d\n",trackIndex,i));
       }
     }
@@ -469,7 +461,7 @@ void AliAnalysisTaskEMCALClusterizeFast::RecPoints2Clusters(TClonesArray *clus)
     for(Int_t i=0; i < Nclus; ++i) {
       AliESDCaloCluster *c = static_cast<AliESDCaloCluster*>(clus->At(i));
       Int_t trackIndex = fRecoUtils->GetMatchedTrackIndex(i);
-      if(trackIndex >= 0) {
+      if (trackIndex >= 0) {
         Float_t dR, dZ;
         fRecoUtils->GetMatchedResiduals(i,dR, dZ);
         c->SetTrackDistance(dR,dZ);
@@ -477,7 +469,7 @@ void AliAnalysisTaskEMCALClusterizeFast::RecPoints2Clusters(TClonesArray *clus)
         c->SetChi2(dZ);           //to be consistent with AODs
         TArrayI tm(1,&trackIndex);
         c->AddTracksMatched(tm);
-        if(DebugLevel() > 1) 
+        if (DebugLevel() > 1) 
           AliInfo(Form("Matched Track index %d to new cluster %d\n",trackIndex,i));
       }
     }
@@ -517,14 +509,14 @@ void AliAnalysisTaskEMCALClusterizeFast::UpdateClusters()
   if (!fAttachClusters)
     return;
   
-  TClonesArray *clus;
+  TClonesArray *clus = 0;
   
   if (fOverwrite)
   {
     clus = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject("caloClusters"));
     if (!clus)
       clus = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject("CaloClusters"));
-    if(!clus)
+    if (!clus)
       return;
     
     Int_t nents = clus->GetEntries();
@@ -535,25 +527,18 @@ void AliAnalysisTaskEMCALClusterizeFast::UpdateClusters()
       if (c->IsEMCAL())
         delete clus->RemoveAt(i);
     }
-  }
-  else
-  {
+  } else {
     clus = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fNewClusterArrayName));
-    if(!clus)
-    {
+    if (!clus) {
       clus = new TClonesArray("AliESDCaloCluster");
       clus->SetName(fNewClusterArrayName);
       InputEvent()->AddObject(clus);
-    }
-    else 
-    {
-      
+    } else {
       Int_t nents = clus->GetEntries();
       for (Int_t i=0;i<nents;++i) {
         AliVCluster *c = static_cast<AliVCluster*>(clus->At(i));
         if (!c)
           continue;
-        
         delete clus->RemoveAt(i);
       }
       clus->Compress();
@@ -594,8 +579,8 @@ void AliAnalysisTaskEMCALClusterizeFast::Init()
   if (!fGeomMatrixSet) {
     if (fLoadGeomMatrices) {
       for(Int_t mod=0; mod < geometry->GetNumberOfSuperModules(); ++mod) {
-        if(fGeomMatrix[mod]){
-          if(DebugLevel() > 2) 
+        if (fGeomMatrix[mod]){
+          if (DebugLevel() > 2) 
             fGeomMatrix[mod]->Print();
           geometry->SetMisalMatrix(fGeomMatrix[mod],mod);  
         }
@@ -613,7 +598,7 @@ void AliAnalysisTaskEMCALClusterizeFast::Init()
           }
         }
         if (gm) {
-          if(DebugLevel() > 2) 
+          if (DebugLevel() > 2) 
             gm->Print();
           geometry->SetMisalMatrix(gm,mod);
         }
@@ -632,14 +617,14 @@ void AliAnalysisTaskEMCALClusterizeFast::Init()
   delete fClusterizer;
   if     (fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerv1)
     fClusterizer = new AliEMCALClusterizerv1(geometry);
-  else if(fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerNxN) {
+  else if (fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerNxN) {
    AliEMCALClusterizerNxN *clusterizer = new AliEMCALClusterizerNxN(geometry);
    clusterizer->SetNRowDiff(fRecParam->GetNRowDiff());
    clusterizer->SetNColDiff(fRecParam->GetNColDiff());
     fClusterizer = clusterizer;
-  } else if(fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerv2) 
+  } else if (fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerv2) 
     fClusterizer = new AliEMCALClusterizerv2(geometry);
-  else if(fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerFW){
+  else if (fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerFW){
     AliEMCALClusterizerFixedWindow *clusterizer = new AliEMCALClusterizerFixedWindow(geometry);
     clusterizer->SetNphi(fNPhi);
     clusterizer->SetNeta(fNEta);
@@ -678,7 +663,7 @@ void AliAnalysisTaskEMCALClusterizeFast::Init()
   } else {
     fClusterizer->SetInputCalibrated(kTRUE);   
   }
-  if(fRecParam->GetClusterizerFlag() != AliEMCALRecParam::kClusterizerFW)
+  if (!fClusterizeFastORs)
     fClusterizer->SetCaloCalibPedestal(fPedestalData);
   fClusterizer->SetJustClusters(kTRUE);
   fClusterizer->SetDigitsArr(fDigitsArr);