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