]>
Commit | Line | Data |
---|---|---|
24373b38 | 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); | |
7ffa833f | 31 | void SetDebugMode(Bool_t d) { fDebug = d;} |
24373b38 | 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; } | |
7ffa833f | 44 | void SetRandomizeEta(Bool_t b) { fRandomizeEta = b; } |
24373b38 | 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();} | |
7ffa833f | 54 | Double_t GetTrackEta() const { return gRandom->Uniform(-.9, .9); } |
24373b38 | 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 | |
7ffa833f | 95 | Int_t fCenBin; //! centrality bin |
24373b38 | 96 | TArrayI* fCentralityClasses; // centrality classes (max 10) |
97 | TF1* fFuncVn; //! vn function | |
98 | TList* fOutputList; // output list | |
99 | TF1* fTrackSpectrum; // track pt spectrum | |
7ffa833f | 100 | Bool_t fRandomizeEta; // randomize eta |
24373b38 | 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 |