get the v0 signal and multiplicity, accessible for different analysis, add histograms...
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 7 Nov 2010 18:40:33 +0000 (18:40 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 7 Nov 2010 18:40:33 +0000 (18:40 +0000)
PWG4/PartCorrBase/AliAnaPartCorrBaseClass.cxx
PWG4/PartCorrBase/AliAnaPartCorrBaseClass.h
PWG4/PartCorrBase/AliCaloTrackESDReader.cxx
PWG4/PartCorrBase/AliCaloTrackESDReader.h
PWG4/PartCorrBase/AliCaloTrackReader.cxx
PWG4/PartCorrBase/AliCaloTrackReader.h
PWG4/PartCorrDep/AliAnaCalorimeterQA.cxx
PWG4/PartCorrDep/AliAnaCalorimeterQA.h
PWG4/macros/QA/AddTaskCalorimeterQA.C

index 8ea2fe3..7f310d7 100755 (executable)
@@ -59,81 +59,17 @@ ClassImp(AliAnaPartCorrBaseClass)
     fHistoPhiBins(0),  fHistoPhiMax(0.),  fHistoPhiMin(0.),
     fHistoEtaBins(0),  fHistoEtaMax(0.),  fHistoEtaMin(0.),
     fHistoMassBins(0), fHistoMassMax(0.), fHistoMassMin(0.),
-    fHistoAsymBins(0), fHistoAsymMax(0.), fHistoAsymMin(0.)
+    fHistoAsymBins(0), fHistoAsymMax(0.), fHistoAsymMin(0.),
+    fHistoV0SBins(0),  fHistoV0SMax(0),   fHistoV0SMin(0),
+    fHistoV0MBins(0),  fHistoV0MMax(0),   fHistoV0MMin(0),
+    fHistoTrMBins(0),  fHistoTrMMax(0),   fHistoTrMMin(0)
 {
   //Default Ctor
     
   //Initialize parameters
   InitParameters();
 }
-/*
-//___________________________________________________________
-AliAnaPartCorrBaseClass::AliAnaPartCorrBaseClass(const AliAnaPartCorrBaseClass & abc) :   
-  TObject(), fDataMC(abc.fDataMC), fDebug(abc.fDebug),
-  fCheckFidCut(abc.fCheckFidCut),  fCheckCaloPID(abc. fCheckCaloPID),
-  fRecalculateCaloPID(abc.fRecalculateCaloPID),
-  fMinPt(abc.fMinPt), fMaxPt(abc.fMaxPt), fReader(new AliCaloTrackReader(*abc.fReader)),  
-  fInputAODBranch(new TClonesArray(*abc.fInputAODBranch)), fInputAODName(abc.fInputAODName),
-  fOutputAODBranch(new TClonesArray(*abc.fOutputAODBranch)),fNewAOD(abc.fNewAOD), 
-  fOutputAODName(abc.fOutputAODName), fOutputAODClassName(abc.fOutputAODClassName),
-  fAODObjArrayName(abc.fAODObjArrayName),
-  fAddToHistogramsName(abc.fAddToHistogramsName),
-  fCaloPID(new AliCaloPID(*abc.fCaloPID)), fFidCut(new AliFiducialCut(*abc.fFidCut)), fIC(new AliIsolationCut(*abc.fIC)),
-  fMCUtils(new AliMCAnalysisUtils(*abc.fMCUtils)), fNMS(new AliNeutralMesonSelection(*abc.fNMS)),
-  fCaloUtils(new AliCalorimeterUtils(*abc.fCaloUtils)),
-  fHistoPtBins(abc.fHistoPtBins),     fHistoPtMax(abc.fHistoPtMax),     fHistoPtMin(abc.fHistoPtMin),
-  fHistoPhiBins(abc.fHistoPhiBins),   fHistoPhiMax(abc.fHistoPhiMax),   fHistoPhiMin(abc.fHistoPhiMin),
-  fHistoEtaBins(abc.fHistoEtaBins),   fHistoEtaMax(abc.fHistoEtaMax),   fHistoEtaMin(abc.fHistoEtaMin),
-  fHistoMassBins(abc.fHistoMassBins), fHistoMassMax(abc.fHistoMassMax), fHistoMassMin(abc.fHistoMassMin),
-  fHistoAsymBins(abc.fHistoAsymBins), fHistoAsymMax(abc.fHistoAsymMax), fHistoAsymMin(abc.fHistoAsymMin)
-{
-  // cpy ctor
 
-}
-*/
-  /*
-//_________________________________________________________________________
-AliAnaPartCorrBaseClass & AliAnaPartCorrBaseClass::operator = (const AliAnaPartCorrBaseClass & abc)
-{
-  // assignment operator
-  
-  if(this == &abc) return *this;
-  ((TObject *)this)->operator=(abc);
-  
-  fDataMC             = abc.fDataMC;
-  fDebug              = abc.fDebug ;
-  fRecalculateCaloPID = abc.fRecalculateCaloPID ;
-  fCheckCaloPID       = abc.fCheckCaloPID ;
-  fCheckFidCut        = abc.fCheckFidCut ; 
-       
-  fMinPt   = abc.fMinPt;
-  fMaxPt   = abc.fMaxPt;
-       
-  delete fCaloPID;   fCaloPID   = new AliCaloPID        (*abc.fCaloPID);
-  delete fFidCut;    fFidCut    = new AliFiducialCut    (*abc.fFidCut);
-  delete fMCUtils;   fMCUtils   = new AliMCAnalysisUtils(*abc.fMCUtils);
-  delete fIC;        fIC        = new AliIsolationCut   (*abc.fIC);
-  delete fNMS;       fNMS       = new AliNeutralMesonSelection(*abc.fNMS);
-  delete fCaloUtils; fCaloUtils = new AliCalorimeterUtils(*abc.fCaloUtils);
-  delete fReader;    fReader    = new AliCaloTrackReader(*abc.fReader) ;
-       
-  delete fInputAODBranch;  fInputAODBranch      = new TClonesArray(*abc.fInputAODBranch) ;
-  fInputAODName        = abc.fInputAODName;
-  delete fOutputAODBranch; fOutputAODBranch     = new TClonesArray(*abc.fOutputAODBranch) ;
-  fNewAOD              = abc.fNewAOD ; 
-  fOutputAODName       = abc.fOutputAODName; 
-  fOutputAODClassName  = abc.fOutputAODClassName;
-  fAddToHistogramsName = abc.fAddToHistogramsName;
-  fAODObjArrayName     = abc.fAODObjArrayName;
-
-  fHistoPtBins  = abc.fHistoPtBins;  fHistoPtMax  = abc.fHistoPtMax;  fHistoPtMin  = abc.fHistoPtMin;
-  fHistoPhiBins = abc.fHistoPhiBins; fHistoPhiMax = abc.fHistoPhiMax; fHistoPhiMin = abc.fHistoPhiMin;
-  fHistoEtaBins = abc.fHistoEtaBins; fHistoEtaMax = abc.fHistoEtaMax; fHistoEtaMin = abc.fHistoEtaMin;
-  
-  return *this;
-  
-}
-  */
 //____________________________________________________________________________
 AliAnaPartCorrBaseClass::~AliAnaPartCorrBaseClass() 
 {
@@ -498,6 +434,18 @@ void AliAnaPartCorrBaseClass::InitParameters()
   fHistoAsymBins  = 10 ;
   fHistoAsymMax   = 1. ;
   fHistoAsymMin   = 0. ;
+  
+  fHistoV0SBins   = 100 ;
+  fHistoV0SMax    = 10000  ;
+  fHistoV0SMin    = 0  ;
+  
+  fHistoV0MBins  = 100;
+  fHistoV0MMax   = 10000 ;
+  fHistoV0MMin   = 0 ;
+       
+  fHistoTrMBins  = 100 ;
+  fHistoTrMMax   = 10000 ;
+  fHistoTrMMin   = 0 ;
        
 }
 
@@ -526,6 +474,10 @@ void AliAnaPartCorrBaseClass::Print(const Option_t * opt) const
   printf("Histograms: %3.1f < eta < %3.1f, Nbin = %d\n", fHistoEtaMin, fHistoEtaMax, fHistoEtaBins);
   printf("Histograms: %3.1f < mass < %3.1f, Nbin = %d\n", fHistoMassMin, fHistoMassMax, fHistoMassBins);
   printf("Histograms: %3.1f < asymmetry < %3.1f, Nbin = %d\n", fHistoAsymMin, fHistoAsymMax, fHistoAsymBins);
+  printf("Histograms: %d < V0 Signal < %d, Nbin = %d\n", fHistoV0SMin, fHistoV0SMax, fHistoV0SBins);
+  printf("Histograms: %d < V0 Mult < %d, Nbin = %d\n", fHistoV0MMin, fHistoV0MMax, fHistoV0MBins);
+  printf("Histograms: %d < Track Mult < %d, Nbin = %d\n", fHistoTrMMin, fHistoTrMMax, fHistoTrMBins);
+
   printf("Name of reference array      : %s\n", fAODObjArrayName.Data());      
   printf("String added histograms name : %s\n",fAddToHistogramsName.Data());
        
index d9ac191..7949af4 100755 (executable)
@@ -73,9 +73,7 @@ public:
   
   virtual AliCaloTrackReader * GetReader() const {return fReader ; }
   virtual void SetReader(AliCaloTrackReader * const reader) { fReader = reader ; }
-  
-  Int_t GetTrackMultiplicity() const {return fReader->GetTrackMultiplicity();}
-  
+    
   //Calorimeter helper class access methods
   AliEMCALGeoUtils *  GetEMCALGeometry() const { return fCaloUtils->GetEMCALGeometry(); }
   AliPHOSGeoUtils  *  GetPHOSGeometry()  const { return fCaloUtils->GetPHOSGeometry() ; }
@@ -237,6 +235,39 @@ public:
   virtual Float_t GetHistoAsymmetryMin()   const { return fHistoAsymMin ; }
   virtual Float_t GetHistoAsymmetryMax()   const { return fHistoAsymMax ; }    
   
+  
+  //VZero
+  virtual void SetHistoV0SignalRangeAndNBins(Int_t min, Int_t max, Int_t n) {
+    fHistoV0SBins = n ;
+    fHistoV0SMax  = max ;
+    fHistoV0SMin  = min ;
+  }
+       
+  virtual Int_t   GetHistoV0SignalBins()  const { return fHistoV0SBins ; }
+  virtual Float_t GetHistoV0SignalMin()   const { return fHistoV0SMin ; }
+  virtual Float_t GetHistoV0SignalMax()   const { return fHistoV0SMax ; }
+       
+  virtual void SetHistoV0MultiplicityRangeAndNBins(Int_t min, Int_t max, Int_t n) {
+    fHistoV0MBins = n ;
+    fHistoV0MMax  = max ;
+    fHistoV0MMin  = min ;
+  }
+       
+  virtual Int_t   GetHistoV0MultiplicityBins()  const { return fHistoV0MBins ; }
+  virtual Float_t GetHistoV0MultiplicityMin()   const { return fHistoV0MMin ; }
+  virtual Float_t GetHistoV0MultiplicityMax()   const { return fHistoV0MMax ; }
+  
+  virtual void SetHistoTrackMultiplicityRangeAndNBins(Int_t min, Int_t max, Int_t n) {
+    fHistoTrMBins = n ;
+    fHistoTrMMax  = max ;
+    fHistoTrMMin  = min ;
+  }
+       
+  virtual Int_t   GetHistoTrackMultiplicityBins()  const { return fHistoTrMBins ; }
+  virtual Float_t GetHistoTrackMultiplicityMin()   const { return fHistoTrMMin ; }
+  virtual Float_t GetHistoTrackMultiplicityMax()   const { return fHistoTrMMax ; }
+  
+  
   virtual AliMixedEvent * GetMixedEvent()          { return GetReader()->GetMixedEvent() ; } 
   virtual Int_t           GetNMixedEvent()   const { return GetReader()->GetNMixedEvent() ; } 
   
@@ -250,23 +281,29 @@ public:
   void SwitchOffPlotsMaking() {fMakePlots = kFALSE ;}
   Bool_t MakePlotsOn() const  {return fMakePlots;}
   
+  //MULTIPLICITY
+  Int_t GetTrackMultiplicity() const {return fReader->GetTrackMultiplicity();}
+  //VZERO
+  Int_t GetV0Signal(Int_t i )       const {return fReader->GetV0Signal(i);}
+  Int_t GetV0Multiplicity(Int_t i ) const {return fReader->GetV0Multiplicity(i);}
+
 private:    
   
-  Bool_t  fDataMC ;             // Flag to access MC data when using ESD or AOD     
-  Int_t   fDebug ;              // Debug level
-  Bool_t  fCheckFidCut ;        // Do analysis for clusters in defined region         
-  Bool_t  fCheckCaloPID ;       // Do analysis for calorimeters
-  Bool_t  fRecalculateCaloPID ; // Recalculate PID or use PID weights in calorimeters
-  Float_t fMinPt ;              // Maximum pt of (trigger) particles in the analysis
-  Float_t fMaxPt ;              // Minimum pt of (trigger) particles in the analysis
-  Int_t    fMultiBin ;   // Number of bins in event container for multiplicity
-  Int_t    fNZvertBin ;          // Number of bins in event container for vertex position
-  Int_t    fNrpBin ;       // Number of bins in event container for reaction plain
-  Float_t  fZvtxCut ;      // Cut on vertex position  
-  Int_t    fMaxMulti ;              // Maximum multiplicity of particles in the analysis
-  Int_t    fMinMulti ;              // Maximum multiplicity of particles in the analysis
-  Bool_t   fUseSelectEvent ; // Select events based on multiplicity and vertex cuts
-  Bool_t   fMakePlots   ;    // Print plots
+  Bool_t   fDataMC ;             // Flag to access MC data when using ESD or AOD     
+  Int_t    fDebug ;              // Debug level
+  Bool_t   fCheckFidCut ;        // Do analysis for clusters in defined region         
+  Bool_t   fCheckCaloPID ;       // Do analysis for calorimeters
+  Bool_t   fRecalculateCaloPID ; // Recalculate PID or use PID weights in calorimeters
+  Float_t  fMinPt ;              // Maximum pt of (trigger) particles in the analysis
+  Float_t  fMaxPt ;              // Minimum pt of (trigger) particles in the analysis
+  Int_t    fMultiBin ;          // Number of bins in event container for multiplicity
+  Int_t    fNZvertBin ;                 // Number of bins in event container for vertex position
+  Int_t    fNrpBin ;              // Number of bins in event container for reaction plain
+  Float_t  fZvtxCut ;             // Cut on vertex position  
+  Int_t    fMaxMulti ;           // Maximum multiplicity of particles in the analysis
+  Int_t    fMinMulti ;           // Maximum multiplicity of particles in the analysis
+  Bool_t   fUseSelectEvent ;     // Select events based on multiplicity and vertex cuts
+  Bool_t   fMakePlots   ;        // Print plots
 
        
   AliCaloTrackReader * fReader; // Acces to ESD/AOD/MC data
@@ -304,8 +341,17 @@ private:
   Int_t   fHistoAsymBins ;  // Number of bins in asymmetry axis
   Float_t fHistoAsymMax  ;  // Maximum value of asymmetry histogram range
   Float_t fHistoAsymMin  ;  // Minimum value of asymmetry histogram range
-  
-  ClassDef(AliAnaPartCorrBaseClass,11)
+  Int_t   fHistoV0SBins  ;  // Number of bins in V0 signal axis
+  Int_t   fHistoV0SMax   ;  // Maximum value of V0 signal histogram range
+  Int_t   fHistoV0SMin   ;  // Minimum value of V0 signal histogram range
+  Int_t   fHistoV0MBins  ;  // Number of bins in V0 multiplicity axis
+  Int_t   fHistoV0MMax   ;  // Maximum value of V0 multiplicity histogram range
+  Int_t   fHistoV0MMin   ;  // Minimum value of V0 multiplicity histogram range
+  Int_t   fHistoTrMBins  ;  // Number of bins in V0 multiplicity axis
+  Int_t   fHistoTrMMax   ;  // Maximum value of track multiplicity histogram range
+  Int_t   fHistoTrMMin   ;  // Minimum value of track multiplicity histogram range
+  
+  ClassDef(AliAnaPartCorrBaseClass,13)
 } ;
 
 
index ddcb489..0f189d0 100755 (executable)
@@ -35,6 +35,7 @@
 #include "AliMultiEventInputHandler.h"
 #include "AliAnalysisManager.h"
 #include "AliMixedEvent.h"
+#include "AliESDVZERO.h"
 
 
 ClassImp(AliCaloTrackESDReader)
@@ -93,3 +94,27 @@ void AliCaloTrackESDReader::SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* a
   SetMC(mc);
   
 }
+
+//____________________________________________________________________________
+void AliCaloTrackESDReader::FillInputVZERO(){
+  //Fill VZERO information in data member, add all the channels information.
+  AliESDVZERO* esdV0 = ((AliESDEvent*)fInputEvent)->GetVZEROData();
+  //printf("Init V0: ADC (%d,%d), Multiplicity (%d,%d) \n",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]);
+
+  if (esdV0) 
+  {
+    for (Int_t i = 0; i < 32; i++)
+    {
+      fV0ADC[0] += esdV0->GetAdcV0C(i);
+      fV0ADC[1] += esdV0->GetAdcV0A(i);
+      fV0Mul[0] += esdV0->GetMultiplicityV0C(i);
+      fV0Mul[1] += esdV0->GetMultiplicityV0A(i);
+    }
+    if(fDebug > 0)
+      printf("V0: ADC (%d,%d), Multiplicity (%d,%d) \n",fV0ADC[0],fV0ADC[1],fV0Mul[0],fV0Mul[1]);
+  }
+  else
+  {
+    printf("Cannot retrieve V0 ESD! Run w/ null V0 charges");
+  }
+}
index 9c08307..f926981 100755 (executable)
@@ -32,6 +32,8 @@ class AliCaloTrackESDReader : public AliCaloTrackReader {
   void SetInputOutputMCEvent(AliVEvent* esd, AliAODEvent* aod, AliMCEvent* mc) ; 
        
   TString GetFiredTriggerClasses() {return ((AliESDEvent*)GetInputEvent())->GetFiredTriggerClasses();}
+  
+  void FillInputVZERO();
 
   ClassDef(AliCaloTrackESDReader,1)
 } ;
index e61dab7..c2a4749 100755 (executable)
@@ -323,7 +323,9 @@ void AliCaloTrackReader::InitParameters()
   
   fESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010();
 
-  
+  fV0ADC[0] = 0;   fV0ADC[1] = 0; 
+  fV0Mul[0] = 0;   fV0Mul[1] = 0; 
+
 }
 
 //________________________________________________________________
@@ -445,6 +447,7 @@ Bool_t AliCaloTrackReader::FillInputEvent(const Int_t iEntry, const char * curre
   if(fFillPHOS)  
     FillInputPHOS();
 
+  FillInputVZERO();
        
   return kTRUE ;
 }
@@ -458,6 +461,10 @@ void AliCaloTrackReader::ResetLists() {
   if(fAODPHOS)    fAODPHOS    -> Clear();
   if(fEMCALCells) fEMCALCells -> Clear();
   if(fPHOSCells)  fPHOSCells  -> Clear();
+
+  fV0ADC[0] = 0;   fV0ADC[1] = 0; 
+  fV0Mul[0] = 0;   fV0Mul[1] = 0; 
+
 }
 
 //____________________________________________________________________________
@@ -845,6 +852,7 @@ void AliCaloTrackReader::FillInputPHOSCells() {
   
 }
 
+
 //____________________________________________________________________________
 Bool_t AliCaloTrackReader::IsEMCALCluster(AliVCluster* cluster) const {
   // Check if it is a cluster from EMCAL. For old AODs cluster type has
index 9015141..fc799f0 100755 (executable)
@@ -217,6 +217,10 @@ public:
   Bool_t WriteDeltaAODToFile() const {return fWriteOutputDeltaAOD ; } 
   
   
+  virtual void FillInputVZERO(){;}
+  Int_t GetV0Signal(Int_t i) const { return fV0ADC[i];}
+  Int_t GetV0Multiplicity(Int_t i)   const { return fV0Mul[i];}
+
   //MC reader methods:
   
   virtual void AddNeutralParticlesArray(TArrayI & /*array*/)  { ; }  
@@ -298,6 +302,10 @@ public:
   Bool_t           fWriteOutputDeltaAOD;// Write the created delta AOD objects into file  
        Bool_t           fOldAOD;             // Old AODs, before revision 4.20
   
+  Int_t            fV0ADC[2]    ;       // Integrated V0 signal
+  Int_t            fV0Mul[2]    ;       // Integrated V0 Multiplicity
+
+  
   ClassDef(AliCaloTrackReader,20)
 } ;
 
index d3b4cbd..4864306 100755 (executable)
@@ -58,7 +58,7 @@ ClassImp(AliAnaCalorimeterQA)
 AliAnaCalorimeterQA::AliAnaCalorimeterQA() : 
 AliAnaPartCorrBaseClass(), fCalorimeter(""), fStyleMacro(""), 
 fFillAllPosHisto(kFALSE), fFillAllTH12(kFALSE),
-fCorrelateCalos(kFALSE), fNModules(12), fNRCU(2),
+fCorrelate(kTRUE), fNModules(12), fNRCU(2),
 fTimeCutMin(-1), fTimeCutMax(9999999),
 fEMCALCellAmpMin(0),fPHOSCellAmpMin(0), 
 fHistoFinePtBins(1000),    fHistoFinePtMax(5.),        fHistoFinePtMin(0.),
@@ -90,6 +90,9 @@ fhDeltaCellClusterRE(0),     fhDeltaCellClusterXE(0),     fhDeltaCellClusterYE(0
 fhNCells(0), fhAmplitude(0), fhAmpId(0), fhEtaPhiAmp(0), 
 fhTime(0), fhTimeId(0), fhTimeAmp(0), //fhT0Time(0), fhT0TimeId(0), fhT0TimeAmp(0), 
 fhCaloCorrNClusters(0), fhCaloCorrEClusters(0), fhCaloCorrNCells(0), fhCaloCorrECells(0),
+fhCaloV0SCorrNClusters(0), fhCaloV0SCorrEClusters(0), fhCaloV0SCorrNCells(0), fhCaloV0SCorrECells(0),
+fhCaloV0MCorrNClusters(0), fhCaloV0MCorrEClusters(0), fhCaloV0MCorrNCells(0), fhCaloV0MCorrECells(0),
+fhCaloTrackMCorrNClusters(0), fhCaloTrackMCorrEClusters(0), fhCaloTrackMCorrNCells(0), fhCaloTrackMCorrECells(0),
 fhEMod(0), fhNClustersMod(0), fhNCellsPerClusterMod(0), fhNCellsMod(0),  
 fhGridCellsMod(0), fhGridCellsEMod(0), fhGridCellsTimeMod(0), 
 fhAmplitudeMod(0), fhAmplitudeModFraction(0),fhTimeAmpPerRCU(0), //fhT0TimeAmpPerRCU(0), fhTimeCorrRCU(0),
@@ -176,7 +179,10 @@ TList *  AliAnaCalorimeterQA::GetCreateOutputObjects()
   Int_t ybins       = GetHistoYBins();            Float_t ymax      = GetHistoYMax();            Float_t ymin      = GetHistoYMin(); 
   Int_t zbins       = GetHistoZBins();            Float_t zmax      = GetHistoZMax();            Float_t zmin      = GetHistoZMin(); 
   Int_t ssbins      = GetHistoShowerShapeBins();  Float_t ssmax     = GetHistoShowerShapeMax();  Float_t ssmin     = GetHistoShowerShapeMin();
-  
+  Int_t nv0sbins    = GetHistoV0SignalBins();     Int_t nv0smax     = GetHistoV0SignalMax();     Int_t nv0smin     = GetHistoV0SignalMin(); 
+  Int_t nv0mbins    = GetHistoV0MultiplicityBins();Int_t nv0mmax    = GetHistoV0MultiplicityMax();Int_t nv0mmin    = GetHistoV0MultiplicityMin(); 
+  Int_t ntrmbins    = GetHistoTrackMultiplicityBins();Int_t ntrmmax = GetHistoTrackMultiplicityMax();Int_t ntrmmin = GetHistoTrackMultiplicityMin(); 
+
   //EMCAL
   Int_t colmax = 48;
   Int_t rowmax = 24;
@@ -515,13 +521,14 @@ TList *  AliAnaCalorimeterQA::GetCreateOutputObjects()
     //         outputContainer->Add(fhT0TimeAmp);
   }
        
-  if(fCorrelateCalos){
+  if(fCorrelate){
+    //PHOS vs EMCAL
     fhCaloCorrNClusters  = new TH2F ("hCaloCorrNClusters","# clusters in EMCAL vs PHOS", nbins,nmin,nmax,nbins,nmin,nmax); 
     fhCaloCorrNClusters->SetXTitle("number of clusters in EMCAL");
     fhCaloCorrNClusters->SetYTitle("number of clusters in PHOS");
     outputContainer->Add(fhCaloCorrNClusters);
     
-    fhCaloCorrEClusters  = new TH2F ("hCaloCorrEClusters","summed energy of clusters in EMCAL vs PHOS", nptbins*2,ptmin,ptmax*2,nptbins,ptmin,ptmax*2); 
+    fhCaloCorrEClusters  = new TH2F ("hCaloCorrEClusters","summed energy of clusters in EMCAL vs PHOS", nptbins,ptmin,ptmax,nptbins,ptmin,ptmax); 
     fhCaloCorrEClusters->SetXTitle("#Sigma E of clusters in EMCAL (GeV)");
     fhCaloCorrEClusters->SetYTitle("#Sigma E of clusters in PHOS (GeV)");
     outputContainer->Add(fhCaloCorrEClusters);
@@ -531,10 +538,75 @@ TList *  AliAnaCalorimeterQA::GetCreateOutputObjects()
     fhCaloCorrNCells->SetYTitle("number of Cells in PHOS");
     outputContainer->Add(fhCaloCorrNCells);
     
-    fhCaloCorrECells  = new TH2F ("hCaloCorrECells","summed energy of Cells in EMCAL vs PHOS", nptbins*2,ptmin,ptmax*2,nptbins,ptmin,ptmax*2); 
+    fhCaloCorrECells  = new TH2F ("hCaloCorrECells","summed energy of Cells in EMCAL vs PHOS", nptbins*2,ptmin,ptmax*2,nptbins*2,ptmin,ptmax*2); 
     fhCaloCorrECells->SetXTitle("#Sigma E of Cells in EMCAL (GeV)");
     fhCaloCorrECells->SetYTitle("#Sigma E of Cells in PHOS (GeV)");
     outputContainer->Add(fhCaloCorrECells);
+    
+    //Calorimeter VS V0 signal
+    fhCaloV0SCorrNClusters  = new TH2F ("hCaloV0SNClusters",Form("# clusters in %s vs V0 signal",fCalorimeter.Data()), nv0sbins,nv0smin,nv0smax,nbins,nmin,nmax); 
+    fhCaloV0SCorrNClusters->SetXTitle("V0 signal");
+    fhCaloV0SCorrNClusters->SetYTitle(Form("number of clusters in %s",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloV0SCorrNClusters);
+    
+    fhCaloV0SCorrEClusters  = new TH2F ("hCaloV0SEClusters",Form("summed energy of clusters in Calorimeter vs V0 signal",fCalorimeter.Data()), nv0sbins,nv0smin,nv0smax,nptbins,ptmin,ptmax); 
+    fhCaloV0SCorrEClusters->SetXTitle("V0 signal");
+    fhCaloV0SCorrEClusters->SetYTitle(Form("#Sigma E of clusters in %s (GeV)",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloV0SCorrEClusters);
+    
+    fhCaloV0SCorrNCells  = new TH2F ("hCaloV0SNCells",Form("# Cells in Calorimeter vs V0 signal",fCalorimeter.Data()), nv0sbins,nv0smin,nv0smax, nbins,nmin,nmax); 
+    fhCaloV0SCorrNCells->SetXTitle("V0 signal");
+    fhCaloV0SCorrNCells->SetYTitle(Form("number of Cells in %s",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloV0SCorrNCells);
+    
+    fhCaloV0SCorrECells  = new TH2F ("hCaloV0SECells",Form("summed energy of Cells in %s vs V0 signal",fCalorimeter.Data()), nv0sbins,nv0smin,nv0smax,nptbins,ptmin,ptmax); 
+    fhCaloV0SCorrECells->SetXTitle("V0 signal");
+    fhCaloV0SCorrECells->SetYTitle(Form("#Sigma E of Cells in %s (GeV)",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloV0SCorrECells);    
+    
+    //Calorimeter VS V0 multiplicity
+    fhCaloV0MCorrNClusters  = new TH2F ("hCaloV0MNClusters",Form("# clusters in %s vs V0 signal",fCalorimeter.Data()), nv0mbins,nv0mmin,nv0mmax,nbins,nmin,nmax); 
+    fhCaloV0MCorrNClusters->SetXTitle("V0 signal");
+    fhCaloV0MCorrNClusters->SetYTitle(Form("number of clusters in %s",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloV0MCorrNClusters);
+    
+    fhCaloV0MCorrEClusters  = new TH2F ("hCaloV0MEClusters",Form("summed energy of clusters in Calorimeter vs V0 signal",fCalorimeter.Data()), nv0mbins,nv0mmin,nv0mmax,nptbins,ptmin,ptmax); 
+    fhCaloV0MCorrEClusters->SetXTitle("V0 signal");
+    fhCaloV0MCorrEClusters->SetYTitle(Form("#Sigma E of clusters in %s (GeV)",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloV0MCorrEClusters);
+    
+    fhCaloV0MCorrNCells  = new TH2F ("hCaloV0MNCells",Form("# Cells in Calorimeter vs V0 signal",fCalorimeter.Data()), nv0mbins,nv0mmin,nv0mmax, nbins,nmin,nmax); 
+    fhCaloV0MCorrNCells->SetXTitle("V0 signal");
+    fhCaloV0MCorrNCells->SetYTitle(Form("number of Cells in %s",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloV0MCorrNCells);
+    
+    fhCaloV0MCorrECells  = new TH2F ("hCaloV0MECells",Form("summed energy of Cells in %s vs V0 signal",fCalorimeter.Data()), nv0mbins,nv0mmin,nv0mmax,nptbins,ptmin,ptmax); 
+    fhCaloV0MCorrECells->SetXTitle("V0 signal");
+    fhCaloV0MCorrECells->SetYTitle(Form("#Sigma E of Cells in %s (GeV)",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloV0SCorrECells);    
+    
+    //Calorimeter VS Track multiplicity
+    fhCaloTrackMCorrNClusters  = new TH2F ("hCaloTrackMNClusters",Form("# clusters in %s vs V0 signal",fCalorimeter.Data()), ntrmbins,ntrmmin,ntrmmax,nbins,nmin,nmax); 
+    fhCaloTrackMCorrNClusters->SetXTitle("Track Multiplicity");
+    fhCaloTrackMCorrNClusters->SetYTitle(Form("number of clusters in %s",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloTrackMCorrNClusters);
+    
+    fhCaloTrackMCorrEClusters  = new TH2F ("hCaloTrackMEClusters",Form("summed energy of clusters in Calorimeter vs V0 signal",fCalorimeter.Data()), ntrmbins,ntrmmin,ntrmmax,nptbins,ptmin,ptmax); 
+    fhCaloTrackMCorrEClusters->SetXTitle("Track Multiplicity");
+    fhCaloTrackMCorrEClusters->SetYTitle(Form("#Sigma E of clusters in %s (GeV)",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloTrackMCorrEClusters);
+    
+    fhCaloTrackMCorrNCells  = new TH2F ("hCaloTrackMNCells",Form("# Cells in Calorimeter vs V0 signal",fCalorimeter.Data()), ntrmbins,ntrmmin,ntrmmax, nbins,nmin,nmax); 
+    fhCaloTrackMCorrNCells->SetXTitle("Track Multiplicity");
+    fhCaloTrackMCorrNCells->SetYTitle(Form("number of Cells in %s",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloTrackMCorrNCells);
+    
+    fhCaloTrackMCorrECells  = new TH2F ("hCaloTrackMECells",Form("summed energy of Cells in %s vs V0 signal",fCalorimeter.Data()), ntrmbins,ntrmmin,ntrmmax,nptbins,ptmin,ptmax); 
+    fhCaloTrackMCorrECells->SetXTitle("Track Multiplicity");
+    fhCaloTrackMCorrECells->SetYTitle(Form("#Sigma E of Cells in %s (GeV)",fCalorimeter.Data()));
+    outputContainer->Add(fhCaloV0SCorrECells);    
+    
+    
   }//correlate calorimeters
   
   //Module histograms
@@ -1282,10 +1354,9 @@ void  AliAnaCalorimeterQA::MakeAnalysisFillHistograms()
   }
   else{
     //----------------------------------------------------------
-    //Correlate Calorimeters
+    //Correlate Calorimeters and V0 and track Multiplicity
     //----------------------------------------------------------
-    //if(fCorrelateCalos)      CorrelateCalorimeters(caloClusters);
-    if(fCorrelateCalos)        CorrelateCalorimeters();
+    if(fCorrelate)     Correlate();
     
     
     //----------------------------------------------------------
@@ -2191,72 +2262,18 @@ void AliAnaCalorimeterQA::ClusterHistograms(const TLorentzVector mom, const Doub
   
 }// Clusters
 
-//__________________________________
-//void AliAnaCalorimeterQA::CorrelateCalorimeters(TRefArray* refArray){
-//  // Correlate information from PHOS and EMCAL
-//     TRefArray * caloClustersEMCAL = 0;
-//     TRefArray * caloClustersPHOS  = 0;
-//     
-//  // Get once the array of clusters per calorimeter, avoid an extra loop.
-//  if(fCalorimeter == "EMCAL"){ 
-//    caloClustersPHOS = new TRefArray();
-//    GetReader()->GetInputEvent()->GetPHOSClusters(caloClustersPHOS);
-//    caloClustersEMCAL = new TRefArray(*refArray);
-//  }
-//  else if(fCalorimeter == "PHOS") { 
-//    caloClustersEMCAL = new TRefArray();
-//    GetReader()->GetInputEvent()->GetEMCALClusters (caloClustersEMCAL);
-//    caloClustersPHOS = new TRefArray(*refArray);
-//  }
-//  
-//  //Fill histograms with clusters
-//  
-//  fhCaloCorrNClusters->Fill(caloClustersEMCAL->GetEntriesFast(),caloClustersPHOS->GetEntriesFast());
-//  Float_t sumClusterEnergyEMCAL = 0;
-//  Float_t sumClusterEnergyPHOS  = 0;
-//  Int_t iclus = 0;
-//  for(iclus = 0 ; iclus <  caloClustersEMCAL->GetEntriesFast() ; iclus++) 
-//    sumClusterEnergyEMCAL += ((AliVCluster*)caloClustersEMCAL->At(iclus))->E();
-//  for(iclus = 0 ; iclus <  caloClustersPHOS->GetEntriesFast(); iclus++) 
-//    sumClusterEnergyPHOS += ((AliVCluster*)caloClustersPHOS->At(iclus))->E();
-//  fhCaloCorrEClusters->Fill(sumClusterEnergyEMCAL,sumClusterEnergyPHOS);
-//  
-//  //Fill histograms with cells
-//  
-//  AliVCaloCells * cellsEMCAL = GetReader()->GetInputEvent()->GetEMCALCells();
-//  AliVCaloCells * cellsPHOS  = GetReader()->GetInputEvent()->GetPHOSCells();
-//  fhCaloCorrNCells   ->Fill(cellsEMCAL->GetNumberOfCells(),cellsPHOS->GetNumberOfCells());
-//  
-//  Int_t icell = 0;
-//  Float_t sumCellEnergyEMCAL = 0;
-//  Float_t sumCellEnergyPHOS  = 0;
-//  for(icell = 0 ; icell < cellsEMCAL->GetNumberOfCells()  ; icell++) 
-//    sumCellEnergyEMCAL += cellsEMCAL->GetAmplitude(icell);
-//  for(icell = 0 ; icell <  cellsPHOS->GetNumberOfCells(); icell++) 
-//    sumCellEnergyPHOS += cellsPHOS->GetAmplitude(icell);
-//  fhCaloCorrECells->Fill(sumCellEnergyEMCAL,sumCellEnergyPHOS);
-//  if(GetDebug() > 0 ){
-//    printf("AliAnaCalorimeterQA::CorrelateCalorimeters() - ESD: \n");
-//    printf("\t EMCAL: N cells %d, N clusters  %d, summed E cells %f, summed E clusters %f \n",
-//           cellsEMCAL->GetNumberOfCells(),caloClustersEMCAL->GetEntriesFast(),sumCellEnergyEMCAL,sumClusterEnergyEMCAL);
-//    printf("\t PHOS : N cells %d, N clusters  %d, summed E cells %f, summed E clusters %f \n",
-//           cellsPHOS->GetNumberOfCells(),caloClustersPHOS->GetEntriesFast(),sumCellEnergyPHOS,sumClusterEnergyPHOS);
-//  }
-//     
-//     delete caloClustersEMCAL;
-//     delete caloClustersPHOS;
-//     
-//}
 
 //__________________________________
-void AliAnaCalorimeterQA::CorrelateCalorimeters(){
-  // Correlate information from PHOS and EMCAL
+void AliAnaCalorimeterQA::Correlate(){
+  // Correlate information from PHOS and EMCAL and with V0 and track multiplicity
+  //Clusters 
   TObjArray * caloClustersEMCAL = GetAODEMCAL();
   TObjArray * caloClustersPHOS  = GetAODPHOS();
   
-  //Fill histograms with clusters
+  Int_t nclEMCAL = caloClustersEMCAL->GetEntriesFast();
+  Int_t nclPHOS  = caloClustersPHOS ->GetEntriesFast();
   
-  fhCaloCorrNClusters->Fill(caloClustersEMCAL->GetEntriesFast(),caloClustersPHOS->GetEntriesFast());
   Float_t sumClusterEnergyEMCAL = 0;
   Float_t sumClusterEnergyPHOS  = 0;
   Int_t iclus = 0;
@@ -2264,28 +2281,75 @@ void AliAnaCalorimeterQA::CorrelateCalorimeters(){
     sumClusterEnergyEMCAL += ((AliVCluster*)caloClustersEMCAL->At(iclus))->E();
   for(iclus = 0 ; iclus <  caloClustersPHOS->GetEntriesFast(); iclus++) 
     sumClusterEnergyPHOS += ((AliVCluster*)caloClustersPHOS->At(iclus))->E();
-  fhCaloCorrEClusters->Fill(sumClusterEnergyEMCAL,sumClusterEnergyPHOS);
   
-  //Fill histograms with cells
+
+  //Cells
   
   AliVCaloCells * cellsEMCAL = GetEMCALCells();
   AliVCaloCells * cellsPHOS  = GetPHOSCells();
-  fhCaloCorrNCells   ->Fill(cellsEMCAL->GetNumberOfCells(),cellsPHOS->GetNumberOfCells());
+
+  Int_t ncellsEMCAL = cellsEMCAL->GetNumberOfCells();
+  Int_t ncellsPHOS  = cellsPHOS ->GetNumberOfCells();
   
-  Int_t icell = 0;
   Float_t sumCellEnergyEMCAL = 0;
   Float_t sumCellEnergyPHOS  = 0;
+  Int_t icell = 0;
   for(icell = 0 ; icell < cellsEMCAL->GetNumberOfCells()  ; icell++) 
     sumCellEnergyEMCAL += cellsEMCAL->GetAmplitude(icell);
   for(icell = 0 ; icell <  cellsPHOS->GetNumberOfCells(); icell++) 
     sumCellEnergyPHOS += cellsPHOS->GetAmplitude(icell);
-  fhCaloCorrECells->Fill(sumCellEnergyEMCAL,sumCellEnergyPHOS);
-  if(GetDebug() > 0 ){
-    printf("AliAnaCalorimeterQA::CorrelateCalorimeters() - ESD: \n");
+  
+  
+  //Fill Histograms
+  fhCaloCorrNClusters->Fill(nclEMCAL,nclPHOS);
+  fhCaloCorrEClusters->Fill(sumClusterEnergyEMCAL,sumClusterEnergyPHOS);
+  fhCaloCorrNCells   ->Fill(ncellsEMCAL,ncellsPHOS);
+  fhCaloCorrECells   ->Fill(sumCellEnergyEMCAL,sumCellEnergyPHOS);
+
+  Int_t v0S = GetV0Signal(0)+GetV0Signal(1);
+  Int_t v0M = GetV0Multiplicity(0)+GetV0Multiplicity(1);
+  Int_t trM = GetTrackMultiplicity();
+  if(fCalorimeter=="PHOS"){
+    fhCaloV0MCorrNClusters   ->Fill(v0M,nclPHOS);
+    fhCaloV0MCorrEClusters   ->Fill(v0M,sumClusterEnergyPHOS);
+    fhCaloV0MCorrNCells      ->Fill(v0M,ncellsPHOS);
+    fhCaloV0MCorrECells      ->Fill(v0M,sumCellEnergyPHOS);
+
+    fhCaloV0SCorrNClusters   ->Fill(v0S,nclPHOS);
+    fhCaloV0SCorrEClusters   ->Fill(v0S,sumClusterEnergyPHOS);
+    fhCaloV0SCorrNCells      ->Fill(v0S,ncellsPHOS);
+    fhCaloV0SCorrECells      ->Fill(v0S,sumCellEnergyPHOS);
+
+    fhCaloTrackMCorrNClusters->Fill(trM,nclPHOS);
+    fhCaloTrackMCorrEClusters->Fill(trM,sumClusterEnergyPHOS);    
+    fhCaloTrackMCorrNCells   ->Fill(trM,ncellsPHOS);
+    fhCaloTrackMCorrECells   ->Fill(trM,sumCellEnergyPHOS);
+  }
+  else{
+    fhCaloV0MCorrNClusters   ->Fill(v0M,nclEMCAL);
+    fhCaloV0MCorrEClusters   ->Fill(v0M,sumClusterEnergyEMCAL);
+    fhCaloV0MCorrNCells      ->Fill(v0M,ncellsEMCAL);
+    fhCaloV0MCorrECells      ->Fill(v0M,sumCellEnergyEMCAL);
+    
+    fhCaloV0SCorrNClusters   ->Fill(v0S,nclEMCAL);
+    fhCaloV0SCorrEClusters   ->Fill(v0S,sumClusterEnergyEMCAL);
+    fhCaloV0SCorrNCells      ->Fill(v0S,ncellsEMCAL);
+    fhCaloV0SCorrECells      ->Fill(v0S,sumCellEnergyEMCAL);
+    
+    fhCaloTrackMCorrNClusters->Fill(trM,nclEMCAL);
+    fhCaloTrackMCorrEClusters->Fill(trM,sumClusterEnergyEMCAL);    
+    fhCaloTrackMCorrNCells   ->Fill(trM,ncellsEMCAL);
+    fhCaloTrackMCorrECells   ->Fill(trM,sumCellEnergyEMCAL);
+  }
+  
+  if(GetDebug() > 0 )
+  {
+    printf("AliAnaCalorimeterQA::Correlate(): \n");
     printf("\t EMCAL: N cells %d, N clusters  %d, summed E cells %f, summed E clusters %f \n",
-           cellsEMCAL->GetNumberOfCells(),caloClustersEMCAL->GetEntriesFast(),sumCellEnergyEMCAL,sumClusterEnergyEMCAL);
+           ncellsEMCAL,nclEMCAL, sumCellEnergyEMCAL,sumClusterEnergyEMCAL);
     printf("\t PHOS : N cells %d, N clusters  %d, summed E cells %f, summed E clusters %f \n",
-           cellsPHOS->GetNumberOfCells(),caloClustersPHOS->GetEntriesFast(),sumCellEnergyPHOS,sumClusterEnergyPHOS);
+           ncellsPHOS,nclPHOS,sumCellEnergyPHOS,sumClusterEnergyPHOS);
+    printf("\t V0 : Signal %d, Multiplicity  %d, Track Multiplicity %d \n", v0S,v0M,trM);
   }
 }
 
@@ -2439,11 +2503,26 @@ void AliAnaCalorimeterQA::ReadHistograms(TList* outputList)
   }
   
   
-  if(fCorrelateCalos){
+  if(fCorrelate){
     fhCaloCorrNClusters = (TH2F *) outputList->At(index++);
     fhCaloCorrEClusters = (TH2F *) outputList->At(index++); 
     fhCaloCorrNCells    = (TH2F *) outputList->At(index++); 
     fhCaloCorrECells    = (TH2F *) outputList->At(index++); 
+    
+    fhCaloV0SCorrNClusters = (TH2F *) outputList->At(index++);
+    fhCaloV0SCorrEClusters = (TH2F *) outputList->At(index++); 
+    fhCaloV0SCorrNCells    = (TH2F *) outputList->At(index++); 
+    fhCaloV0SCorrECells    = (TH2F *) outputList->At(index++); 
+    
+    fhCaloV0MCorrNClusters = (TH2F *) outputList->At(index++);
+    fhCaloV0MCorrEClusters = (TH2F *) outputList->At(index++); 
+    fhCaloV0MCorrNCells    = (TH2F *) outputList->At(index++); 
+    fhCaloV0MCorrECells    = (TH2F *) outputList->At(index++); 
+    
+    fhCaloTrackMCorrNClusters = (TH2F *) outputList->At(index++);
+    fhCaloTrackMCorrEClusters = (TH2F *) outputList->At(index++); 
+    fhCaloTrackMCorrNCells    = (TH2F *) outputList->At(index++); 
+    fhCaloTrackMCorrECells    = (TH2F *) outputList->At(index++); 
   }
   
   //Module histograms
@@ -4129,7 +4208,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
   //---------------------------------------------
   //Calorimeter Correlation, PHOS vs EMCAL
   //---------------------------------------------
-  if(fCorrelateCalos){
+  if(fCorrelate){
     
     snprintf(cname,buffersize,"QA_%s_CaloCorr_EMCALvsPHOS",fCalorimeter.Data());
     TCanvas  * ccorr = new TCanvas(cname, " EMCAL vs PHOS", 400, 400) ;
index cbe8a7a..2ac963c 100755 (executable)
@@ -62,10 +62,9 @@ public:
   void SwitchOnFillAllTH12Histogram()   {fFillAllTH12 = kTRUE  ;}
   void SwitchOffFillAllTH12Histogram()  {fFillAllTH12 = kFALSE ;}
   
-  void SwitchOnCalorimetersCorrelation()  {fCorrelateCalos = kTRUE  ;}
-  void SwitchOffCalorimetersCorrelation() {fCorrelateCalos = kFALSE ;}
-  //void CorrelateCalorimeters(TRefArray* caloClusters);
-  void CorrelateCalorimeters();
+  void SwitchOnCorrelation()  {fCorrelate = kTRUE  ;}
+  void SwitchOffCorrelation() {fCorrelate = kFALSE ;}
+  void Correlate();
   
   void Terminate(TList * outputList);
   void ReadHistograms(TList * outputList); //Fill histograms with histograms in ouput list, needed in Terminate.
@@ -227,7 +226,7 @@ public:
   TString  fStyleMacro  ;    // Location of macro for plots style
   Bool_t   fFillAllPosHisto; // Fill all the position related histograms 
   Bool_t   fFillAllTH12 ;    // Fill simple histograms which information is already in TH3 histograms
-  Bool_t   fCorrelateCalos ; // Correlate PHOS/EMCAL clusters
+  Bool_t   fCorrelate   ;    // Correlate PHOS/EMCAL cells/clusters, also with V0 and track multiplicity
   Int_t    fNModules    ;    // Number of EMCAL/PHOS modules, set as many histogras as modules 
   Int_t    fNRCU        ;    // Number of EMCAL/PHOS RCU, set as many histogras as RCU 
   Double_t fTimeCutMin  ;    // Remove clusters/cells with time smaller than this value, in ns
@@ -366,6 +365,22 @@ public:
   TH2F * fhCaloCorrNCells; // EMCAL vs PHOS, number of cells
   TH2F * fhCaloCorrECells; // EMCAL vs PHOS,  total measured cell energy
        
+  //V0 Correlation
+  TH2F * fhCaloV0SCorrNClusters; // Calo vs V0 signal , number of clusters     
+  TH2F * fhCaloV0SCorrEClusters; // Calo vs V0 signal, total measured cluster energy
+  TH2F * fhCaloV0SCorrNCells; // Calo vs V0 signal, number of cells
+  TH2F * fhCaloV0SCorrECells; // Calo vs V0 signal,  total measured cell energy
+  TH2F * fhCaloV0MCorrNClusters; // Calo vs V0 multiplicity , number of clusters       
+  TH2F * fhCaloV0MCorrEClusters; // Calo vs V0 multiplicity, total measured cluster energy
+  TH2F * fhCaloV0MCorrNCells; // Calo vs V0 multiplicity, number of cells
+  TH2F * fhCaloV0MCorrECells; // Calo vs V0 multiplicity,  total measured cell energy
+  
+  //Track Correlation
+  TH2F * fhCaloTrackMCorrNClusters; // Calo vs Track Multiplicity, number of clusters  
+  TH2F * fhCaloTrackMCorrEClusters; // Calo vs Track Multiplicity, total measured cluster energy
+  TH2F * fhCaloTrackMCorrNCells; // Calo vs V0 Track Multiplicity, number of cells
+  TH2F * fhCaloTrackMCorrECells; // Calo vs V0 Track Multipliticy,  total measured cell energy
+  
   //Module histograms
   TH1F ** fhEMod  ;               //! E distribution for different module, Reco
   TH1F ** fhNClustersMod ;        //! Number of clusters for different module, Reco
@@ -488,7 +503,7 @@ public:
   TH2F *fhMCChHad1pOverER02;    //! p/E for track-cluster matches, dR > 0.2, MC charged hadrons
   TH2F *fhMCNeutral1pOverER02;  //! p/E for track-cluster matches, dR > 0.2, MC neutral
        
-  ClassDef(AliAnaCalorimeterQA,12)
+  ClassDef(AliAnaCalorimeterQA,13)
 } ;
 
 
index 9ad0eb7..502b3e9 100644 (file)
@@ -40,7 +40,7 @@ AliAnalysisTaskParticleCorrelation *AddTaskCalorimeterQA(TString data, Bool_t kP
   reader->SwitchOnPHOSCells(); 
   reader->SwitchOnEMCAL();
   reader->SwitchOnPHOS();
-  reader->SwitchOffCTS();
+  reader->SwitchOnCTS();
   reader->SetEMCALPtMin(0.); 
   reader->SetPHOSPtMin (0.);
   reader->SetCTSPtMin  (0.);
@@ -113,11 +113,11 @@ AliAnalysisTaskParticleCorrelation *AddTaskCalorimeterQA(TString data, Bool_t kP
   //emcalQA->SetFiducialCut(fidCut);
   emcalQA->SwitchOffFiducialCut();
   emcalQA->SwitchOffPlotsMaking();
-  emcalQA->SwitchOnCalorimetersCorrelation();
+  emcalQA->SwitchOnCorrelation();
   if(!kUseKinematics)emcalQA->SetTimeCut(400,850);//Open for the moment
   //Set Histrograms bins and ranges
   emcalQA->SetHistoPtRangeAndNBins(0, 5, 50) ;
-  emcalQA->SetHistoFinePtRangeAndNBins(0, 5, 1000) ; // bining for fhAmpId
+  emcalQA->SetHistoFinePtRangeAndNBins(0, 5, 200) ; // bining for fhAmpId
   emcalQA->SetHistoPhiRangeAndNBins(79*TMath::DegToRad(), 121*TMath::DegToRad(), 100) ;
   emcalQA->SetHistoEtaRangeAndNBins(-0.71, 0.71, 200) ;
   emcalQA->SetNumberOfModules(4); //EMCAL first year
@@ -134,7 +134,9 @@ AliAnalysisTaskParticleCorrelation *AddTaskCalorimeterQA(TString data, Bool_t kP
   emcalQA->SetHistoYRangeAndNBins(370,450,40);
   emcalQA->SetHistoZRangeAndNBins(-400,400,200);
   emcalQA->SetHistoRRangeAndNBins(400,450,25);
-  
+  emcalQA->SetHistoV0SignalRangeAndNBins(0,5000,500);
+  emcalQA->SetHistoV0MultiplicityRangeAndNBins(0,5000,500);
+  emcalQA->SetHistoTrackMultiplicityRangeAndNBins(0,5000,500);
   //emcalQA->GetMCAnalysisUtils()->SetDebug(10);
        
   if(kPrintSettings) emcalQA->Print("");       
@@ -151,7 +153,7 @@ AliAnalysisTaskParticleCorrelation *AddTaskCalorimeterQA(TString data, Bool_t kP
   phosQA->SwitchOffPlotsMaking();
   //Set Histrograms bins and ranges
   phosQA->SetHistoPtRangeAndNBins(0, 5, 50) ;
-  phosQA->SetHistoFinePtRangeAndNBins(0, 5, 1000) ; // bining for fhAmpId
+  phosQA->SetHistoFinePtRangeAndNBins(0, 5, 200) ; // bining for fhAmpId
   phosQA->SetHistoPhiRangeAndNBins(259*TMath::DegToRad(), 321*TMath::DegToRad(), 130) ;
   phosQA->SetHistoEtaRangeAndNBins(-0.125, 0.125, 57) ;
   phosQA->SetNumberOfModules(3); //PHOS first year
@@ -167,7 +169,10 @@ AliAnalysisTaskParticleCorrelation *AddTaskCalorimeterQA(TString data, Bool_t kP
   phosQA->SetHistoXRangeAndNBins(-100,400,100);
   phosQA->SetHistoYRangeAndNBins(-490,-290,100);
   phosQA->SetHistoZRangeAndNBins(-80,80,100);
-  phosQA->SetHistoRRangeAndNBins(440,480,80);
+  phosQA->SetHistoRRangeAndNBins(440,480,80);  
+  phosQA->SetHistoV0SignalRangeAndNBins(0,5000,500);
+  phosQA->SetHistoV0MultiplicityRangeAndNBins(0,5000,500);
+  phosQA->SetHistoTrackMultiplicityRangeAndNBins(0,5000,500);
        
   //if(kPrintSettings)phosQA->Print("");