]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGDQ/dielectron/AliAnalysisTaskMultiDielectronTG.h
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
including switch to set on/off iso-track core removal, cleaning and bug fix
[u/mrichter/AliRoot.git] / PWGDQ / dielectron / AliAnalysisTaskMultiDielectronTG.h
CommitLineData
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
6fbd0222 27using std::vector;
28using std::deque;
29
b1f673b5 30// #include "AliDielectronPID.h"
31
32class AliDielectron;
33class TH1D;
34class AliAnalysisCuts;
35class AliTriggerAnalysis;
36class AliESDtrackCuts;
37
38class 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
134class AliAnalysisTaskMultiDielectronTG : public AliAnalysisTaskSE {
135
136public:
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 188protected:
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