]> 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
o fixes
[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
27// #include "AliDielectronPID.h"
28
29class AliDielectron;
30class TH1D;
31class AliAnalysisCuts;
32class AliTriggerAnalysis;
33class AliESDtrackCuts;
34
35class 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
130class AliAnalysisTaskMultiDielectronTG : public AliAnalysisTaskSE {
131
132public:
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
7329335b 159 void RejectConversion(double val){fdconvphiv = val;} ///To reject conversions
160 void EnableV0mixing(Bool_t val){fdv0mixing = val;} ///Enable V0 mixing
161 void CheckGhostPairs(vector<AliDielectronSingleTG*> e1); ///identify ghost pairs in like sign pais
162 void FillPair(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2, int type, AliDielectron *die); /// Fill Pairs
163 bool PairTrackcut(double var1); /// Pair cuts
164 void CalcVars(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2,
b1f673b5 165 double &mass, double &phiv, double &px, double &py, double&pz,
7329335b 166 double &pt, double &e, double &phi, double &eta, double &cos, double &psi); /// Calcualate kinematic variables
167 void CalcPair(vector<AliDielectronSingleTG*> e1, vector<AliDielectronSingleTG*> e2, AliDielectron *die, Int_t idie); ///Process Pairs
168 void RandomizePool(vector<AliDielectronSingleTG*> e1, vector<AliDielectronSingleTG*> e2); ///Randimize pairs
169 void ReshuffleBuffer(vector<AliDielectronSingleTG*> ve, deque<AliDielectronSingleTG*> pool); ///ReshuffleBuffer
b1f673b5 170
171protected:
172 enum {kAllEvents=0, kSelectedEvents, kV0andEvents, kFilteredEvents, kPileupEvents, kNbinsEvent};
173 TList fListDielectron; // List of dielectron framework instances
174 TList fListHistos; //! List of histogram manager lists in the framework classes
175 TList fListCF; //! List with CF Managers
7329335b 176 TList *fQAElectron; //! List with CF Managers
b1f673b5 177
178
179 Bool_t fSelectPhysics; // Whether to use physics selection
180 UInt_t fTriggerMask; // Event trigger mask
181 UInt_t fExcludeTriggerMask; // Triggers to exclude from the analysis
182 Bool_t fTriggerOnV0AND; // if to trigger on V0and
183 Bool_t fRejectPileup; // pileup rejection wanted
184
185 ETriggerLogig fTriggerLogic; // trigger logic: any or all bits need to be matching
186
187 AliTriggerAnalysis *fTriggerAnalysis; //! trigger analysis class
188
189 AliAnalysisCuts *fEventFilter; // event filter
190
7329335b 191 AliESDtrackCuts *fCutsMother; /// Mother Cuts for QA
b1f673b5 192
193 TH1D *fEventStat; //! Histogram with event statistics
7329335b 194 TH1D *fEvent; // Centrality
195 TH2D *fdEdXvsPt; // TPC dE/dx
196 TH2D *fdEdXnSigmaElecvsPt; // TPC nSigmaEle vs. pt
197 TH2D *fdEdXvsPtTOF; // TPC dE/dx with TOF cut
198 TH2D *fdEdXnSigmaElecvsPtTOF; // TPC nSigmaEle vs. pt with TOF Cuts
199 TH2D *fTOFbetavsPt; // TOF beta vs. pT
200 TH2D *fTOFnSigmaElecvsPt; // TOF nSigma Electron vs. pT
201 TH2F *fNCrossedRowsTPC; // TPC NCrossedRows vs. pT
202 TH2F *fChi2ClusTPC; // TPC Chi2 Per Cluster
203 TH2F *fRatioCrossClusTPC; // TPC Crossed rows per finable Clusters
204
205 Double_t fgValues[AliDielectronVarManager::kNMaxValues]; /// Track/Pair information from AliDielectronVarManager
206 std::vector<AliDielectronSingleTG*> fVem; /// Lists of electrons
207 std::vector<AliDielectronSingleTG*> fVep; /// Lists of positions
208 std::vector<AliDielectronSingleTG*> fVemtmp; /// template for electron lists
209 std::vector<AliDielectronSingleTG*> fVeptmp; /// template for positron lists
210 Double_t fdconvphiv; /// PhiCut
211 Double_t fbz; /// Magnetic field
212 Bool_t fdv0mixing; /// Mixing using V0
b1f673b5 213
214
215 //Buffer for event mixing
7329335b 216 static const int fgkNBUF=100; //depth of buffer
217 static const int fgkNMix=40; //# of events mixed (for +-)
b1f673b5 218 //static const int NMix=2; //# of events mixed (for +-)
219
220
7329335b 221 static const int fgkNRPBIN=12; ///Number of RPbin for mixed event
222 static const int fgkNZBIN=10; ///Number of zbin for mixed event
223 static const int fgkNCENT=10; ///Number of centrality for mixed event
224 static const int fgkNDIE=10; ///maximum number of cuts for AliDielectron
225 int fibuf[fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN]; ///buffer occupation for mixed event
226 std::vector<AliDielectronSingleTG*> fvep[fgkNBUF][fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN]; //// positron buffer for mixing
227 std::vector<AliDielectronSingleTG*> fvem[fgkNBUF][fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN]; //// electron buffer for mixing
228
229 static const unsigned int fgkMAXPOOL=500; ////maximum pool for mixing
b1f673b5 230 //static const unsigned int MAXPOOL=50;
7329335b 231 static const int fgkMAXTRY=3; ///try to shuffle
232 std::deque<AliDielectronSingleTG*> fpoolp[fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN]; ///pool for positrons
233 std::deque<AliDielectronSingleTG*> fpoolm[fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN]; ///pool for electrons
b1f673b5 234
235 AliAnalysisTaskMultiDielectronTG(const AliAnalysisTaskMultiDielectronTG &c);
236 AliAnalysisTaskMultiDielectronTG& operator= (const AliAnalysisTaskMultiDielectronTG &c);
237
238 ClassDef(AliAnalysisTaskMultiDielectronTG, 2); //Analysis Task handling multiple instances of AliDielectron
239};
240#endif