PWG/FLOW/Tasks/AliAnalysisTaskJetFlowMC.h

   1 #ifndef AliAnalysisTaskJetFlowMC_H
   2 #define AliAnalysisTaskJetFlowMC_H
   3
   4 // root includes
   5 #include "TF1.h"
   6 #include "TH1F.h"
   7 #include "TH2F.h"
   8 #include "TRandom.h"
   9 // aliroot includes
  10 #include "AliAnalysisTaskSE.h"
  11 // forward declarations
  12 class TList;
  13 class TClonesArray;
  14 class TArrayI;
  15
  16 class AliAnalysisTaskJetFlowMC : public AliAnalysisTaskSE
  17 {
  18     public:
  19         // enumerators
  20         enum detectorType       {kVZEROA, kVZEROC, kVZEROComb};  // detector that was used
  21         // constructors, destructor
  22         AliAnalysisTaskJetFlowMC();
  23         AliAnalysisTaskJetFlowMC(const char *name);
  24         virtual ~AliAnalysisTaskJetFlowMC();
  25         // mirror image of PickTrackMaker
  26         void    UserCreateOutputObjects();
  27         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);
  28         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);
  29
  30         void    UserExec(Option_t *option);
  31         void    SetDebugMode(Bool_t d)                          { fDebug = d;}
  32         void    SetTracksInName(const char *name)               { fTracksInName     = name; }
  33         void    SetTracksOutName(const char *name)              { fTracksOutName    = name; }
  34         // additional setters
  35         void    SetCentralityClasses(TArrayI* c)                { fCentralityClasses = c; }
  36         void    SetReferenceDetector(detectorType type)         { fDetectorType = type; }
  37         void    SetDifferentialV2(TF1* v2, Int_t c = 0)         { fFuncDiffV2[c] = v2; }
  38         void    SetDifferentialV3(TF1* v3, Int_t c = 0)         { fFuncDiffV3[c] = v3; }
  39         void    SetDifferentialV2(TH1* v2, Int_t c = 0)         { fHistDiffV2[c] = v2; }
  40         void    SetDifferentialV3(TH1* v3, Int_t c = 0)         { fHistDiffV3[c] = v3; }
  41         void    SetIntegratedV2(TH1* v2)                        { fHistIntV2 = v2; }
  42         void    SetIntegratedV3(TH1* v3)                        { fHistIntV3 = v3; }
  43         void    SetTrackSpectrum(TF1* ts)                       { fTrackSpectrum = ts; }
  44         void    SetRandomizeEta(Bool_t b)                       { fRandomizeEta = b; }
  45         void    SetSingleFragmentationJetSpectrum(TF1* js)      { fJetSpectrumSF = js; }
  46         void    SetNoOfSFJets(Int_t n)                          { fNoOfSFJets = n; }
  47         // additional methods
  48         void    V2AfterBurner(Double_t& phi, Double_t& eta, Double_t& pt) const;
  49         void    V3AfterBurner(Double_t& phi, Double_t& eta, Double_t& pt) const;
  50         void    InjectSingleFragmentationJetSpectrum(Int_t nacc);
  51         void    CalculateEventPlane();
  52         // inlined helper calculations
  53         Double_t        GetTrackPt()       const                { return fTrackSpectrum->GetRandom();}
  54         Double_t        GetTrackEta()       const               { return gRandom->Uniform(-.9, .9); }
  55         /* inline */    Double_t GetV2(Double_t pt) const {
  56             return (fFuncDiffV2[fCenBin]) ? fFuncDiffV2[fCenBin]->Eval(pt) :
  57             fHistDiffV2[fCenBin]->GetBinContent(fHistDiffV2[fCenBin]->GetXaxis()->FindBin(pt));
  58         }
  59         /* inline */    Double_t GetV3(Double_t pt) const {
  60             return (fFuncDiffV3[fCenBin]) ? fFuncDiffV3[fCenBin]->Eval(pt) :
  61             fHistDiffV3[fCenBin]->GetBinContent(fHistDiffV3[fCenBin]->GetXaxis()->FindBin(pt));
  62         }
  63         /* inline */    void GetFlowFluctuation(Double_t& vn) const {
  64             vn += TMath::Sqrt(2*(vn*.25)*(vn*.25))*TMath::ErfInverse(2*(gRandom->Uniform(0, fFlowFluctuations))-1);
  65         }
  66         /* inline */    Double_t PhaseShift(Double_t x) const {
  67             while (x>=TMath::TwoPi())x-=TMath::TwoPi();
  68             while (x<0.)x+=TMath::TwoPi();
  69         return x; }
  70         /* inline */    Double_t PhaseShift(Double_t x, Double_t n) const {
  71             x = PhaseShift(x);
  72             if(TMath::Nint(n)==2) while (x>TMath::Pi()) x-=TMath::Pi();
  73             if(TMath::Nint(n)==3) {
  74                 if(x>2.*TMath::TwoPi()/n) x = TMath::TwoPi() - x;
  75                 if(x>TMath::TwoPi()/n) x = TMath::TwoPi()-(x+TMath::TwoPi()/n);
  76             }
  77         return x; }
  78         /* inline */    void SampleVnFromTF1(Double_t &phi) const {
  79         phi = (fFuncVn) ? fFuncVn->GetRandom(0., TMath::TwoPi()) : 0; }
  80         /* inline */    void FillHistogramsOriginalData(Double_t& pt, Double_t& eta, Double_t& phi) const {
  81             fHistOriginalSpectrum[fCenBin]->Fill(pt);    fHistOriginalEtaPhi[fCenBin]->Fill(eta, phi);
  82             fHistOriginalDeltaPhi[fCenBin]->Fill(PhaseShift(phi-fPsi2, 2));
  83         }
  84         /* inline */    void FillHistogramsToyData(Double_t& pt, Double_t& eta, Double_t& phi, Double_t& vn) const {
  85             fHistToySpectrum[fCenBin]->Fill(pt);         fHistToyEtaPhi[fCenBin]->Fill(eta, phi);
  86             fHistToyDeltaPhi[fCenBin]->Fill(PhaseShift(phi-fPsi2, 2));  fHistToyVn[fCenBin]->Fill(pt, vn);
  87         }
  88         void            Terminate(Option_t* option);
  89         void            PrintInfo() const;
  90     protected:
  91         TString         fTracksOutName;         // name of output track array
  92         TString         fTracksInName;          // name of input track array
  93         TClonesArray   *fTracksIn;              //!track array in
  94         TClonesArray   *fTracksOut;             //!track array out
  95         Int_t           fCenBin;                //! centrality bin
  96         TArrayI*        fCentralityClasses;     // centrality classes (max 10)
  97         TF1*            fFuncVn;                //! vn function
  98         TList*          fOutputList;            // output list
  99         TF1*            fTrackSpectrum;         // track pt spectrum
 100         Bool_t          fRandomizeEta;          // randomize eta
 101         TF1*            fJetSpectrumSF;         // single fragmentation spectrum of jets
 102         Int_t           fNoOfSFJets;            // number of single fragmentation jets that will be added
 103         TF1*            fFuncDiffV2[10];        // differential v2 of charged tracks
 104         TF1*            fFuncDiffV3[10];        // differential v3 of charged tracks
 105         TH1*            fHistDiffV2[10];        // differential v2 of charged tracks
 106         TH1*            fHistDiffV3[10];        // differential v3 of charged tracks
 107         TH1*            fHistIntV2;             // integrated v2 of charged tracks
 108         TH1*            fHistIntV3;             // integrated v3 of charged tracks
 109         Float_t         fFlowFluctuations;      // introduce gaussian flow fluctuations of this magnitude
 110         Int_t           fMaxNumberOfIterations; // max number of iterations for afterburner
 111         Double_t        fPsi2;                  //! 2nd order event plane orientation
 112         Double_t        fPsi3;                  //! 3rd order event plane orientation
 113         Double_t        fPrecisionPhi;          // afterburner precision
 114         detectorType    fDetectorType;          // type of detector from which the EP is taken
 115         // output histograms
 116         TH1F*           fHistOriginalSpectrum[10];      //! original pt spectrum of accepted tracks
 117         TH2F*           fHistOriginalEtaPhi[10];        //! original eta phi spectrum of accepted tracks
 118         TH1F*           fHistToySpectrum[10];           //! spectrum of toy (generated) tracks
 119         TH2F*           fHistToyEtaPhi[10];             //! eta phi spectrum of toy (generated) tracks
 120         TH1F*           fHistOriginalDeltaPhi[10];      //! original delta phi spectrum
 121         TH1F*           fHistToyDeltaPhi[10];           //! delta phi spectrum of toy (generated) tracks
 122         TH2F*           fHistToyVn[10];                 //! generated differential vn values (should equal the differential spectrum)
 123         TH1F*           fHistSFJetSpectrum;             //! spectrum of generated sf jets
 124         TH2F*           fHistSFJetEtaPhi;               //! eta phi of generated sf jets
 125     private:
 126         AliAnalysisTaskJetFlowMC(const AliAnalysisTaskJetFlowMC&);            // not implemented
 127         AliAnalysisTaskJetFlowMC &operator=(const AliAnalysisTaskJetFlowMC&); // not implemented
 128
 129         ClassDef(AliAnalysisTaskJetFlowMC, 1); // Task to generate toy mc PicoTracks based on real events
 130 };
 131 #endif