PWGGA/PHOSTasks/PHOS_PbPb/AliAnalysisTaskPi0Flow.h

   1 #ifndef AliAnalysisTaskPi0Flow_cxx
   2 #define AliAnalysisTaskPi0Flow_cxx
   3
   4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  * See cxx source for full Copyright notice                               */
   6
   7 // Analysis task to fill histograms with PHOS ESD or AOD clusters and cells
   8 // Authors : Dmitri Peressounko
   9 // Date    : 28.05.2011
  10 // Modified: 03.08.2012 Henrik Qvigstad
  11 /* $Id$ */
  12
  13 class TObjArray;
  14 class TH1F;
  15 class TH2I;
  16 class TH2F;
  17 class TH3F;
  18 class TF1 ;
  19 class AliStack ;
  20 class AliESDtrackCuts;
  21 class AliPHOSGeometry;
  22 class AliESDEvent ;
  23 class AliPHOSCalibData;
  24 class AliESDtrack ;
  25 class AliESDCaloCluster ;
  26 class AliEPFlattener;
  27
  28 #include "TArrayD.h"
  29
  30 #include "AliAnalysisTaskSE.h"
  31
  32 class AliAnalysisTaskPi0Flow : public AliAnalysisTaskSE {
  33 public:
  34     enum Period { kUndefinedPeriod, kLHC10h, kLHC11h };
  35
  36 public:
  37     AliAnalysisTaskPi0Flow(const char *name = "AliAnalysisTaskPi0Flow", Period period = kUndefinedPeriod);
  38     virtual ~AliAnalysisTaskPi0Flow();
  39
  40     virtual void   UserCreateOutputObjects();
  41     virtual void   UserExec(Option_t *option);
  42     /* virtual void   Terminate(Option_t *); */
  43
  44     void SetPeriod(Period period) { fPeriod = period;}
  45
  46     void SetCentralityBinning(const TArrayD& edges, const TArrayI& nMixed);
  47     void SetEventMixingRPBinning(UInt_t nBins) { fNEMRPBins = nBins; }
  48     void SetMaxAbsVertexZ(Float_t z) { fMaxAbsVertexZ = z; }
  49     void SetManualV0EPCalc(Bool_t manCalc = true) {fManualV0EPCalc = manCalc;}
  50
  51     void SetPHOSBadMap(Int_t mod,TH2I * badMapHist);
  52     //Where to read AODB object with EP calibration if not default
  53     void SetEPcalibFileName(const TString filename) {fEPcalibFileName = filename; }
  54
  55 private:
  56     AliAnalysisTaskPi0Flow(const AliAnalysisTaskPi0Flow&); // not implemented
  57     AliAnalysisTaskPi0Flow& operator=(const AliAnalysisTaskPi0Flow&); // not implemented
  58
  59     // Step 0:
  60     AliVEvent* GetEvent();
  61     AliStack* GetMCStack();
  62
  63     // Step 1:
  64     void SetGeometry();
  65     void SetMisalignment();
  66     void SetV0Calibration(); //V0 calibration
  67     void SetESDTrackCuts(); // AliESDtrack cuts ( for esd data )
  68     void SetPHOSCalibData(); // phos re-calibration ( for esd data)
  69     void SetFlatteningData(); // phos flattening
  70
  71     // Step 2:
  72     void SetVertex();
  73     Bool_t RejectEventVertex();
  74
  75     // Step 4:
  76     void SetCentrality();
  77     Bool_t RejectCentrality();
  78
  79     // Step 5:
  80     void EvalReactionPlane();
  81     void EvalV0ReactionPlane();
  82
  83     // Step 7: QA PHOS cells
  84     void FillPHOSCellQAHists();
  85
  86     // Step 8: Event Photons (PHOS Clusters) selection
  87     void SelectPhotonClusters();
  88     void FillSelectedClusterHistograms();
  89
  90     // Step 9: Consider pi0 (photon/cluster) pairs.
  91     void ConsiderPi0s();
  92
  93     // Step 10; Mixing
  94     void ConsiderPi0sMix();
  95
  96     // Step 11: Update lists
  97     void UpdateLists();
  98
  99     Bool_t AreNeibors(Int_t id1,Int_t id2) ;
 100     Double_t ApplyFlattening(Double_t phi, Double_t c) ; //Apply centrality-dependent flattening
 101     Double_t ApplyFlatteningV0A(Double_t phi, Double_t c) ; //Apply centrality-dependent flattening
 102     Double_t ApplyFlatteningV0C(Double_t phi, Double_t c) ; //Apply centrality-dependent flattening
 103     Int_t ConvertToInternalRunNumber(Int_t run) ;
 104     Double_t CoreEnergy(AliVCluster * clu, AliVCaloCells * cells);
 105     void EvalCoreLambdas(AliVCluster * clu, AliVCaloCells * cells, Double_t &m02, Double_t &m20) ;
 106     Bool_t TestCoreLambda(Double_t pt,Double_t l1,Double_t l2) ;
 107
 108
 109
 110
 111     void FillHistogram(const char * key,Double_t x) const ; //Fill 1D histogram witn name key
 112     void FillHistogram(const char * key,Double_t x, Double_t y) const ; //Fill 2D histogram witn name key
 113     void FillHistogram(const char * key,Double_t x, Double_t y, Double_t z) const ; //Fill 3D histogram witn name key
 114
 115     TVector3 GetVertexVector(const AliVVertex* vertex);
 116     Int_t GetCentralityBin(Float_t centralityV0M);
 117     Int_t GetRPBin();
 118
 119     void LogProgress(int step);
 120     void LogSelection(int step, int internalRunNumber);
 121
 122     Bool_t IsGoodChannel(const char * det, Int_t mod,Int_t ix, Int_t iz); //Use addisional bad map for PHOS
 123
 124
 125     void Reclusterize(AliVCluster * clu) ;
 126     Double_t TestCPV(Double_t dx, Double_t dz, Double_t pt, Int_t charge);
 127     Bool_t TestLambda(Double_t pt,Double_t l1,Double_t l2) ;  //Evaluate Dispersion cuts for photons
 128     Bool_t TestLambda2(Double_t pt,Double_t l1,Double_t l2) ;  //Evaluate Dispersion cuts for photons
 129
 130     UInt_t GetNumberOfCentralityBins() { return fCentEdges.GetSize()-1; }
 131     TList* GetCaloPhotonsPHOSList(UInt_t vtxBin, UInt_t centBin, UInt_t rpBin);
 132
 133
 134
 135
 136 private:
 137     // constants:
 138     static const Double_t kLogWeight= 4.5 ; // log weight for recalibration.
 139     static const Double_t kAlphaCut=0.7 ;
 140     static const Bool_t doESDReCalibration = kTRUE;
 141     static const Int_t kNCenBins = 9; // see EvalV0ReactionPlane()
 142
 143     // cluster cut variables:
 144     static const Double_t kMinClusterEnergy = 0.3;
 145     static const Double_t kMinBCDistance = 2.5;  //distance to nearest bad channel
 146     static const Int_t kMinNCells = 3;
 147     static const Double_t kMinM02 = 0.2;
 148
 149     // Binning, [vtx, centrality, reaction-plane]
 150     static const Int_t kNVtxZBins = 1;
 151     static const Double_t kCentCutoff = 90.; // Ignore Centrality over 90%
 152     TArrayD fCentEdges;  // Centrality Bin Lower edges
 153     TArrayI fCentNMixed; // Number of mixed events for each centrality bin
 154     UInt_t fNEMRPBins;
 155
 156
 157     // Behavior / cuts
 158     Period fPeriod;
 159     Float_t fMaxAbsVertexZ; // in cm
 160     Bool_t fManualV0EPCalc;
 161
 162
 163     TList * fOutputContainer;        //final histogram container
 164
 165     TF1 *fNonLinCorr;          // Non-linearity correction
 166 //TF1 * fRecent[5][12] ;//Recentering corrections
 167     TH2I *fPHOSBadMap[6] ;    //Container for PHOS bad channels map
 168
 169     // Run variables
 170
 171     // Step 0: Event Objects
 172     // fEvent, fMCStack
 173     AliVEvent* fEvent; //! Current event
 174     AliESDEvent* fEventESD; //! Current event, if ESD.
 175     AliAODEvent* fEventAOD; //! Current event, if AOD.
 176     AliStack * fMCStack ;
 177
 178     // Step 1: Run Number, Misalignment Matrix, and Calibration
 179     Int_t fRunNumber; // run number
 180     Int_t fInternalRunNumber ;    //Current internal run number
 181     AliPHOSGeometry  *fPHOSGeo;  //! PHOS geometry
 182     TProfile *fMultV0;                  // object containing VZERO calibration information
 183     Float_t fV0Cpol,fV0Apol;            // loaded by OADB
 184     Float_t fMeanQ[kNCenBins][2][2];    // and recentering
 185     Float_t fWidthQ[kNCenBins][2][2];   // ...
 186     AliESDtrackCuts *fESDtrackCuts; // Track cut
 187     AliPHOSCalibData *fPHOSCalibData; // PHOS calibration object
 188     TString fEPcalibFileName;
 189     AliEPFlattener * fTPCFlat ; //Object for flattening of TPC
 190     AliEPFlattener * fV0AFlat ; //Object for flattening of V0A
 191     AliEPFlattener * fV0CFlat ; //Object for flattening of V0C
 192
 193
 194     // Step 2: Vertex
 195     Double_t fVertex[3];
 196     TVector3 fVertexVector;
 197     Int_t fVtxBin;
 198
 199     // Step 4: Centrality
 200     Float_t fCentralityV0M ; //!Centrality of the currecnt event
 201     Int_t fCentBin ;       //! Current centrality bin
 202
 203     // Step 5: Reaction Plane
 204     Bool_t fHaveTPCRP ; //! Is TPC RP defined?
 205     Float_t fRP ;       //!Reaction plane calculated with full TPC
 206     Float_t fRPV0A ;    //!Reaction plain calculated with A-side TPC: eta>0.15
 207     Float_t fRPV0C ;    //!Reaction plain calculated with C-side TPC: eta<-0.15
 208     Int_t fEMRPBin;       //! Event Mixing Reaction Plane Bin
 209
 210     // Step 8: Event Photons (PHOS Clusters) selection
 211     TObjArray * fCaloPhotonsPHOS ;      //PHOS photons in current event
 212
 213     // Step 11: Update lists for mixing.
 214     TObjArray* fCaloPhotonsPHOSLists; //! array of TList, Containers for events with PHOS photons
 215
 216
 217     ClassDef(AliAnalysisTaskPi0Flow, 1); // PHOS analysis task
 218 };
 219
 220 #endif