PWGJE/EMCALJetTasks/UserTasks/AliAnalysisTaskRhoVnModulation.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 ALIANALYSISTASKRHOVNMODULATION_H
   6 #define ALIANALYSISTASKRHOVNMODULATION_H
   7
   8 #include <AliAnalysisTaskEmcalJet.h>
   9 #include <AliEmcalJet.h>
  10 #include <AliVEvent.h>
  11 #include <AliVTrack.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 TF1;
  21 class THF1;
  22 class THF2;
  23 class TProfile;
  24 class AliLocalRhoParameter;
  25
  26 class AliAnalysisTaskRhoVnModulation : public AliAnalysisTaskEmcalJet {
  27     public:
  28          // enumerators
  29         enum fitModulationType  { kNoFit, kV2, kV3, kCombined, kFourierSeries, kIntegratedFlow, kQC2, kQC4 }; // fit type
  30         enum fitGoodnessTest    { kChi2ROOT, kChi2Poisson, kKolmogorov, kKolmogorovTOY, kLinearFit };
  31         enum collisionType      { kPbPb, kPythia };                     // collision type
  32         enum qcRecovery         { kFixedRho, kNegativeVn, kTryFit };    // how to deal with negative cn value for qcn value
  33         enum runModeType        { kLocal, kGrid };                      // run mode type
  34         enum dataType           { kESD, kAOD, kESDMC, kAODMC };         // data type
  35         enum detectorType       { kTPC, kVZEROA, kVZEROC, kVZEROComb};  // detector that was used
  36         // constructors, destructor
  37                                 AliAnalysisTaskRhoVnModulation();
  38                                 AliAnalysisTaskRhoVnModulation(const char *name, runModeType type);
  39         virtual                 ~AliAnalysisTaskRhoVnModulation();
  40         // setting up the task and technical aspects
  41         void                    ExecOnce();
  42         Bool_t                  InitializeAnalysis();
  43         virtual void            UserCreateOutputObjects();
  44         virtual Bool_t          Run();
  45         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);
  46         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);
  47         /* inline */    Double_t PhaseShift(Double_t x) const {
  48             while (x>=TMath::TwoPi())x-=TMath::TwoPi();
  49             while (x<0.)x+=TMath::TwoPi();
  50             return x; }
  51         /* inline */    Double_t PhaseShift(Double_t x, Double_t n) const {
  52             x = PhaseShift(x);
  53             if(TMath::Nint(n)==2) while (x>TMath::Pi()) x-=TMath::Pi();
  54             if(TMath::Nint(n)==3) {
  55                 if(x>2.*TMath::TwoPi()/n) x = TMath::TwoPi() - x;
  56                 if(x>TMath::TwoPi()/n) x = TMath::TwoPi()-(x+TMath::TwoPi()/n);
  57             }
  58             return x; }
  59         /* inline */    Double_t ChiSquarePDF(Int_t ndf, Double_t x) const {
  60             Double_t n(ndf/2.), denom(TMath::Power(2, n)*TMath::Gamma(n));
  61             if (denom!=0)  return ((1./denom)*TMath::Power(x, n-1)*TMath::Exp(-x/2.));
  62             return -999; }
  63         // note that the cdf of the chisquare distribution is the normalized lower incomplete gamma function
  64         /* inline */    Double_t ChiSquareCDF(Int_t ndf, Double_t x) const { return TMath::Gamma(ndf/2., x/2.); }
  65         /* inline */    Double_t ChiSquare(TH1& histo, TF1* func) const {
  66             // evaluate the chi2 using a poissonian error estimate on bins
  67             Double_t chi2(0.);
  68             for(Int_t i(0); i < histo.GetXaxis()->GetNbins(); i++) {
  69                 if(histo.GetBinContent(i+1) <= 0.) continue;
  70                 chi2 += TMath::Power((histo.GetBinContent(i+1)-func->Eval(histo.GetXaxis()->GetBinCenter(1+i))), 2)/histo.GetBinContent(i+1);
  71             }
  72            return chi2;
  73         }
  74         /* inline*/ Double_t KolmogorovTest(TH1F& histo, TF1* func) const {
  75             // return the probability from a Kolmogorov test
  76             TH1F test(histo);       // stack copy of test statistic
  77             for(Int_t i(0); i < test.GetXaxis()->GetNbins(); i++) test.SetBinContent(i+1, func->Eval(test.GetXaxis()->GetBinCenter(1+i)));
  78             if(fFitGoodnessTest == kKolmogorovTOY) return histo.TH1::KolmogorovTest((&test), "X");
  79             return histo.TH1::KolmogorovTest((&test));
  80         }
  81
  82         // setters - analysis setup
  83         void                    SetDebugMode(Int_t d)                           {fDebug = d;}
  84         void                    SetRunToyMC(Bool_t t)                           {fRunToyMC = t; }
  85         void                    SetAttachToEvent(Bool_t b)                      {fAttachToEvent = b;}
  86         void                    SetSemiCentralInclusive(Bool_t b)               {fSemiCentralInclusive = b;}
  87         void                    SetFillHistograms(Bool_t b)                     {fFillHistograms = b;}
  88         void                    SetFillQAHistograms(Bool_t qa)                  {fFillQAHistograms = qa;}
  89         void                    SetReduceBinsXYByFactor(Float_t x, Float_t y)   {fReduceBinsXByFactor = x;
  90                                                                                  fReduceBinsYByFactor = y;}
  91         void                    SetNoEventWeightsForQC(Bool_t e)                {fNoEventWeightsForQC = e;}
  92         void                    SetCentralityClasses(TArrayD* c)                {fCentralityClasses = c;}
  93         void                    SetPtBinsHybrids(TArrayD* p)                    {fPtBinsHybrids = p;}
  94         void                    SetPtBinsJets(TArrayD* p)                       {fPtBinsJets = p;}
  95         void                    SetIntegratedFlow(TH1F* i, TH1F* j)             {fUserSuppliedV2 = i;
  96                                                                                  fUserSuppliedV3 = j; }
  97         void                    SetOnTheFlyResCorrection(TH1F* r2, TH1F* r3)    {fUserSuppliedR2 = r2;
  98                                                                                  fUserSuppliedR3 = r3; }
  99         void                    SetNameJetClones(const char* name)              {fNameJetClones = name; }
 100         void                    SetNamePicoTrackClones(const char* name)        {fNamePicoTrackClones = name; }
 101         void                    SetNameRho(const char* name)                    {fNameRho = name; }
 102         void                    SetNameRhoSmall(TString name)                   {fNameSmallRho = name; }
 103         void                    SetUseScaledRho(Bool_t s)                       {fUseScaledRho = s; }
 104         void                    SetRandomSeed(TRandom3* r)                      {if (fRandom) delete fRandom; fRandom = r; }
 105         void                    SetModulationFit(TF1* fit);
 106         void                    SetUseControlFit(Bool_t c);
 107         void                    SetModulationFitMinMaxP(Float_t m, Float_t n)   {fMinPvalue = m; fMaxPvalue = n; }
 108         void                    SetModulationFitType(fitModulationType type)    {fFitModulationType = type; }
 109         void                    SetGoodnessTest(fitGoodnessTest test)           {fFitGoodnessTest = test; }
 110         void                    SetQCnRecoveryType(qcRecovery type)             {fQCRecovery = type; }
 111         void                    SetModulationFitOptions(TString opt)            {fFitModulationOptions = opt; }
 112         void                    SetReferenceDetector(detectorType type)         {fDetectorType = type; }
 113         void                    SetCollisionType(collisionType type)            {fCollisionType = type; }
 114         void                    SetUsePtWeight(Bool_t w)                        {
 115             fUsePtWeight = w;
 116             if(!fUsePtWeight) fUsePtWeightErrorPropagation = kFALSE; }
 117         void                    SetUsePtWeightErrorPropagation(Bool_t w)        {fUsePtWeightErrorPropagation = w; }
 118         void                    SetRunModeType(runModeType type)                {fRunModeType = type; }
 119         void                    SetAbsVertexZ(Float_t v)                        {fAbsVertexZ = v; }
 120         void                    SetMinDistanceRctoLJ(Float_t m)                 {fMinDisanceRCtoLJ = m; }
 121         void                    SetRandomConeRadius(Float_t r)                  {fRandomConeRadius = r; }
 122         void                    SetMaxNoRandomCones(Int_t m)                    {fMaxCones = m; }
 123         void                    SetMinLeadingHadronPt(Double_t m)               {fMinLeadingHadronPt = m; }
 124         void                    SetSetPtSub(Bool_t s)                           {fSubtractJetPt = s;}
 125         void                    SetForceAbsVnHarmonics(Bool_t f)                {fAbsVnHarmonics = f; }
 126         void                    SetExcludeLeadingJetsFromFit(Float_t n)         {fExcludeLeadingJetsFromFit = n; }
 127         void                    SetRebinSwapHistoOnTheFly(Bool_t r)             {fRebinSwapHistoOnTheFly = r; }
 128         void                    SetSaveThisPercentageOfFits(Float_t p)          {fPercentageOfFits = p; }
 129         void                    SetUseV0EventPlaneFromHeader(Bool_t h)          {fUseV0EventPlaneFromHeader = h;}
 130         void                    SetExplicitOutlierCutForYear(Int_t y)           {fExplicitOutlierCut = y;}
 131         // getters - these are used as well by AliAnalyisTaskJetFlow, so be careful when changing them
 132         TString                 GetJetsName() const                             {return GetJetContainer()->GetArrayName(); }
 133         TString                 GetTracksName() const                           {return GetParticleContainer()->GetArrayName(); }
 134         TString                 GetLocalRhoName() const                         {return fLocalRhoName; }
 135         TArrayD*                GetCentralityClasses() const                    {return fCentralityClasses;}
 136         TArrayD*                GetPtBinsHybrids() const                        {return fPtBinsHybrids; }
 137         TArrayD*                GetPtBinsJets() const                           {return fPtBinsJets; }
 138         TProfile*               GetResolutionParameters(Int_t h, Int_t c) const {return (h==2) ? fProfV2Resolution[c] : fProfV3Resolution[c];}
 139         TList*                  GetOutputList() const                           {return fOutputList;}
 140         AliLocalRhoParameter*   GetLocalRhoParameter() const                    {return fLocalRho;}
 141         Double_t                GetJetRadius() const                            {return GetJetContainer()->GetJetRadius();}
 142         /* inline */    AliEmcalJet* GetLeadingJet() {
 143             // return pointer to the highest pt jet (before background subtraction) within acceptance
 144             // only rudimentary cuts are applied on this level, hence the implementation outside of
 145             // the framework
 146             Int_t iJets(fJets->GetEntriesFast());
 147             Double_t pt(0);
 148             AliEmcalJet* leadingJet(0x0);
 149             for(Int_t i(0); i < iJets; i++) {
 150                 AliEmcalJet* jet = static_cast<AliEmcalJet*>(fJets->At(i));
 151                 if(!PassesSimpleCuts(jet)) continue;
 152                 if(jet->Pt() > pt) {
 153                    leadingJet = jet;
 154                    pt = leadingJet->Pt();
 155                 }
 156             }
 157             return leadingJet;
 158         }
 159         void                    ExecMe()                                        {ExecOnce();}
 160         AliAnalysisTaskRhoVnModulation* ReturnMe()                              {return this;}
 161         // local cuts
 162         void                    SetLocalJetMinMaxEta(Float_t min, Float_t max)  {fLocalJetMinEta = min; fLocalJetMaxEta = max;}
 163         void                    SetLocalJetMinMaxEta(Float_t R)                 {fLocalJetMinEta = - 0.9 + R; fLocalJetMaxEta = 0.9 - R; }
 164         void                    SetLocalJetMinMaxPhi(Float_t min, Float_t max)  {fLocalJetMinPhi = min; fLocalJetMaxEta = max;}
 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         void                    CalculateEventPlaneVZERO(Double_t vzero[2][2]) const;
 170         void                    CalculateEventPlaneTPC(Double_t* tpc);
 171         void                    CalculateEventPlaneCombinedVZERO(Double_t* comb) const;
 172         void                    CalculateEventPlaneResolution(Double_t vzero[2][2], Double_t* vzeroComb, Double_t* tpc);
 173         Double_t                CalculateEventPlaneChi(Double_t resEP) const;
 174         void                    CalculateRandomCone(Float_t &pt, Float_t &eta, Float_t &phi, AliEmcalJet* jet = 0x0) const;
 175         Double_t                CalculateQC2(Int_t harm);
 176         Double_t                CalculateQC4(Int_t harm);
 177         // helper calculations for the q-cumulant analysis, also used by AliAnalyisTaskJetFlow
 178         void                    QCnQnk(Int_t n, Int_t k, Double_t &reQ, Double_t &imQ);
 179         void                    QCnDiffentialFlowVectors(
 180             TClonesArray* pois, TArrayD* ptBins, Bool_t vpart, Double_t* repn, Double_t* impn,
 181             Double_t *mp, Double_t *reqn, Double_t *imqn, Double_t* mq, Int_t n);
 182         Double_t                QCnS(Int_t i, Int_t j);
 183         Double_t                QCnM();
 184         Double_t                QCnM11();
 185         Double_t                QCnM1111();
 186         Bool_t                  QCnRecovery(Double_t psi2, Double_t psi3);
 187         // analysis details
 188         Bool_t                  CorrectRho(Double_t psi2, Double_t psi3);
 189         // event and track selection, also used by AliAnalyisTaskJetFlow
 190         /* inline */    Bool_t PassesCuts(AliVTrack* track) const { return AcceptTrack(track, 0); }
 191         /* inline */    Bool_t PassesCuts(AliEmcalJet* jet) { return AcceptJet(jet, 0); }
 192         /* inline */    Bool_t PassesSimpleCuts(AliEmcalJet* jet) {
 193             Float_t minPhi(GetJetContainer()->GetJetPhiMin()), maxPhi(GetJetContainer()->GetJetPhiMax());
 194             return (jet && jet->Pt() > 1 && jet->Eta() < .9-GetJetRadius() && jet->Eta() > -.9+GetJetRadius() && jet->Phi() > minPhi && jet->Phi() < maxPhi && jet->Area() > .557*GetJetRadius()*GetJetRadius()*TMath::Pi());
 195         }
 196         Bool_t                  PassesCuts(AliVEvent* event);
 197         Bool_t                  PassesCuts(Int_t year);
 198         Bool_t                  PassesCuts(const AliVCluster* track) const;
 199         // filling histograms
 200         void                    FillHistogramsAfterSubtraction(Double_t psi2, Double_t psi3, Double_t vzero[2][2], Double_t* vzeroComb, Double_t* tpc);
 201         void                    FillTrackHistograms() const;
 202         void                    FillClusterHistograms() const;
 203         void                    FillCorrectedClusterHistograms() const;
 204         void                    FillEventPlaneHistograms(Double_t vzero[2][2], Double_t* vzeroComb, Double_t* tpc) const;
 205         void                    FillRhoHistograms();
 206         void                    FillDeltaPtHistograms(Double_t psi2, Double_t psi3) const;
 207         void                    FillJetHistograms(Double_t psi2, Double_t psi3);
 208         void                    FillQAHistograms(AliVTrack* vtrack) const;
 209         void                    FillQAHistograms(AliVEvent* vevent);
 210         void                    FillAnalysisSummaryHistogram() const;
 211         virtual void            Terminate(Option_t* option);
 212         // interface methods for the output file
 213         void                    SetOutputList(TList* l) {fOutputList = l;}
 214         TH1F*                   GetResolutionFromOuptutFile(detectorType detector, Int_t h = 2, TArrayD* c = 0x0);
 215         TH1F*                   CorrectForResolutionDiff(TH1F* v, detectorType detector, TArrayD* cen, Int_t c, Int_t h = 2);
 216         TH1F*                   CorrectForResolutionInt(TH1F* v, detectorType detector, TArrayD* cen, Int_t h = 2);
 217         TH1F*                   GetDifferentialQC(TProfile* refCumulants, TProfile* diffCumlants, TArrayD* ptBins, Int_t h);
 218     private:
 219         // analysis flags and settings
 220         Int_t                   fDebug;                 // debug level (0 none, 1 fcn calls, 2 verbose)
 221         Bool_t                  fRunToyMC;              // run toy mc for fit routine
 222         Bool_t                  fLocalInit;             //! is the analysis initialized?
 223         Bool_t                  fAttachToEvent;         // attach local rho to the event
 224         Bool_t                  fSemiCentralInclusive;  // semi central inclusive event selection
 225         Bool_t                  fFillHistograms;        // fill histograms
 226         Bool_t                  fFillQAHistograms;      // fill qa histograms
 227         Float_t                 fReduceBinsXByFactor;   // reduce the bins on x-axis of histo's by this much
 228         Float_t                 fReduceBinsYByFactor;   // reduce the bins on y-axis of histo's by this much
 229         Bool_t                  fNoEventWeightsForQC;   // don't store event weights for qc analysis
 230         TArrayD*                fCentralityClasses;     //-> centrality classes (maximum 10)
 231         TArrayD*                fPtBinsHybrids;         //-> pt bins for hybrid track vn anaysis
 232         TArrayD*                fPtBinsJets;            //-> pt bins for jet vn analysis
 233         TH1F*                   fUserSuppliedV2;        // histo with integrated v2
 234         TH1F*                   fUserSuppliedV3;        // histo with integrated v3
 235         TH1F*                   fUserSuppliedR2;        // correct the extracted v2 with this r
 236         TH1F*                   fUserSuppliedR3;        // correct the extracted v3 with this r
 237         AliParticleContainer*   fTracksCont;            //!tracks
 238         AliJetContainer*        fJetsCont;              //!jets
 239         AliEmcalJet*            fLeadingJet;            //! leading jet
 240         // members
 241         Bool_t                  fUseScaledRho;          // use scaled rho
 242         Int_t                   fNAcceptedTracks;       //! number of accepted tracks
 243         Int_t                   fNAcceptedTracksQCn;    //! accepted tracks for QCn
 244         fitModulationType       fFitModulationType;     // fit modulation type
 245         fitGoodnessTest         fFitGoodnessTest;       // fit goodness test type
 246         qcRecovery              fQCRecovery;            // recovery type for e-by-e qc method
 247         Bool_t                  fUsePtWeight;           // use dptdphi instead of dndphi
 248         Bool_t                  fUsePtWeightErrorPropagation;   // recalculate the bin errors in case of pt weighting
 249         detectorType            fDetectorType;          // type of detector used for modulation fit
 250         TString                 fFitModulationOptions;  // fit options for modulation fit
 251         runModeType             fRunModeType;           // run mode type
 252         dataType                fDataType;              // datatype
 253         collisionType           fCollisionType;         // collision type
 254         TRandom3*               fRandom;                //-> dont use gRandom to not interfere with other tasks
 255         Int_t                   fRunNumber;             //! current runnumber (for QA and jet, track selection)
 256         Int_t                   fMappedRunNumber;       //! mapped runnumer (for QA)
 257         Int_t                   fInCentralitySelection; //! centrality bin
 258         TF1*                    fFitModulation;         //-> modulation fit for rho
 259         TF1*                    fFitControl;            //-> control fit
 260         Float_t                 fMinPvalue;             // minimum value of p
 261         Float_t                 fMaxPvalue;             // maximum value of p
 262         const char*             fNameJetClones;         //! collection of tclones array with jets
 263         const char*             fNamePicoTrackClones;   //! collection of tclones with pico tracks
 264         const char*             fNameRho;               //! name of rho
 265         TString                 fNameSmallRho;          // name of small rho
 266         // additional jet cuts (most are inherited)
 267         Float_t                 fLocalJetMinEta;        // local eta cut for jets
 268         Float_t                 fLocalJetMaxEta;        // local eta cut for jets
 269         Float_t                 fLocalJetMinPhi;        // local phi cut for jets
 270         Float_t                 fLocalJetMaxPhi;        // local phi cut for jets
 271         Float_t                 fSoftTrackMinPt;        // min pt for soft tracks
 272         Float_t                 fSoftTrackMaxPt;        // max pt for soft tracks
 273         Double_t                fSemiGoodJetMinPhi;     // min phi for semi good tpc runs
 274         Double_t                fSemiGoodJetMaxPhi;     // max phi for semi good tpc runs
 275         Double_t                fSemiGoodTrackMinPhi;   // min phi for semi good tpc runs
 276         Double_t                fSemiGoodTrackMaxPhi;   // max phi for semi good tpc runs
 277         // event cuts
 278         Float_t                 fAbsVertexZ;            // cut on zvertex
 279         // general qa histograms
 280         TH1F*                   fHistCentrality;        //! accepted centrality
 281         TH1F*                   fHistVertexz;           //! accepted verte
 282         TH2F*                   fHistRunnumbersPhi;     //! run numbers averaged phi
 283         TH2F*                   fHistRunnumbersEta;     //! run numbers averaged eta
 284         TH1F*                   fHistPvalueCDFROOT;     //! pdf value of chisquare p
 285         TH2F*                   fHistPvalueCDFROOTCent; //! p value versus centrlaity from root
 286         TH2F*                   fHistChi2ROOTCent;      //! reduced chi2 from ROOT, centrality correlation
 287         TH2F*                   fHistPChi2Root;         //! correlation p value and reduced chi2
 288         TH1F*                   fHistPvalueCDF;         //! cdf value of chisquare p
 289         TH2F*                   fHistPvalueCDFCent;     //! p value vs centrality
 290         TH2F*                   fHistChi2Cent;          //! reduced chi2, centrlaity correlation
 291         TH2F*                   fHistPChi2;             //! correlation p value and reduced chi2
 292         TH1F*                   fHistKolmogorovTest;    //! KolmogorovTest value
 293         TH2F*                   fHistKolmogorovTestCent;//! KolmogorovTest value, centrality correlation
 294         TH2F*                   fHistPKolmogorov;       //! p value vs kolmogorov value
 295         TH2F*                   fHistRhoStatusCent;     //! status of rho as function of centrality
 296         TH1F*                   fHistUndeterminedRunQA; //! undetermined run QA
 297         // general settings
 298         Float_t                 fMinDisanceRCtoLJ;      // min distance between rc and leading jet
 299         Float_t                 fRandomConeRadius;      // radius of random cone
 300         Int_t                   fMaxCones;              // max number of random cones
 301         Bool_t                  fAbsVnHarmonics;        // force postive local rho
 302         Float_t                 fExcludeLeadingJetsFromFit;    // exclude n leading jets from fit
 303         Bool_t                  fRebinSwapHistoOnTheFly;       // rebin swap histo on the fly
 304         Float_t                 fPercentageOfFits;      // save this percentage of fits
 305         Bool_t                  fUseV0EventPlaneFromHeader;             // use the vzero event plane from the header
 306         Int_t                   fExplicitOutlierCut;    // cut on correlation of tpc and global multiplicity
 307         Double_t                fMinLeadingHadronPt;    // minimum pt for leading hadron
 308         Bool_t                  fSubtractJetPt;         // save subtracted jet pt by calling SetPtSub
 309         // transient object pointers
 310         TList*                  fOutputList;            //! output list
 311         TList*                  fOutputListGood;        //! output list for local analysis
 312         TList*                  fOutputListBad;         //! output list for local analysis
 313         TH1F*                   fHistAnalysisSummary;   //! analysis summary
 314         TH1F*                   fHistSwap;              //! swap histogram
 315         TProfile*               fProfV2;                //! extracted v2
 316         TProfile*               fProfV2Cumulant;        //! v2 cumulant
 317         TProfile*               fProfV2Resolution[10];  //! resolution parameters for v2
 318         TProfile*               fProfV3;                //! extracted v3
 319         TProfile*               fProfV3Cumulant;        //! v3 cumulant
 320         TProfile*               fProfV3Resolution[10];  //! resolution parameters for v3
 321         // qa histograms for accepted pico tracks
 322         TH1F*                   fHistPicoTrackPt[10];    //! pt of all charged tracks
 323         TH1F*                   fHistPicoTrackMult[10];  //! multiplicity of accepted pico tracks
 324         TH2F*                   fHistPicoCat1[10];       //! pico tracks spd hit and refit
 325         TH2F*                   fHistPicoCat2[10];       //! pico tracks wo spd hit w refit, constrained
 326         TH2F*                   fHistPicoCat3[10];       //! pico tracks wo spd hit wo refit, constrained
 327         // qa histograms for accepted emcal clusters
 328         /* TH1F*                   fHistClusterPt[10];      //! pt uncorrected emcal clusters */
 329         /* TH1F*                   fHistClusterPhi[10];     //! phi uncorrected emcal clusters */
 330         /* TH1F*                   fHistClusterEta[10];     //! eta uncorrected emcal clusters */
 331         // qa histograms for accepted emcal clusters aftehadronic correction
 332         /* TH1F*                   fHistClusterCorrPt[10];  //! pt corrected emcal clusters */
 333         /* TH1F*                   fHistClusterCorrPhi[10]; //! phi corrected emcal clusters */
 334         /* TH1F*                   fHistClusterCorrEta[10]; //! eta corrected emcal clusters */
 335         // qa event planes
 336         TProfile*               fHistPsiControl;         //! event plane control histogram
 337         TProfile*               fHistPsiSpread;          //! event plane spread histogram
 338         TH1F*                   fHistPsiVZEROA;          //! psi 2 from vzero a
 339         TH1F*                   fHistPsiVZEROC;          //! psi 2 from vzero c
 340         TH1F*                   fHistPsiVZERO;           //! psi 2 from combined vzero
 341         TH1F*                   fHistPsiTPC;             //! psi 2 from tpc
 342         TH2F*                   fHistPsiVZEROAV0M;      //! psi 2 from vzero a
 343         TH2F*                   fHistPsiVZEROCV0M;      //! psi 2 from vzero c
 344         TH2F*                   fHistPsiVZEROVV0M;      //! psi 2 from combined vzero
 345         TH2F*                   fHistPsiTPCiV0M;        //! psi 2 from tpc
 346         TH2F*                   fHistPsiVZEROATRK;      //! psi 2 from vzero a
 347         TH2F*                   fHistPsiVZEROCTRK;      //! psi 2 from vzero c
 348         TH2F*                   fHistPsiVZEROTRK;       //! psi 2 from combined vzero
 349         TH2F*                   fHistPsiTPCTRK;         //! psi 2 from tpc
 350         // background
 351         TH1F*                   fHistRhoPackage[10];     //! rho as estimated by emcal jet package
 352         TH1F*                   fHistRho[10];            //! background
 353         TH2F*                   fHistRhoVsMult;          //! rho versus multiplicity
 354         TH2F*                   fHistRhoVsCent;          //! rho veruss centrality
 355         TH2F*                   fHistRhoAVsMult;         //! rho * A vs multiplicity for all jets
 356         TH2F*                   fHistRhoAVsCent;         //! rho * A vs centrality for all jets
 357         // delta pt distributions
 358         TH2F*                   fHistRCPhiEta[10];              //! random cone eta and phi
 359         TH2F*                   fHistRhoVsRCPt[10];             //! rho * A vs rcpt
 360         TH1F*                   fHistRCPt[10];                  //! rcpt
 361         TH2F*                   fHistDeltaPtDeltaPhi2[10];      //! dpt vs dphi (psi2 - phi)
 362         TH2F*                   fHistDeltaPtDeltaPhi3[10];      //! dpt vs dphi (psi3 - phi)
 363         TH2F*                   fHistRCPhiEtaExLJ[10];          //! random cone eta and phi, excl leading jet
 364         TH2F*                   fHistRhoVsRCPtExLJ[10];         //! rho * A vs rcpt, excl leading jet
 365         TH1F*                   fHistRCPtExLJ[10];              //! rcpt, excl leading jet
 366         TH2F*                   fHistDeltaPtDeltaPhi2ExLJ[10];  //! dpt vs dphi, excl leading jet
 367         TH2F*                   fHistDeltaPtDeltaPhi3ExLJ[10];  //! dpt vs dphi, excl leading jet
 368         /* TH2F*                   fHistRCPhiEtaRand[10];          //! random cone eta and phi, randomized */
 369         /* TH2F*                   fHistRhoVsRCPtRand[10];         //! rho * A vs rcpt, randomized */
 370         /* TH1F*                   fHistRCPtRand[10];              //! rcpt, randomized */
 371         /* TH2F*                   fHistDeltaPtDeltaPhi2Rand[10];  //! dpt vs dphi, randomized */
 372         /* TH2F*                   fHistDeltaPtDeltaPhi3Rand[10];  //! dpt vs dphi, randomized */
 373         // jet histograms (after kinematic cuts)
 374         TH1F*                   fHistJetPtRaw[10];              //! jet pt - no background subtraction
 375         TH1F*                   fHistJetPt[10];                 //! pt of found jets (background subtracted)
 376         TH2F*                   fHistJetEtaPhi[10];             //! eta and phi correlation
 377         TH2F*                   fHistJetPtArea[10];             //! jet pt versus area
 378         TH2F*                   fHistJetPtConstituents[10];     //! jet pt versus number of constituents
 379         TH2F*                   fHistJetEtaRho[10];             //! jet eta versus jet rho
 380         // in plane, out of plane jet spectra
 381         TH2F*                   fHistJetPsi2Pt[10];             //! psi tpc versus pt
 382         TH2F*                   fHistJetPsi3Pt[10];             //! psi vzeroc versus pt
 383
 384         AliAnalysisTaskRhoVnModulation(const AliAnalysisTaskRhoVnModulation&);                  // not implemented
 385         AliAnalysisTaskRhoVnModulation& operator=(const AliAnalysisTaskRhoVnModulation&);       // not implemented
 386
 387         ClassDef(AliAnalysisTaskRhoVnModulation, 24);
 388 };
 389
 390 #endif