EMCAL clusterizer: pas the MC label to the intermediate digits so that we can have...
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 27 Mar 2011 17:20:29 +0000 (17:20 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 27 Mar 2011 17:20:29 +0000 (17:20 +0000)
PartCorr: Add possibility to select only simulated clusters embedded in data.

PWG4/CaloCalib/AliAnalysisTaskEMCALClusterize.cxx
PWG4/CaloCalib/AliAnalysisTaskEMCALClusterize.h
PWG4/CaloCalib/macros/emcalReclusterize.C
PWG4/PartCorrBase/AliCaloTrackAODReader.cxx
PWG4/PartCorrBase/AliCaloTrackAODReader.h
PWG4/PartCorrBase/AliCaloTrackReader.cxx
PWG4/PartCorrBase/AliCaloTrackReader.h

index c142ba0..a36d06f 100644 (file)
@@ -44,6 +44,7 @@
 #include "AliCDBEntry.h"
 #include "AliLog.h"
 #include "AliVEventHandler.h"
+#include "AliAODInputHandler.h"
 
 // --- EMCAL
 #include "AliEMCALRecParam.h"
@@ -69,11 +70,12 @@ AliAnalysisTaskEMCALClusterize::AliAnalysisTaskEMCALClusterize(const char *name)
   , fDigitsArr(0),       fClusterArr(0),       fCaloClusterArr(0)
   , fRecParam(0),        fClusterizer(0),      fUnfolder(0),           fJustUnfold(kFALSE) 
   , fOutputAODBranch(0), fOutputAODBranchName("newEMCALClusters"),     fFillAODFile(kTRUE)
-  , fRun(-1),            fRecoUtils(0),        fConfigName("")
+  , fRun(-1),            fRecoUtils(0),        fConfigName(""), fCellLabels()
   
   {
   //ctor
-  for(Int_t i = 0; i < 10; i++) fGeomMatrix[i] = 0 ;
+  for(Int_t i = 0; i < 10;    i++)  fGeomMatrix[i] =  0;
+  for(Int_t j = 0; j < 12672; j++)  fCellLabels[j] = -1;
   fDigitsArr       = new TClonesArray("AliEMCALDigit",200);
   fClusterArr      = new TObjArray(100);
   fCaloClusterArr  = new TObjArray(100);
@@ -90,10 +92,11 @@ AliAnalysisTaskEMCALClusterize::AliAnalysisTaskEMCALClusterize()
   , fDigitsArr(0),       fClusterArr(0),       fCaloClusterArr(0)
   , fRecParam(0),        fClusterizer(0),      fUnfolder(0),           fJustUnfold(kFALSE)
   , fOutputAODBranch(0), fOutputAODBranchName("newEMCALClusters"),     fFillAODFile(kFALSE)
-  , fRun(-1),            fRecoUtils(0),        fConfigName("")
+  , fRun(-1),            fRecoUtils(0),        fConfigName(""), fCellLabels()
 {
   // Constructor
-  for(Int_t i = 0; i < 10; i++) fGeomMatrix[i] = 0 ;
+  for(Int_t i = 0; i < 10;    i++)  fGeomMatrix[i] =  0;
+  for(Int_t j = 0; j < 24*48*11; j++)  fCellLabels[j] = -1;
   fDigitsArr       = new TClonesArray("AliEMCALDigit",200);
   fClusterArr      = new TObjArray(100);
   fCaloClusterArr  = new TObjArray(100);
@@ -175,9 +178,26 @@ void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *)
   //Remove the contents of output list set in the previous event 
   fOutputAODBranch->Clear("C");
   
-  AliVEvent   * event    = InputEvent();
-  AliESDEvent * esdevent = dynamic_cast<AliESDEvent*>(InputEvent());
-
+  //Get the event
+  AliVEvent   * event    = 0;
+  AliESDEvent * esdevent = 0;
+  
+  //Check if input event are embedded events
+  //If so, take output event
+  AliAODInputHandler* aodIH = dynamic_cast<AliAODInputHandler*>((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
+  if (aodIH && aodIH->GetMergeEvents()) {
+    //printf("AliAnalysisTaskEMCALClusterize::UserExec() - Use embedded events\n");
+    event  = AODEvent();
+//    printf("InputEvent  N Clusters %d, N Cells %d\n",InputEvent()->GetNumberOfCaloClusters(),
+//           InputEvent()->GetEMCALCells()->GetNumberOfCells());
+//    printf("OutputEvent N Clusters %d, N Cells %d\n", AODEvent()->GetNumberOfCaloClusters(),
+//           AODEvent()->GetEMCALCells()->GetNumberOfCells());
+  }
+  else {
+    event =  InputEvent();
+    esdevent = dynamic_cast<AliESDEvent*>(InputEvent());
+  }
+  
   if (!event) {
     Error("UserExec","Event not available");
     return;
@@ -290,6 +310,31 @@ void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *)
     //-------------------------------------------------------------------------------------
     //Transform CaloCells into Digits
     //-------------------------------------------------------------------------------------
+    
+    //In case of MC, first loop on the clusters and fill MC label to array
+    //.....................................................................
+    
+//    for(Int_t j = 0; j < 24*48*11; j++)  {
+//      if(fCellLabels[j]!=-1) printf("Not well initialized cell %d, label %d\n",j,fCellLabels[j]) ;
+//    }
+    
+    for (Int_t i = 0; i < event->GetNumberOfCaloClusters(); i++)
+    {
+      AliVCluster *clus = event->GetCaloCluster(i);
+      if(clus->IsEMCAL()){   
+        
+        Int_t label = clus->GetLabel();
+        UShort_t * index    = clus->GetCellsAbsId() ;
+        for(Int_t icell=0; icell < clus->GetNCells(); icell++ ){
+          fCellLabels[index[icell]]=label;
+          //printf("1) absID %d, label %d\n",index[icell], fCellLabels[index[icell]]);
+        }
+        nClustersOrg++;
+      }
+    } 
+    
+    // Create digits 
+    //.................
     Int_t idigit =  0;
     Int_t id     = -1;
     Float_t amp  = -1; 
@@ -302,6 +347,7 @@ void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *)
     TTree *digitsTree = new TTree("digitstree","digitstree");
     digitsTree->Branch("EMCAL","TClonesArray", &fDigitsArr, 32000);
     
+    
     for (Int_t icell = 0; icell < cells->GetNumberOfCells(); icell++)
     {
       if (cells->GetCell(icell, cellNumber, cellAmplitude, cellTime) != kTRUE)
@@ -318,6 +364,7 @@ void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *)
       //Do not include bad channels found in analysis?
       if( fRecoUtils->IsBadChannelsRemovalSwitchedOn() && 
           fRecoUtils->GetEMCALChannelStatus(imod, ieta, iphi)){
+          fCellLabels[id]=-1; //reset the entry in the array for next event
         //printf("Remove channel %d\n",id);
         continue;
       }
@@ -328,13 +375,19 @@ void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *)
         amp *=fRecoUtils->GetEMCALChannelRecalibrationFactor(imod,ieta,iphi);
       }
            
-      AliEMCALDigit *digit = (AliEMCALDigit*) fDigitsArr->New(idigit);
-      digit->SetId(id);
-      digit->SetAmplitude(amp);
-      digit->SetTime(time);
-      digit->SetTimeR(time);
-      digit->SetIndexInList(idigit);
-      digit->SetType(AliEMCALDigit::kHG);
+      //Create the digit, put a fake primary deposited energy to trick the clusterizer when checking the most likely primary
+      new((*fDigitsArr)[idigit]) AliEMCALDigit( fCellLabels[id], fCellLabels[id],id, amp, time,AliEMCALDigit::kHG,idigit, 0, 0, 1); 
+      //if(fCellLabels[id]>=0)printf("2) Digit cell %d, label %d\n",id,fCellLabels[id]) ;
+      //else                  printf("2) Digit cell %d, no label, amp %f \n",id,amp) ;
+      fCellLabels[id]=-1; //reset the entry in the array for next event
+      
+      //AliEMCALDigit *digit = (AliEMCALDigit*) fDigitsArr->New(idigit);
+      //digit->SetId(id);
+      //digit->SetAmplitude(amp);
+      //digit->SetTime(time);
+      //digit->SetTimeR(time);
+      //digit->SetIndexInList(idigit);
+      //digit->SetType(AliEMCALDigit::kHG);
       
       //printf("Digit: Id %d, amp %f, time %e, index %d\n",id, amp,time,idigit);
       idigit++;
@@ -351,7 +404,7 @@ void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *)
     fClusterizer->SetInput(digitsTree);
     fClusterizer->SetOutput(clustersTree);
     fClusterizer->Digits2Clusters("");
-    
+
     //-------------------------------------------------------------------------------------
     //Transform the recpoints into AliVClusters
     //-------------------------------------------------------------------------------------
@@ -362,7 +415,7 @@ void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *)
     TBranch *branch = clustersTree->GetBranch("EMCALECARP");
     branch->SetAddress(&fClusterArr);
     branch->GetEntry(0);
-    
+
     RecPoints2Clusters(fDigitsArr, fClusterArr, fCaloClusterArr);
     
     //---CLEAN UP-----
@@ -383,8 +436,7 @@ void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *)
   //-------------------------------------------------------------------------------------
   
   Int_t kNumberOfCaloClusters   = fCaloClusterArr->GetEntries();
-  //Info("UserExec","New clusters %d",kNumberOfCaloClusters);
-  //if(nClustersOrg!=kNumberOfCaloClusters) Info("UserExec","Different number: Org %d, New %d\n",nClustersOrg,kNumberOfCaloClusters);
+  //printf("New clusters %d, Org clusters %d\n",kNumberOfCaloClusters, nClustersOrg);
   for(Int_t i = 0; i < kNumberOfCaloClusters; i++){
     AliAODCaloCluster *newCluster = (AliAODCaloCluster *) fCaloClusterArr->At(i);
     //if(Entry()==0) Info("UserExec","newCluster E %f\n", newCluster->E());
@@ -406,8 +458,17 @@ void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *)
       //printf("; after %f \n",newCluster->GetDistanceToBadChannel());
     }
     
+//    if(newCluster->GetNLabels()>0){
+//      printf("3) MC: N labels %d, label %d ; ", newCluster->GetNLabels(), newCluster->GetLabel() );
+//      UShort_t * newindex    = newCluster->GetCellsAbsId() ;
+//      for(Int_t icell=0; icell < newCluster->GetNCells(); icell++ ){
+//       printf("\t absID %d\n",newindex[icell]);
+//     }
+//    }
+//    
+//    printf("Cluster %d, energy %f\n",newCluster->GetID(),newCluster->E());
+    
     newCluster->SetID(i);
-    //printf("Cluster %d, energy %f\n",newCluster->GetID(),newCluster->E());
     new((*fOutputAODBranch)[i])  AliAODCaloCluster(*newCluster);
   }
   
@@ -597,6 +658,12 @@ void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr,
     clus->SetM02(elipAxis[0]*elipAxis[0]) ;
     clus->SetM20(elipAxis[1]*elipAxis[1]) ;
     clus->SetDistanceToBadChannel(recPoint->GetDistanceToBadTower()); 
+    
+    //MC
+    Int_t  parentMult  = 0;
+    Int_t *parentList = recPoint->GetParents(parentMult);
+    clus->SetLabel(parentList, parentMult); 
+    
     clusArray->Add(clus);
   } // recPoints loop
 }
index c607bd8..2893570 100644 (file)
@@ -98,7 +98,9 @@ class AliAnalysisTaskEMCALClusterize : public AliAnalysisTaskSE {
   AliEMCALRecoUtils*     fRecoUtils;        // Access to factorized reconstruction algorithms\r
   TString                fConfigName;       // Name of analysis configuration file\r
   \r
-  ClassDef(AliAnalysisTaskEMCALClusterize, 3);\r
+  Int_t                  fCellLabels[12672];// Array with MC label to be passed to digit. \r
+  \r
+  ClassDef(AliAnalysisTaskEMCALClusterize, 4);\r
 };\r
 \r
 #endif //ALIANALYSISTASKEMCALCLUSTERIZE_H\r
index 74dc5df..73bebcd 100644 (file)
@@ -18,7 +18,8 @@ enum anaModes {mLocal, mLocalCAF,mPROOF,mGRID};
 //Settings to read locally several files, only for "mLocal" mode
 //The different values are default, they can be set with environmental 
 //variables: INDIR, PATTERN, NFILES, respectivelly
-char * kInDir = "/Users/data/path/data/"; 
+char * kInDir = "/Users/Gustavo/Work/data/134908/pass1"; 
+//char * kInDir = "/Users/Gustavo/Work/data/137366/";
 char * kPattern = ""; // Data are in files kInDir/kPattern+i 
 Int_t kFile = 1; // Number of files
 //---------------------------------------------------------------------------
@@ -26,16 +27,17 @@ Int_t kFile = 1; // Number of files
 char * kXML = "collection.xml";
 //---------------------------------------------------------------------------
 
-const TString kInputData = "ESD"; //ESD, AOD, MC
+TString kInputData = "AOD"; //ESD, AOD, MC
 TString kTreeName = "esdTree";
 Bool_t kUsePhysSel = kFALSE;
+Bool_t kEmbed = kTRUE;
 
 void emcalReclusterize(Int_t mode=mLocal)
 {
   // Main
-  char cmd[200] ; 
-  sprintf(cmd, ".! rm -rf aod.root") ; 
-  gROOT->ProcessLine(cmd) ; 
+  //char cmd[200] ; 
+  //sprintf(cmd, ".! rm -rf outputAOD.root") ; 
+  //gROOT->ProcessLine(cmd) ; 
   //--------------------------------------------------------------------
   // Load analysis libraries
   // Look at the method below, 
@@ -66,10 +68,14 @@ void emcalReclusterize(Int_t mode=mLocal)
     
     // AOD output handler
     AliAODHandler* aodoutHandler   = new AliAODHandler();
-    aodoutHandler->SetOutputFileName("aod.root");
-    ////aodoutHandler->SetCreateNonStandardAOD();
+    aodoutHandler->SetOutputFileName("outputAOD.root");
+    if(kEmbed){
+      aodoutHandler->SetCreateNonStandardAOD();
+      kInputData = "AOD";
+    }
     mgr->SetOutputEventHandler(aodoutHandler);
     
+
     //input
     if(kInputData == "ESD")
     {
@@ -84,11 +90,16 @@ void emcalReclusterize(Int_t mode=mLocal)
       // AOD handler
       AliAODInputHandler *aodHandler = new AliAODInputHandler();
       mgr->SetInputEventHandler(aodHandler);
+      if(kEmbed){
+       aodHandler->SetMergeEvents(kTRUE);
+       aodHandler->AddFriend("AliAOD.root");
+      }
+      
       cout<<"AOD handler "<<mgr->GetInputEventHandler()<<endl;
       
     }
     
-    mgr->SetDebugLevel(1);
+    //mgr->SetDebugLevel(1);
     
     //-------------------------------------------------------------------------
     //Define task, put here any other task that you want to use.
@@ -117,7 +128,6 @@ void emcalReclusterize(Int_t mode=mLocal)
 //    mgr->ConnectInput  (clusterize, 0,  cinput1 );
 //    mgr->ConnectOutput (clusterize, 0, coutput1 );
     
-    
     //-----------------------
     // Run the analysis
     //-----------------------    
index e1e7861..e05e010 100755 (executable)
@@ -40,7 +40,7 @@ ClassImp(AliCaloTrackAODReader)
 
 //____________________________________________________________________________
 AliCaloTrackAODReader::AliCaloTrackAODReader() : 
-  AliCaloTrackReader()
+  AliCaloTrackReader(), fOrgInputEvent(0x0)
 {
   //Default Ctor
   
@@ -60,6 +60,27 @@ AliCaloTrackAODReader::AliCaloTrackAODReader() :
 //}
 
 //____________________________________________________________________________
+AliCentrality* AliCaloTrackAODReader::GetCentrality() const {
+  // recover centrality object.
+  AliAODEvent* event    = dynamic_cast<AliAODEvent*> (fInputEvent);
+  AliAODEvent* orgevent = dynamic_cast<AliAODEvent*> (fOrgInputEvent);
+
+  if(event && !fSelectEmbeddedClusters) {
+    //Normal AOD event
+    return event->GetHeader()->GetCentralityP() ;
+  }
+  else if(fSelectEmbeddedClusters && fOrgInputEvent) {
+    // centrality in AOD from input, not in embedded event
+    // temporary fix until this object is copied to the output event in embedding analysis
+    return orgevent->GetHeader()->GetCentralityP();
+  }
+  else {
+    return 0x0 ; 
+  }
+}
+
+
+//____________________________________________________________________________
 void AliCaloTrackAODReader::SetInputOutputMCEvent(AliVEvent* input, AliAODEvent* aod, AliMCEvent* mc) {
   // Connect the data pointers
   // If input is AOD, do analysis with input, if not, do analysis with the output aod.
@@ -92,6 +113,7 @@ void AliCaloTrackAODReader::SetInputOutputMCEvent(AliVEvent* input, AliAODEvent*
   if(tesd)   {
     SetInputEvent(aod);
     SetOutputEvent(aod);
+    fOrgInputEvent = input;
   }
   else if(taod){
     AliAODInputHandler* aodIH = dynamic_cast<AliAODInputHandler*>((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
@@ -99,6 +121,7 @@ void AliCaloTrackAODReader::SetInputOutputMCEvent(AliVEvent* input, AliAODEvent*
                  //Merged events, use output AOD.
                  SetInputEvent(aod);
                  SetOutputEvent(aod);
+      fOrgInputEvent = input;
          }
          else{
                  SetInputEvent(input);
index 0d9f11f..8b11b53 100755 (executable)
@@ -13,6 +13,8 @@
 //
 // -- Author: Gustavo Conesa (INFN-LNF)
 
+#include "AliAnalysisTaskSE.h"
+
 #include "AliAODEvent.h"
 #include "AliCaloTrackReader.h" 
 
@@ -23,14 +25,22 @@ public:
   AliCaloTrackAODReader() ; // ctor
   virtual ~AliCaloTrackAODReader() {;} //virtual dtor
   
-  AliCentrality* GetCentrality() const {
-    AliAODEvent* event = dynamic_cast<AliAODEvent*> (fInputEvent);      
-    if(event) return event->GetHeader()->GetCentralityP() ; 
-    else      return 0x0                    ; }
-  
+private:
+  AliCaloTrackAODReader(const AliCaloTrackAODReader & ) ; // cpy ctor
+  AliCaloTrackAODReader & operator = (const AliCaloTrackAODReader & g) ;//cpy assignment
+   
+public: 
+
+  AliCentrality* GetCentrality() const ;  
   void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ; 
   
-  ClassDef(AliCaloTrackAODReader,5)
+  AliVEvent* GetOriginalInputEvent() const { return fOrgInputEvent; }
+  
+private:
+  
+  AliVEvent *fOrgInputEvent; //! Original input event, not from filtering
+  
+  ClassDef(AliCaloTrackAODReader,6)
 } ;
 
 #endif //ALICALOTRACKAODREADER_H
index 122f1cd..e1bf46b 100755 (executable)
@@ -64,7 +64,7 @@ ClassImp(AliCaloTrackReader)
     fEMCALCells(0x0), fPHOSCells(0x0),
     fInputEvent(0x0), fOutputEvent(0x0),fMC(0x0),
     fFillCTS(0),fFillEMCAL(0),fFillPHOS(0),
-    fFillEMCALCells(0),fFillPHOSCells(0),  
+    fFillEMCALCells(0),fFillPHOSCells(0),  fSelectEmbeddedClusters(kFALSE),
     fRemoveSuspiciousClusters(kFALSE), fSmearClusterEnergy(kFALSE), fRandom(),
 //    fSecondInputAODTree(0x0), fSecondInputAODEvent(0x0),
 //    fSecondInputFileName(""),fSecondInputFirstEvent(0), 
@@ -551,7 +551,7 @@ Bool_t AliCaloTrackReader::FillInputEvent(const Int_t iEntry, const char * /*cur
 void AliCaloTrackReader::ResetLists() {
   //  Reset lists, called by the analysis maker 
 
-  if(fCTSTracks)     fCTSTracks     -> Clear();
+  if(fCTSTracks)       fCTSTracks     -> Clear();
   if(fEMCALClusters)   fEMCALClusters   -> Clear("C");
   if(fPHOSClusters)    fPHOSClusters    -> Clear("C");
 //  if(fEMCALCells) fEMCALCells -> Clear("");
@@ -796,8 +796,12 @@ void AliCaloTrackReader::FillInputEMCALAlgorithm(AliVCluster * clus, const Int_t
 //    else {
 //      if(energy > 2)printf("AliCaloTrackReader::FillInputEMCALAlgorithm() - Keep cluster: e %2.2f, Ncells %d, min Ncells %2.1f\n",energy,ncells,minNCells);
 //    }
-  }
+  }//Suspicious
   
+  if(fSelectEmbeddedClusters){
+    if(clus->GetNLabels()==0) return;
+    //else printf("Embedded cluster,  %d, n label %d label %d  \n",iclus,clus->GetNLabels(),clus->GetLabel());
+  }
   
   TLorentzVector momentum ;
   
index 59f4cef..63b19fe 100755 (executable)
@@ -140,6 +140,9 @@ public:
   void   SwitchOnPHOSCells()            { fFillPHOSCells = kTRUE   ; }
   void   SwitchOffPHOSCells()           { fFillPHOSCells = kFALSE  ; }
 
+  void   SwitchOnEmbeddedClustersSelection() { fSelectEmbeddedClusters = kTRUE   ; }
+  void   SwitchOffEmbeddedClustersSelection(){ fSelectEmbeddedClusters = kFALSE  ; }
+  
   // Filling/ filtering / detector information access methods
   virtual Bool_t FillInputEvent(const Int_t iEntry, const char *currentFileName)  ;
   virtual void   FillInputCTS() ;
@@ -233,7 +236,7 @@ public:
   //------------------------
   // Centrality
   //------------------------
-  virtual AliCentrality* GetCentrality()            const { return fInputEvent->GetCentrality() ; }
+  virtual AliCentrality* GetCentrality()            const { return fInputEvent->GetCentrality() ; } //Look in AOD reader, different there
   virtual void      SetCentralityClass(TString name)      { fCentralityClass   = name           ; }
   virtual void      SetCentralityOpt(Int_t opt)           { fCentralityOpt     = opt            ; }
   virtual TString   GetCentralityClass()            const { return fCentralityClass             ; }
@@ -277,6 +280,7 @@ public:
   virtual AliAODMCHeader*   GetAODMCHeader(Int_t input = 0)    const ;
        
   virtual AliVEvent*        GetInputEvent()  const { return fInputEvent  ; }
+  virtual AliVEvent* GetOriginalInputEvent() const { return 0x0          ; }
   virtual AliAODEvent*      GetOutputEvent() const { return fOutputEvent ; }
   virtual AliMCEvent*       GetMC()          const { return fMC          ; }
   virtual AliMixedEvent*    GetMixedEvent()  const { return fMixedEvent  ; }
@@ -346,6 +350,7 @@ public:
   Bool_t           fFillPHOS;       // use data from PHOS
   Bool_t           fFillEMCALCells; // use data from EMCAL
   Bool_t           fFillPHOSCells;  // use data from PHOS
+  Bool_t           fSelectEmbeddedClusters;   // Use only simulated clusters that come from embedding.
   Bool_t           fRemoveSuspiciousClusters; // Remove high energy clusters with low number of cells
   Bool_t           fSmearClusterEnergy;       // Smear cluster energy, to be done only for simulated data to match real data
   Float_t          fSmearClusterParam[3];     // Smearing parameters
@@ -398,7 +403,7 @@ public:
   Int_t            fCentralityOpt;       // Option for the returned value of the centrality, possible options 5, 10, 100
   Int_t            fCentralityBin[2];    // Minimum and maximum value of the centrality for the analysis
   
-  ClassDef(AliCaloTrackReader,27)
+  ClassDef(AliCaloTrackReader,28)
 } ;