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