PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskJetV2.h

   1 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. */
   2 /* See cxx source for full Copyright notice */
   3 /* $Id$ */
   4
   5 #ifndef AliAnalysisTaskJetV2_H
   6 #define AliAnalysisTaskJetV2_H
   7
   8 #include <AliAnalysisTaskEmcalJet.h>
   9 #include <AliEmcalJet.h>
  10 #include <AliVEvent.h>
  11 #include <AliVParticle.h>
  12 #include <AliVCluster.h>
  13 #include <TClonesArray.h>
  14 #include <TMath.h>
  15 #include <TArrayD.h>
  16 #include <TRandom3.h>
  17 #include <AliJetContainer.h>
  18 #include <AliParticleContainer.h>
  19
  20 class TFile;
  21 class TF1;
  22 class TH1F;
  23 class TH2F;
  24 class TH3F;
  25 class TProfile;
  26 class AliLocalRhoParameter;
  27 class AliClusterContainer;
  28 class AliVTrack;
  29
  30 class AliAnalysisTaskJetV2 : public AliAnalysisTaskEmcalJet {
  31     public:
  32          // enumerators
  33         enum fitModulationType  { kNoFit, kV2, kV3, kCombined, kFourierSeries, kIntegratedFlow, kQC2, kQC4 }; // fit type
  34         enum fitGoodnessTest    { kChi2ROOT, kChi2Poisson, kKolmogorov, kKolmogorovTOY, kLinearFit };
  35         enum collisionType      { kPbPb, kPythia, kPbPb10h, kPbPb11h, kJetFlowMC }; // collision type, kPbPb = 11h, kept for backward compatibilitiy
  36         enum qcRecovery         { kFixedRho, kNegativeVn, kTryFit };    // how to deal with negative cn value for qcn value
  37         enum runModeType        { kLocal, kGrid };                      // run mode type
  38         enum dataType           { kESD, kAOD, kESDMC, kAODMC};          // data type
  39         enum detectorType       { kTPC, kVZEROA, kVZEROC, kVZEROComb, kFixedEP};  // detector that was used for event plane
  40         enum analysisType       { kCharged, kFull };                    // analysis type
  41         // constructors, destructor
  42                                 AliAnalysisTaskJetV2();
  43                                 AliAnalysisTaskJetV2(const char *name, runModeType type);
  44         virtual                 ~AliAnalysisTaskJetV2();
  45         // setting up the task and technical aspects
  46         void                    ExecOnce();
  47         virtual Bool_t          Notify();
  48         Bool_t                  InitializeAnalysis();
  49         virtual void            UserCreateOutputObjects();
  50         virtual void            Exec(Option_t *);
  51         virtual Bool_t          Run();
  52         TH1F*                   BookTH1F(const char* name, const char* x, Int_t bins, Double_t min, Double_t max, Int_t c = -1, Bool_t append = kTRUE);
  53         TH2F*                   BookTH2F(const char* name, const char* x, const char* y, Int_t binsx, Double_t minx, Double_t maxx, Int_t binsy, Double_t miny, Double_t maxy, Int_t c = -1, Bool_t append = kTRUE);
  54         TH3F*                   BookTH3F(const char* name, const char* x, const char* y, const char* z, Int_t binsx, Double_t minx, Double_t maxx, Int_t binsy, Double_t miny, Double_t maxy, Int_t binsz, Double_t minz, Double_t maxz, Int_t c = -1, Bool_t append = kTRUE);
  55         /* inline */    static Double_t PhaseShift(Double_t x) {
  56             while (x>=TMath::TwoPi())x-=TMath::TwoPi();
  57             while (x<0.)x+=TMath::TwoPi();
  58             return x; }
  59         /* inline */    static Double_t PhaseShift(Double_t x, Double_t n) {
  60             x = PhaseShift(x);
  61             if(TMath::Nint(n)==2) while (x>TMath::Pi()) x-=TMath::Pi();
  62             if(TMath::Nint(n)==3) {
  63                 if(x>2.*TMath::TwoPi()/n) x = TMath::TwoPi() - x;
  64                 if(x>TMath::TwoPi()/n) x = TMath::TwoPi()-(x+TMath::TwoPi()/n);
  65             }
  66             return x; }
  67         /* inline */    static Bool_t   IsInPlane(Double_t dPhi) {
  68             return (dPhi < -1.*TMath::Pi()/4. || dPhi > TMath::Pi()/4.); }
  69         /* inline */    static Double_t ChiSquarePDF(Int_t ndf, Double_t x) {
  70             Double_t n(ndf/2.), denom(TMath::Power(2, n)*TMath::Gamma(n));
  71             if (denom!=0)  return ((1./denom)*TMath::Power(x, n-1)*TMath::Exp(-x/2.));
  72             return -999; }
  73         // note that the cdf of the chisquare distribution is the normalized lower incomplete gamma function
  74         /* inline */    static Double_t ChiSquareCDF(Int_t ndf, Double_t x) { return TMath::Gamma(ndf/2., x/2.); }
  75         /* inline */    static Double_t ChiSquare(TH1& histo, TF1* func) {
  76             // evaluate the chi2 using a poissonian error estimate on bins
  77             Double_t chi2(0.);
  78             for(Int_t i(0); i < histo.GetXaxis()->GetNbins(); i++) {
  79                 if(histo.GetBinContent(i+1) <= 0.) continue;
  80                 chi2 += TMath::Power((histo.GetBinContent(i+1)-func->Eval(histo.GetXaxis()->GetBinCenter(1+i))), 2)/histo.GetBinContent(i+1);
  81             }
  82            return chi2;
  83         }
  84         /* inline */ Double_t KolmogorovTest(TH1F& histo, TF1* func) const {
  85             // return the probability from a Kolmogorov test
  86             return .5;
  87             TH1F test(histo);       // stack copy of test statistic
  88             for(Int_t i(0); i < test.GetXaxis()->GetNbins(); i++) test.SetBinContent(i+1, func->Eval(test.GetXaxis()->GetBinCenter(1+i)));
  89             if(fFitGoodnessTest == kKolmogorovTOY) return histo.TH1::KolmogorovTest((&test), "X");
  90             return histo.TH1::KolmogorovTest((&test));
  91         }
  92
  93         // setters - analysis setup
  94         void                    SetDebugMode(Int_t d)                           {fDebug = d;}
  95         void                    SetRunToyMC(Bool_t t)                           {fRunToyMC = t; }
  96         void                    SetAttachToEvent(Bool_t b)                      {fAttachToEvent = b;}
  97         void                    SetFillHistograms(Bool_t b)                     {fFillHistograms = b;}
  98         void                    SetFillQAHistograms(Bool_t qa)                  {fFillQAHistograms = qa;}
  99         void                    SetReduceBinsXYByFactor(Float_t x, Float_t y)   {fReduceBinsXByFactor = x;
 100                                                                                  fReduceBinsYByFactor = y;}
 101         void                    SetNoEventWeightsForQC(Bool_t e)                {fNoEventWeightsForQC = e;}
 102         void                    SetCentralityClasses(TArrayD* c)                {fCentralityClasses = c;}
 103         void                    SetExpectedRuns(TArrayI* r)                     {fExpectedRuns = r;}
 104         void                    SetExpectedSemiGoodRuns(TArrayI* r)             {fExpectedSemiGoodRuns = r;}
 105         void                    SetIntegratedFlow(TH1F* i, TH1F* j)             {fUserSuppliedV2 = i;
 106                                                                                  fUserSuppliedV3 = j; }
 107         void                    SetOnTheFlyResCorrection(TH1F* r2, TH1F* r3)    {fUserSuppliedR2 = r2;
 108                                                                                  fUserSuppliedR3 = r3; }
 109         void                    SetEventPlaneWeights(TH1F* ep)                  {fEventPlaneWeights = ep; }
 110         void                    SetAcceptanceWeights(Bool_t w)                  {fAcceptanceWeights = w; }
 111         void                    SetNameRhoSmall(TString name)                   {fNameSmallRho = name; }
 112         void                    SetRandomSeed(TRandom3* r)                      {if (fRandom) delete fRandom; fRandom = r; }
 113         void                    SetModulationFit(TF1* fit);
 114         void                    SetUseControlFit(Bool_t c);
 115         void                    SetModulationFitMinMaxP(Float_t m, Float_t n)   {fMinPvalue = m; fMaxPvalue = n; }
 116         void                    SetModulationFitType(fitModulationType type)    {fFitModulationType = type; }
 117         void                    SetGoodnessTest(fitGoodnessTest test)           {fFitGoodnessTest = test; }
 118         void                    SetQCnRecoveryType(qcRecovery type)             {fQCRecovery = type; }
 119         void                    SetModulationFitOptions(TString opt)            {fFitModulationOptions = opt; }
 120         void                    SetReferenceDetector(detectorType type)         {fDetectorType = type; }
 121         void                    SetAnalysisType(analysisType type)              {fAnalysisType = type; }
 122         void                    SetCollisionType(collisionType type)            {fCollisionType = type; }
 123         void                    SetUsePtWeight(Bool_t w)                        {
 124             fUsePtWeight = w;
 125             if(!fUsePtWeight) fUsePtWeightErrorPropagation = kFALSE; }
 126         void                    SetUsePtWeightErrorPropagation(Bool_t w)        {fUsePtWeightErrorPropagation = w; }
 127         void                    SetRunModeType(runModeType type)                {fRunModeType = type; }
 128         void                    SetAbsVertexZ(Float_t v)                        {fAbsVertexZ = v; }
 129         void                    SetMinDistanceRctoLJ(Float_t m)                 {fMinDisanceRCtoLJ = m; }
 130         void                    SetMaxNoRandomCones(Int_t m)                    {fMaxCones = m; }
 131         void                    SetExcludeLeadingJetsFromFit(Float_t n)         {fExcludeLeadingJetsFromFit = n; }
 132         void                    SetRebinSwapHistoOnTheFly(Bool_t r)             {fRebinSwapHistoOnTheFly = r; }
 133         void                    SetSaveThisPercentageOfFits(Float_t p)          {fPercentageOfFits = p; }
 134         // setters specific to the vzero calibration for 10h data
 135         void                    SetVZEROApol(Int_t ring, Float_t f)             {fVZEROApol[ring]=f;}
 136         void                    SetVZEROCpol(Int_t ring, Float_t f)             {fVZEROCpol[ring]=f;}
 137         void                    SetVZEROgainEqualizationPerRing(Bool_t s)       {fVZEROgainEqualizationPerRing = s;}
 138         void                    SetUseVZERORing(Int_t i, Bool_t u) {
 139             // exclude vzero rings: 0 through 7 can be excluded by calling this setter multiple times
 140             // 0 corresponds to segment ID 0 through 7, etc
 141             fUseVZERORing[i] = u;
 142             fVZEROgainEqualizationPerRing = kTRUE;       // must be true for this option
 143         }
 144
 145         void                    SetChi2VZEROA(TArrayD* a)                       { fChi2A = a;}
 146         void                    SetChi2VZEROC(TArrayD* a)                       { fChi2C = a;}
 147         void                    SetChi3VZEROA(TArrayD* a)                       { fChi3A = a;}
 148         void                    SetChi3VZEROC(TArrayD* a)                       { fChi3C = a;}
 149
 150         // getters
 151         TString                 GetJetsName() const                             {return GetJetContainer()->GetArrayName(); }
 152         TString                 GetTracksName() const                           {return GetParticleContainer()->GetArrayName(); }
 153         TString                 GetLocalRhoName() const                         {return fLocalRhoName; }
 154         TArrayD*                GetCentralityClasses() const                    {return fCentralityClasses;}
 155         TProfile*               GetResolutionParameters(Int_t h, Int_t c) const {return (h==2) ? fProfV2Resolution[c] : fProfV3Resolution[c];}
 156         TList*                  GetOutputList() const                           {return fOutputList;}
 157         AliLocalRhoParameter*   GetLocalRhoParameter() const                    {return fLocalRho;}
 158         Double_t                GetJetRadius() const                            {return GetJetContainer()->GetJetRadius();}
 159         AliEmcalJet*            GetLeadingJet(AliLocalRhoParameter* localRho = 0x0);
 160         static TH1F*            GetEventPlaneWeights(TH1F* hist);
 161         static void             PrintTriggerSummary(UInt_t trigger);
 162         void                    ExecMe()                                        {ExecOnce();}
 163         AliAnalysisTaskJetV2*   ReturnMe()                                      {return this;}
 164         // local cuts
 165         void                    SetSoftTrackMinMaxPt(Float_t min, Float_t max)          {fSoftTrackMinPt = min; fSoftTrackMaxPt = max;}
 166         void                    SetSemiGoodJetMinMaxPhi(Double_t a, Double_t b)         {fSemiGoodJetMinPhi = a; fSemiGoodJetMaxPhi = b;}
 167         void                    SetSemiGoodTrackMinMaxPhi(Double_t a, Double_t b)       {fSemiGoodTrackMinPhi = a; fSemiGoodTrackMaxPhi = b;}
 168         // numerical evaluations
 169         static void             NumericalOverlap(Double_t x1, Double_t x2, Double_t psi2, Double_t &percIn, Double_t &percOut, Double_t &percLost);
 170         static Int_t            OverlapsWithPlane(Double_t x1, Double_t x2,
 171                 Double_t a, Double_t b, Double_t c, Double_t d, Double_t e, Double_t phi);
 172         static Double_t         CalculateEventPlaneChi(Double_t res);
 173         void                    CalculateEventPlaneVZERO(Double_t vzero[2][2]) const;
 174         void                    CalculateEventPlaneCombinedVZERO(Double_t* comb) const;
 175         void                    CalculateEventPlaneTPC(Double_t* tpc);
 176         void                    CalculateEventPlaneResolution(Double_t vzero[2][2], Double_t* vzeroComb, Double_t* tpc);
 177         void                    CalculateQvectorVZERO(Double_t Qa2[2], Double_t Qc2[2], Double_t Qa3[2], Double_t Qc3[2]) const;
 178         void                    CalculateQvectorCombinedVZERO(Double_t Q2[2], Double_t Q3[2]) const;
 179         void                    CalculateRandomCone(
 180                 Float_t &pt,
 181                 Float_t &eta,
 182                 Float_t &phi,
 183                 AliParticleContainer* tracksCont,
 184                 AliClusterContainer* clusterCont = 0x0,
 185                 AliEmcalJet* jet = 0x0
 186                 ) const;
 187         Double_t                CalculateQC2(Int_t harm);
 188         Double_t                CalculateQC4(Int_t harm);
 189         // helper calculations for the q-cumulant analysis
 190         void                    QCnQnk(Int_t n, Int_t k, Double_t &reQ, Double_t &imQ);
 191         void                    QCnDiffentialFlowVectors(
 192             TClonesArray* pois, TArrayD* ptBins, Bool_t vpart, Double_t* repn, Double_t* impn,
 193             Double_t *mp, Double_t *reqn, Double_t *imqn, Double_t* mq, Int_t n);
 194         Double_t                QCnS(Int_t i, Int_t j);
 195         Double_t                QCnM();
 196         Double_t                QCnM11();
 197         Double_t                QCnM1111();
 198         Bool_t                  QCnRecovery(Double_t psi2, Double_t psi3);
 199         // analysis details
 200         Bool_t                  CorrectRho(Double_t psi2, Double_t psi3);
 201         // event and track selection
 202         /* inline */    Bool_t PassesCuts(AliVParticle* track) const    { return AcceptTrack(track, 0); }
 203         /* inline */    Bool_t PassesCuts(AliEmcalJet* jet)             { return AcceptJet(jet, 0); }
 204         /* inline */    Bool_t PassesCuts(AliVCluster* clus) const      { return AcceptCluster(clus, 0); }
 205         /* inline */    Bool_t PassesSimpleCuts(AliEmcalJet* jet)       {
 206             Float_t minPhi(GetJetContainer()->GetJetPhiMin()), maxPhi(GetJetContainer()->GetJetPhiMax());
 207             Float_t minEta(GetJetContainer()->GetJetEtaMin()), maxEta(GetJetContainer()->GetJetEtaMax());
 208             return (jet/* && jet->Pt() > 1.*/ && jet->Eta() > minEta && jet->Eta() < maxEta && jet->Phi() > minPhi && jet->Phi() < maxPhi && jet->Area() > .557*GetJetRadius()*GetJetRadius()*TMath::Pi());
 209         }
 210         Bool_t                  PassesCuts(AliVEvent* event);
 211         Bool_t                  PassesCuts(const AliVCluster* track) const;
 212         // filling histograms
 213         void                    FillHistogramsAfterSubtraction(Double_t psi2, Double_t vzero[2][2], Double_t* vzeroComb, Double_t* tpc);
 214         void                    FillQAHistograms(AliVTrack* vtrack) const;
 215         void                    FillQAHistograms(AliVEvent* vevent);
 216         void                    FillWeightedTrackHistograms() const;
 217         void                    FillWeightedClusterHistograms() const;
 218         void                    FillWeightedEventPlaneHistograms(Double_t vzero[2][2], Double_t* vzeroComb, Double_t* tpc) const;
 219         void                    FillWeightedRhoHistograms();
 220         void                    FillWeightedDeltaPtHistograms(Double_t psi2) const;
 221         void                    FillWeightedJetHistograms(Double_t psi2);
 222         void                    FillWeightedQAHistograms(AliVTrack* vtrack) const;
 223         void                    FillWeightedQAHistograms(AliVEvent* vevent);
 224         void                    FillWeightedTriggerQA(Double_t dPhi, Double_t pt, UInt_t trigger);
 225         void                    FillAnalysisSummaryHistogram() const;
 226         virtual void            Terminate(Option_t* option);
 227         // interface methods for the output file
 228         void                    SetOutputList(TList* l) {fOutputList = l;}
 229         TH1F*                   GetResolutionFromOuptutFile(detectorType detector, Int_t h = 2, TArrayD* c = 0x0);
 230         TH1F*                   CorrectForResolutionDiff(TH1F* v, detectorType detector, TArrayD* cen, Int_t c, Int_t h = 2);
 231         TH1F*                   CorrectForResolutionInt(TH1F* v, detectorType detector, TArrayD* cen, Int_t h = 2);
 232         TH1F*                   GetDifferentialQC(TProfile* refCumulants, TProfile* diffCumlants, TArrayD* ptBins, Int_t h);
 233         void                    ReadVZEROCalibration2010h();
 234         Int_t                   GetVZEROCentralityBin() const;
 235     private:
 236         // analysis flags and settings
 237         Int_t                   fDebug;                 // debug level (0 none, 1 fcn calls, 2 verbose)
 238         Bool_t                  fRunToyMC;              // run toy mc for fit routine
 239         Bool_t                  fLocalInit;             //! is the analysis initialized?
 240         Bool_t                  fAttachToEvent;         // attach local rho to the event
 241         Bool_t                  fFillHistograms;        // fill histograms
 242         Bool_t                  fFillQAHistograms;      // fill qa histograms
 243         Float_t                 fReduceBinsXByFactor;   // reduce the bins on x-axis of histo's by this much
 244         Float_t                 fReduceBinsYByFactor;   // reduce the bins on y-axis of histo's by this much
 245         Bool_t                  fNoEventWeightsForQC;   // don't store event weights for qc analysis
 246         TArrayD*                fCentralityClasses;     //-> centrality classes (maximum 10)
 247         TArrayI*                fExpectedRuns;          //-> array of expected run numbers, used for QA
 248         TArrayI*                fExpectedSemiGoodRuns;  //-> array of expected semi-good runs, used for cuts and QA
 249         TH1F*                   fUserSuppliedV2;        // histo with integrated v2
 250         TH1F*                   fUserSuppliedV3;        // histo with integrated v3
 251         TH1F*                   fUserSuppliedR2;        // correct the extracted v2 with this r
 252         TH1F*                   fUserSuppliedR3;        // correct the extracted v3 with this r
 253         TH1F*                   fEventPlaneWeights;     // weight histo for the event plane
 254         Bool_t                  fAcceptanceWeights;     // store centrality dependent acceptance weights
 255         Float_t                 fEventPlaneWeight;      //! the actual weight of an event
 256         AliParticleContainer*   fTracksCont;            //! tracks
 257         AliClusterContainer*    fClusterCont;           //! cluster container
 258         AliJetContainer*        fJetsCont;              //! jets
 259         AliEmcalJet*            fLeadingJet;            //! leading jet
 260         AliEmcalJet*            fLeadingJetAfterSub;    //! leading jet after background subtraction
 261         // members
 262         Int_t                   fNAcceptedTracks;       //! number of accepted tracks
 263         Int_t                   fNAcceptedTracksQCn;    //! accepted tracks for QCn
 264         fitModulationType       fFitModulationType;     // fit modulation type
 265         fitGoodnessTest         fFitGoodnessTest;       // fit goodness test type
 266         qcRecovery              fQCRecovery;            // recovery type for e-by-e qc method
 267         Bool_t                  fUsePtWeight;           // use dptdphi instead of dndphi
 268         Bool_t                  fUsePtWeightErrorPropagation;   // recalculate the bin errors in case of pt weighting
 269         detectorType            fDetectorType;          // type of detector used for modulation fit
 270         analysisType            fAnalysisType;          // analysis type (full or charged jets)
 271         TString                 fFitModulationOptions;  // fit options for modulation fit
 272         runModeType             fRunModeType;           // run mode type
 273         dataType                fDataType;              // datatype
 274         collisionType           fCollisionType;         // collision type
 275         TRandom3*               fRandom;                //-> dont use gRandom to not interfere with other tasks
 276         Int_t                   fRunNumber;             //! current runnumber (for QA and jet, track selection)
 277         Int_t                   fMappedRunNumber;       //! mapped runnumer (for QA)
 278         Int_t                   fInCentralitySelection; //! centrality bin
 279         TF1*                    fFitModulation;         //-> modulation fit for rho
 280         TF1*                    fFitControl;            //-> control fit
 281         Float_t                 fMinPvalue;             // minimum value of p
 282         Float_t                 fMaxPvalue;             // maximum value of p
 283         TString                 fNameSmallRho;          // name of small rho
 284         AliRhoParameter*        fCachedRho;             //! temp cache for rho pointer
 285         // additional jet cuts (most are inherited)
 286         Float_t                 fSoftTrackMinPt;        // min pt for soft tracks
 287         Float_t                 fSoftTrackMaxPt;        // max pt for soft tracks
 288         Double_t                fSemiGoodJetMinPhi;     // min phi for semi good tpc runs
 289         Double_t                fSemiGoodJetMaxPhi;     // max phi for semi good tpc runs
 290         Double_t                fSemiGoodTrackMinPhi;   // min phi for semi good tpc runs
 291         Double_t                fSemiGoodTrackMaxPhi;   // max phi for semi good tpc runs
 292         // event cuts
 293         Float_t                 fAbsVertexZ;            // cut on zvertex
 294         // general qa histograms
 295         TH1F*                   fHistCentrality;        //! accepted centrality
 296         TProfile*               fHistCentralityPercIn;  //! centrality versus perc in
 297         TProfile*               fHistCentralityPercOut; //! centrality versus perc out
 298         TProfile*               fHistCentralityPercLost;//! centrality versus perc lost
 299         TH1F*                   fHistVertexz;           //! accepted verte
 300         TH2F*                   fHistRunnumbersPhi;     //! run numbers averaged phi
 301         TH2F*                   fHistRunnumbersEta;     //! run numbers averaged eta
 302         TH1F*                   fHistPvalueCDFROOT;     //! pdf value of chisquare p
 303         TH2F*                   fHistPvalueCDFROOTCent; //! p value versus centrlaity from root
 304         TH2F*                   fHistChi2ROOTCent;      //! reduced chi2 from ROOT, centrality correlation
 305         TH2F*                   fHistPChi2Root;         //! correlation p value and reduced chi2
 306         TH1F*                   fHistPvalueCDF;         //! cdf value of chisquare p
 307         TH2F*                   fHistPvalueCDFCent;     //! p value vs centrality
 308         TH2F*                   fHistChi2Cent;          //! reduced chi2, centrlaity correlation
 309         TH2F*                   fHistPChi2;             //! correlation p value and reduced chi2
 310         TH1F*                   fHistKolmogorovTest;    //! KolmogorovTest value
 311         TH2F*                   fHistKolmogorovTestCent;//! KolmogorovTest value, centrality correlation
 312         TH2F*                   fHistPKolmogorov;       //! p value vs kolmogorov value
 313         TH2F*                   fHistRhoStatusCent;     //! status of rho as function of centrality
 314         TH1F*                   fHistUndeterminedRunQA; //! undetermined run QA
 315         // general settings
 316         Float_t                 fMinDisanceRCtoLJ;      // min distance between rc and leading jet
 317         Int_t                   fMaxCones;              // max number of random cones
 318         Float_t                 fExcludeLeadingJetsFromFit;    // exclude n leading jets from fit
 319         Bool_t                  fRebinSwapHistoOnTheFly;       // rebin swap histo on the fly
 320         Float_t                 fPercentageOfFits;      // save this percentage of fits
 321         // transient object pointers
 322         TList*                  fOutputList;            //! output list
 323         TList*                  fOutputListGood;        //! output list for local analysis
 324         TList*                  fOutputListBad;         //! output list for local analysis
 325         TH1F*                   fHistAnalysisSummary;   //! analysis summary
 326         TH1F*                   fHistSwap;              //! swap histogram
 327         TProfile*               fProfV2;                //! extracted v2
 328         TProfile*               fProfV2Cumulant;        //! v2 cumulant
 329         TProfile*               fProfV2Resolution[10];  //! resolution parameters for v2
 330         TProfile*               fProfV3;                //! extracted v3
 331         TProfile*               fProfV3Cumulant;        //! v3 cumulant
 332         TProfile*               fProfV3Resolution[10];  //! resolution parameters for v3
 333         // qa histograms for accepted pico tracks
 334         TH1F*                   fHistPicoTrackPt[10];   //! pt of all charged tracks
 335         TH1F*                   fHistPicoTrackMult[10]; //! multiplicity of accepted pico tracks
 336         TH2F*                   fHistPicoCat1[10];      //! pico tracks spd hit and refit
 337         TH2F*                   fHistPicoCat2[10];      //! pico tracks wo spd hit w refit, constrained
 338         TH2F*                   fHistPicoCat3[10];      //! pico tracks wo spd hit wo refit, constrained
 339         // qa histograms for accepted emcal clusters
 340         TH1F*                   fHistClusterPt[10];     //! pt emcal clusters
 341         TH2F*                   fHistClusterEtaPhi[10]; //! eta phi emcal clusters
 342         TH2F*                   fHistClusterEtaPhiWeighted[10]; //! eta phi emcal clusters, pt weighted
 343         // qa histograms for triggers
 344         TH2F*                   fHistTriggerQAIn[10];   //! trigger qa in plane
 345         TH2F*                   fHistTriggerQAOut[10];  //! trigger qa out of plane
 346         // qa event planes
 347         TProfile*               fHistPsiControl;        //! event plane control histogram
 348         TProfile*               fHistPsiSpread;         //! event plane spread histogram
 349         TH1F*                   fHistPsiVZEROA;         //! psi 2 from vzero a
 350         TH1F*                   fHistPsiVZEROC;         //! psi 2 from vzero c
 351         TH1F*                   fHistPsiVZERO;          //! psi 2 from combined vzero
 352         TH1F*                   fHistPsiTPC;            //! psi 2 from tpc
 353         TH2F*                   fHistPsiVZEROAV0M;      //! psi 2 from vzero a
 354         TH2F*                   fHistPsiVZEROCV0M;      //! psi 2 from vzero c
 355         TH2F*                   fHistPsiVZEROVV0M;      //! psi 2 from combined vzero
 356         TH2F*                   fHistPsiTPCV0M;         //! psi 2 from tpc
 357         TH2F*                   fHistPsiVZEROATRK;      //! psi 2 from vzero a
 358         TH2F*                   fHistPsiVZEROCTRK;      //! psi 2 from vzero c
 359         TH2F*                   fHistPsiVZEROTRK;       //! psi 2 from combined vzero
 360         TH2F*                   fHistPsiTPCTRK;         //! psi 2 from tpc
 361         TH3F*                   fHistPsiTPCLeadingJet[10];      //! correlation tpc EP, LJ pt
 362         TH3F*                   fHistPsiVZEROALeadingJet[10];   //! correlation vzeroa EP, LJ pt
 363         TH3F*                   fHistPsiVZEROCLeadingJet[10];   //! correlation vzeroc EP, LJ pt
 364         TH3F*                   fHistPsiVZEROCombLeadingJet[10];//! correlation vzerocomb EP, LJ pt
 365         TH3F*                   fHistPsi2Correlation[10];       //! correlation of event planes
 366         TH2F*                   fHistLeadingJetBackground[10];  //! geometric correlation of leading jet w/wo bkg subtraction
 367         // background
 368         TH1F*                   fHistRhoPackage[10];    //! rho as estimated by emcal jet package
 369         TH1F*                   fHistRho[10];           //! background
 370         TH2F*                   fHistRhoVsMult;         //! rho versus multiplicity
 371         TH2F*                   fHistRhoVsCent;         //! rho veruss centrality
 372         TH2F*                   fHistRhoAVsMult;        //! rho * A vs multiplicity for all jets
 373         TH2F*                   fHistRhoAVsCent;        //! rho * A vs centrality for all jets
 374         // delta pt distributions
 375         TH2F*                   fHistRCPhiEta[10];              //! random cone eta and phi
 376         TH2F*                   fHistRhoVsRCPt[10];             //! rho * A vs rcpt
 377         TH1F*                   fHistRCPt[10];                  //! rcpt
 378         TH2F*                   fHistDeltaPtDeltaPhi2[10];      //! dpt vs dphi (psi2 - phi)
 379         TH2F*                   fHistDeltaPtDeltaPhi2Rho0[10];  //! dpt vs dphi, rho_0
 380         TH2F*                   fHistRCPhiEtaExLJ[10];          //! random cone eta and phi, excl leading jet
 381         TH2F*                   fHistRhoVsRCPtExLJ[10];         //! rho * A vs rcpt, excl leading jet
 382         TH1F*                   fHistRCPtExLJ[10];              //! rcpt, excl leading jet
 383         TH2F*                   fHistDeltaPtDeltaPhi2ExLJ[10];  //! dpt vs dphi, excl leading jet
 384         TH2F*                   fHistDeltaPtDeltaPhi2ExLJRho0[10];      //! dpt vs dphi, excl leading jet, rho_0
 385         // jet histograms (after kinematic cuts)
 386         TH1F*                   fHistJetPtRaw[10];              //! jet pt - no background subtraction
 387         TH1F*                   fHistJetPt[10];                 //! pt of found jets (background subtracted)
 388         TH2F*                   fHistJetEtaPhi[10];             //! eta and phi correlation
 389         TH2F*                   fHistJetPtArea[10];             //! jet pt versus area
 390         TH2F*                   fHistJetPtEta[10];              //! jet pt versus eta (temp control)
 391         TH2F*                   fHistJetPtConstituents[10];     //! jet pt versus number of constituents
 392         TH2F*                   fHistJetEtaRho[10];             //! jet eta versus rho
 393         // in plane, out of plane jet spectra
 394         TH2F*                   fHistJetPsi2Pt[10];             //! event plane dependence of jet pt
 395         TH2F*                   fHistJetPsi2PtRho0[10];         //! event plane dependence of jet pt vs rho_0
 396         // vzero event plane calibration cache for 10h data
 397         Float_t                 fMeanQ[9][2][2];                //! recentering
 398         Float_t                 fWidthQ[9][2][2];               //! recentering
 399         Float_t                 fMeanQv3[9][2][2];              //! recentering
 400         Float_t                 fWidthQv3[9][2][2];             //! recentering
 401         TH1*                    fVZEROgainEqualization;         //! equalization histo
 402         Bool_t                  fVZEROgainEqualizationPerRing;  // per ring vzero gain calibration
 403         Float_t                 fVZEROApol[4];                  //! calibration info per ring
 404         Float_t                 fVZEROCpol[4];                  //! calibration info per ring
 405         Bool_t                  fUseVZERORing[8];               // kTRUE means the ring is included
 406         TArrayD*                fChi2A;                         // chi vs cent for vzero A ep_2
 407         TArrayD*                fChi2C;                         // chi vs cent for vzero C ep_2
 408         TArrayD*                fChi3A;                         // chi vs cent for vzero A ep_3
 409         TArrayD*                fChi3C;                         // chi vs cent for vzero C ep_3
 410         TFile*                  fOADB;                          //! fOADB
 411
 412
 413         AliAnalysisTaskJetV2(const AliAnalysisTaskJetV2&);                  // not implemented
 414         AliAnalysisTaskJetV2& operator=(const AliAnalysisTaskJetV2&);       // not implemented
 415
 416         ClassDef(AliAnalysisTaskJetV2, 4);
 417 };
 418
 419 #endif