]>
Commit | Line | Data |
---|---|---|
b1f673b5 | 1 | #ifndef ALIANALYSISTASKMULTIDIELECTRONTG_H |
2 | #define ALIANALYSISTASKMULTIDIELECTRONTG_H | |
3 | /* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. * | |
4 | * See cxx source for full Copyright notice */ | |
5 | ||
6 | //##################################################### | |
7 | //# # | |
8 | //# Basic Analysis task for Dielectron # | |
9 | //# single event analysis # | |
10 | //# # | |
11 | //# by WooJin J. Park, GSI / W.J.Park@gsi.de # | |
12 | //# Ionut C. Arsene, GSI / I.C.Arsene@gsi.de # | |
13 | //# Magnus Mager, CERN / Magnus.Mager@cern.ch # | |
14 | //# Jens Wiechula, Uni HD / Jens.Wiechula@cern.ch # | |
15 | //# # | |
16 | //##################################################### | |
17 | ||
18 | #include "TList.h" | |
19 | ||
20 | #include "AliAnalysisTaskSE.h" | |
21 | ||
22 | #include <vector> | |
23 | #include <deque> | |
24 | #include <cstdlib> | |
25 | ||
26 | ||
27 | // #include "AliDielectronPID.h" | |
28 | ||
29 | class AliDielectron; | |
30 | class TH1D; | |
31 | class AliAnalysisCuts; | |
32 | class AliTriggerAnalysis; | |
33 | class AliESDtrackCuts; | |
34 | ||
35 | class AliDielectronSingleTG : public TObject | |
36 | { | |
37 | public: | |
38 | AliDielectronSingleTG(): | |
39 | fCharge(0), | |
40 | fCentrality(0), | |
41 | fXv(0), | |
42 | fYv(0), | |
43 | fZv(0), | |
44 | fPx(0), | |
45 | fPy(0), | |
46 | fPz(0), | |
47 | fPt(0), | |
48 | fEta(0), | |
49 | fPhi(0), | |
50 | fTheta(0), | |
51 | fConv(0), | |
52 | fGst(0), | |
7329335b | 53 | fObj(0x0) |
b1f673b5 | 54 | {; |
55 | } | |
56 | ||
57 | AliDielectronSingleTG(Int_t charge, Double_t cent, | |
58 | Double_t xv, Double_t yv, Double_t zv, | |
59 | Double_t px, Double_t py, Double_t pz, Double_t pt, | |
60 | Double_t eta, Double_t phi, Double_t theta, | |
61 | Int_t conv, Int_t ghost, AliVTrack *trk) | |
62 | : | |
63 | fCharge(charge), | |
64 | fCentrality(cent), | |
65 | fXv(xv), | |
66 | fYv(yv), | |
67 | fZv(zv), | |
68 | fPx(px), | |
69 | fPy(py), | |
70 | fPz(pz), | |
71 | fPt(pt), | |
72 | fEta(eta), | |
73 | fPhi(phi), | |
74 | fTheta(theta), | |
75 | fConv(conv), | |
7329335b | 76 | fGst(ghost), fObj(0x0) |
b1f673b5 | 77 | { |
78 | SetTrack(trk); | |
79 | ; | |
80 | } | |
81 | ||
7329335b | 82 | AliDielectronSingleTG(const AliDielectronSingleTG&); |
83 | AliDielectronSingleTG &operator=(const AliDielectronSingleTG&); | |
84 | ||
85 | ||
86 | ||
b1f673b5 | 87 | ~AliDielectronSingleTG() {;} |
88 | ||
89 | ||
7329335b | 90 | void SetTrack(AliVTrack * const trk) { fObj = trk;} |
91 | virtual Int_t Charge(void) const { return fCharge;} | |
92 | Double_t Phi(void) const { return fPhi;} | |
93 | Double_t Theta(void) const { return fTheta;} | |
94 | Double_t Px(void) const { return fPx;} | |
95 | Double_t Py(void) const { return fPy;} | |
96 | Double_t Pz(void) const { return fPz;} | |
97 | Double_t Xv(void) const { return fPx;} | |
98 | Double_t Yv(void) const { return fPy;} | |
99 | Double_t Zv(void) const { return fPz;} | |
100 | Double_t Pt(void) const { return fPt;} | |
101 | AliVTrack *GetTrack(void) const { return fObj;} | |
b1f673b5 | 102 | void SetConvFlag(Int_t val){ fConv = val;} |
103 | void SetGstFlag(Int_t val){ fGst = val;} | |
7329335b | 104 | Int_t GetConvFlag(void) const { return fConv;} |
105 | Int_t GetGstFlag(void) const { return fGst;} | |
b1f673b5 | 106 | |
107 | protected: | |
7329335b | 108 | Int_t fCharge; ///charge of track |
109 | Double_t fCentrality; // centrality | |
110 | Double_t fXv; // vertex in X | |
111 | Double_t fYv; // vertex in Y | |
112 | Double_t fZv; // vertex in Z | |
113 | Double_t fPx; // Momentum in X | |
114 | Double_t fPy; // Momentum in Y | |
115 | Double_t fPz; // Momentum in Z | |
116 | Double_t fPt; // Momentum in Transverse | |
117 | Double_t fEta; // Particle Eta | |
118 | Double_t fPhi; // Particle Phi | |
119 | Double_t fTheta; //Particle Theta | |
120 | Int_t fConv; /// Conversion Flag | |
121 | Int_t fGst; /// Ghost flag | |
122 | AliVTrack *fObj; ///AliVTrack | |
b1f673b5 | 123 | |
124 | ClassDef(AliDielectronSingleTG, 2) // Event pool class | |
125 | ||
126 | }; | |
127 | ||
128 | ||
129 | ||
130 | class AliAnalysisTaskMultiDielectronTG : public AliAnalysisTaskSE { | |
131 | ||
132 | public: | |
133 | AliAnalysisTaskMultiDielectronTG(); | |
134 | AliAnalysisTaskMultiDielectronTG(const char *name); | |
135 | virtual ~AliAnalysisTaskMultiDielectronTG(); | |
136 | ||
137 | enum ETriggerLogig {kAny, kExact}; | |
138 | ||
139 | virtual void UserExec(Option_t *option); | |
140 | virtual void UserCreateOutputObjects(); | |
141 | virtual void FinishTaskOutput(); | |
142 | //temporary | |
143 | // virtual void NotifyRun(){AliDielectronPID::SetCorrVal((Double_t)fCurrentRunNumber);} | |
144 | ||
145 | void UsePhysicsSelection(Bool_t phy=kTRUE) {fSelectPhysics=phy;} | |
146 | void SetTriggerMask(ULong64_t mask) {fTriggerMask=mask;} | |
147 | UInt_t GetTriggerMask() const { return fTriggerMask; } | |
148 | void SetExcludeTriggerMask(ULong64_t mask) {fExcludeTriggerMask=mask;} | |
149 | UInt_t GetExcludeTriggerMask() const { return fExcludeTriggerMask; } | |
150 | void SetTriggerLogic(ETriggerLogig log) {fTriggerLogic=log;} | |
151 | ETriggerLogig GetTriggerLogic() const {return fTriggerLogic;} | |
152 | ||
153 | void SetEventFilter(AliAnalysisCuts * const filter) {fEventFilter=filter;} | |
154 | void SetTriggerOnV0AND(Bool_t v0and=kTRUE) { fTriggerOnV0AND=v0and; } | |
155 | void SetRejectPileup(Bool_t pileup=kTRUE) { fRejectPileup=pileup; } | |
156 | void AddDielectron(AliDielectron * const die) { fListDielectron.Add(die); } | |
157 | ||
158 | ||
805bd069 | 159 | void RejectOP(double val){fdop = val;} ///To reject conversions |
7329335b | 160 | void RejectConversion(double val){fdconvphiv = val;} ///To reject conversions |
161 | void EnableV0mixing(Bool_t val){fdv0mixing = val;} ///Enable V0 mixing | |
162 | void CheckGhostPairs(vector<AliDielectronSingleTG*> e1); ///identify ghost pairs in like sign pais | |
805bd069 | 163 | void RejectPairs(vector<AliDielectronSingleTG*> e1, vector<AliDielectronSingleTG*> e2, Int_t idie); ///identify conversions for the rejection |
164 | void FillPair(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2, int type, AliDielectron *die, Int_t idie); /// Fill Pairs | |
165 | bool PairTrackcut(double var1, double var2, int idie); /// Pair cuts | |
7329335b | 166 | void CalcVars(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2, |
b1f673b5 | 167 | double &mass, double &phiv, double &px, double &py, double&pz, |
7329335b | 168 | double &pt, double &e, double &phi, double &eta, double &cos, double &psi); /// Calcualate kinematic variables |
169 | void CalcPair(vector<AliDielectronSingleTG*> e1, vector<AliDielectronSingleTG*> e2, AliDielectron *die, Int_t idie); ///Process Pairs | |
170 | void RandomizePool(vector<AliDielectronSingleTG*> e1, vector<AliDielectronSingleTG*> e2); ///Randimize pairs | |
171 | void ReshuffleBuffer(vector<AliDielectronSingleTG*> ve, deque<AliDielectronSingleTG*> pool); ///ReshuffleBuffer | |
b1f673b5 | 172 | |
805bd069 | 173 | Double_t GetPhiv(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2); /// calculate phiv |
174 | Double_t GetOpeningAngle(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2); /// calculate opening angle | |
175 | void SetPairCuts(Int_t Types[20]){ | |
176 | for(int i=0;i<20;i++){ | |
177 | fRejectPairFlag[i] = Types[i]; | |
178 | } | |
179 | } | |
180 | ||
181 | ||
b1f673b5 | 182 | protected: |
183 | enum {kAllEvents=0, kSelectedEvents, kV0andEvents, kFilteredEvents, kPileupEvents, kNbinsEvent}; | |
184 | TList fListDielectron; // List of dielectron framework instances | |
185 | TList fListHistos; //! List of histogram manager lists in the framework classes | |
186 | TList fListCF; //! List with CF Managers | |
7329335b | 187 | TList *fQAElectron; //! List with CF Managers |
b1f673b5 | 188 | |
189 | ||
190 | Bool_t fSelectPhysics; // Whether to use physics selection | |
191 | UInt_t fTriggerMask; // Event trigger mask | |
192 | UInt_t fExcludeTriggerMask; // Triggers to exclude from the analysis | |
193 | Bool_t fTriggerOnV0AND; // if to trigger on V0and | |
194 | Bool_t fRejectPileup; // pileup rejection wanted | |
195 | ||
805bd069 | 196 | enum PairRejType { NoRej=0, RejPairOp, RejPairPv, CutPairOp, CutPairPv}; |
197 | ||
198 | Int_t fRejectPairFlag[20]; | |
199 | ||
b1f673b5 | 200 | ETriggerLogig fTriggerLogic; // trigger logic: any or all bits need to be matching |
201 | ||
202 | AliTriggerAnalysis *fTriggerAnalysis; //! trigger analysis class | |
203 | ||
204 | AliAnalysisCuts *fEventFilter; // event filter | |
205 | ||
7329335b | 206 | AliESDtrackCuts *fCutsMother; /// Mother Cuts for QA |
b1f673b5 | 207 | |
208 | TH1D *fEventStat; //! Histogram with event statistics | |
7329335b | 209 | TH1D *fEvent; // Centrality |
210 | TH2D *fdEdXvsPt; // TPC dE/dx | |
211 | TH2D *fdEdXnSigmaElecvsPt; // TPC nSigmaEle vs. pt | |
212 | TH2D *fdEdXvsPtTOF; // TPC dE/dx with TOF cut | |
213 | TH2D *fdEdXnSigmaElecvsPtTOF; // TPC nSigmaEle vs. pt with TOF Cuts | |
214 | TH2D *fTOFbetavsPt; // TOF beta vs. pT | |
215 | TH2D *fTOFnSigmaElecvsPt; // TOF nSigma Electron vs. pT | |
216 | TH2F *fNCrossedRowsTPC; // TPC NCrossedRows vs. pT | |
217 | TH2F *fChi2ClusTPC; // TPC Chi2 Per Cluster | |
218 | TH2F *fRatioCrossClusTPC; // TPC Crossed rows per finable Clusters | |
219 | ||
220 | Double_t fgValues[AliDielectronVarManager::kNMaxValues]; /// Track/Pair information from AliDielectronVarManager | |
221 | std::vector<AliDielectronSingleTG*> fVem; /// Lists of electrons | |
222 | std::vector<AliDielectronSingleTG*> fVep; /// Lists of positions | |
223 | std::vector<AliDielectronSingleTG*> fVemtmp; /// template for electron lists | |
224 | std::vector<AliDielectronSingleTG*> fVeptmp; /// template for positron lists | |
225 | Double_t fdconvphiv; /// PhiCut | |
805bd069 | 226 | Double_t fdop; /// Opening angle Cut |
7329335b | 227 | Double_t fbz; /// Magnetic field |
228 | Bool_t fdv0mixing; /// Mixing using V0 | |
b1f673b5 | 229 | |
230 | ||
231 | //Buffer for event mixing | |
7329335b | 232 | static const int fgkNBUF=100; //depth of buffer |
233 | static const int fgkNMix=40; //# of events mixed (for +-) | |
b1f673b5 | 234 | //static const int NMix=2; //# of events mixed (for +-) |
235 | ||
236 | ||
7329335b | 237 | static const int fgkNRPBIN=12; ///Number of RPbin for mixed event |
238 | static const int fgkNZBIN=10; ///Number of zbin for mixed event | |
239 | static const int fgkNCENT=10; ///Number of centrality for mixed event | |
805bd069 | 240 | static const int fgkNDIE=20; ///maximum number of cuts for AliDielectron |
7329335b | 241 | int fibuf[fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN]; ///buffer occupation for mixed event |
242 | std::vector<AliDielectronSingleTG*> fvep[fgkNBUF][fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN]; //// positron buffer for mixing | |
243 | std::vector<AliDielectronSingleTG*> fvem[fgkNBUF][fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN]; //// electron buffer for mixing | |
244 | ||
245 | static const unsigned int fgkMAXPOOL=500; ////maximum pool for mixing | |
b1f673b5 | 246 | //static const unsigned int MAXPOOL=50; |
7329335b | 247 | static const int fgkMAXTRY=3; ///try to shuffle |
248 | std::deque<AliDielectronSingleTG*> fpoolp[fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN]; ///pool for positrons | |
249 | std::deque<AliDielectronSingleTG*> fpoolm[fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN]; ///pool for electrons | |
b1f673b5 | 250 | |
251 | AliAnalysisTaskMultiDielectronTG(const AliAnalysisTaskMultiDielectronTG &c); | |
252 | AliAnalysisTaskMultiDielectronTG& operator= (const AliAnalysisTaskMultiDielectronTG &c); | |
253 | ||
254 | ClassDef(AliAnalysisTaskMultiDielectronTG, 2); //Analysis Task handling multiple instances of AliDielectron | |
255 | }; | |
256 | #endif |