Change Mult binning scheme
[u/mrichter/AliRoot.git] / PWGDQ / dielectron / AliReducedEvent.h
CommitLineData
240ed454 1// Classes used for creating a reduced information tree
2// Author: Ionut-Cristian Arsene (i.c.arsene@gsi.de)
3//
4// Basic structure:
5// 1. Event wise information
6// 2. List of tracks in the event
7// 3. List of resonance candidates
8
9#ifndef ALIREDUCEDEVENT_H
10#define ALIREDUCEDEVENT_H
11
12#include <TClonesArray.h>
13#include <TBits.h>
14#include <TMath.h>
15
16
17const Int_t fgkNMaxHarmonics = 10;
6ab32c51 18const Float_t gZdcNalpha= 1.0;
240ed454 19
20//_____________________________________________________________________
21class AliReducedTrack : public TObject {
22
23 friend class AliAnalysisTaskReducedTree; // friend analysis task which fills the object
24
25 public:
26 AliReducedTrack();
27 ~AliReducedTrack();
28
29 // getters
30 UShort_t TrackId() const {return fTrackId;}
31 ULong_t Status() const {return fStatus;}
32 Bool_t CheckTrackStatus(UInt_t flag) const {return (flag<8*sizeof(ULong_t) ? (fStatus&(1<<flag)) : kFALSE);}
33 Int_t Charge() const {return (fGlobalPt>0.0 ? +1 : -1);}
34 Float_t Px() const {return TMath::Abs(fGlobalPt)*TMath::Cos(fGlobalPhi);}
35 Float_t Py() const {return TMath::Abs(fGlobalPt)*TMath::Sin(fGlobalPhi);}
36 Float_t Pz() const {return TMath::Abs(fGlobalPt)*TMath::SinH(fGlobalEta);}
37 Float_t P() const {return TMath::Abs(fGlobalPt)*TMath::CosH(fGlobalEta);};
38 Float_t Phi() const {return fGlobalPhi;}
39 Float_t Pt() const {return TMath::Abs(fGlobalPt);}
40 Float_t Eta() const {return fGlobalEta;}
41 Float_t Theta() const {return TMath::ACos(TMath::TanH(fGlobalEta));}
42 Float_t PxTPC() const {return fTPCPt*TMath::Cos(fTPCPhi);}
43 Float_t PyTPC() const {return fTPCPt*TMath::Sin(fTPCPhi);}
44 Float_t PzTPC() const {return fTPCPt*TMath::SinH(fTPCEta);}
45 Float_t PTPC() const {return fTPCPt*TMath::CosH(fTPCEta);};
46 Float_t PhiTPC() const {return fTPCPhi;}
47 Float_t PtTPC() const {return fTPCPt;}
48 Float_t EtaTPC() const {return fTPCEta;}
49 Float_t ThetaTPC() const {return TMath::ACos(TMath::TanH(fTPCEta));}
50 Float_t Pin() const {return fMomentumInner;}
51 Float_t DCAxy() const {return fDCA[0];}
52 Float_t DCAz() const {return fDCA[1];}
6ab32c51 53 Float_t TrackLength() const {return fTrackLength;}
240ed454 54
55 UShort_t ITSncls() const;
56 UChar_t ITSclusterMap() const {return fITSclusterMap;}
57 Bool_t ITSLayerHit(Int_t layer) const {return (layer>=0 && layer<6 ? (fITSclusterMap&(1<<layer)) : kFALSE);};
58 Float_t ITSsignal() const {return fITSsignal;}
f6e67fe7 59 Float_t ITSnSig(Int_t specie) const {return (specie>=0 && specie<=3 ? fITSnSig[specie] : -999.);}
6ab32c51 60 Float_t ITSchi2() const {return fITSchi2;}
240ed454 61
62 UChar_t TPCncls() const {return fTPCNcls;}
63 UChar_t TPCFindableNcls() const {return fTPCNclsF;}
64 UChar_t TPCCrossedRows() const {return fTPCCrossedRows;}
65 UChar_t TPCnclsIter1() const {return fTPCNclsIter1;}
66 UChar_t TPCClusterMap() const {return fTPCClusterMap;}
67 Int_t TPCClusterMapBitsFired() const;
68 Bool_t TPCClusterMapBitFired(Int_t bit) const {return (bit>=0 && bit<8 ? (fTPCClusterMap&(1<<bit)) : kFALSE);};
69 Float_t TPCsignal() const {return fTPCsignal;}
6ab32c51 70 UChar_t TPCsignalN() const {return fTPCsignalN;}
240ed454 71 Float_t TPCnSig(Int_t specie) const {return (specie>=0 && specie<=3 ? fTPCnSig[specie] : -999.);}
6ab32c51 72 Float_t TPCchi2() const {return fTPCchi2;}
240ed454 73
74 Float_t TOFbeta() const {return fTOFbeta;}
75 Float_t TOFnSig(Int_t specie) const {return (specie>=0 && specie<=3 ? fTOFnSig[specie] : -999.);}
6ab32c51 76 Short_t TOFdeltaBC() const {return fTOFdeltaBC;}
240ed454 77
78 Int_t TRDntracklets(Int_t type) const {return (type==0 || type==1 ? fTRDntracklets[type] : -1);}
79 Float_t TRDpid(Int_t specie) const {return (specie>=0 && specie<=1 ? fTRDpid[specie] : -999.);}
6ab32c51 80 Float_t TRDpidLQ1D(Int_t specie) const {return (specie>=0 && specie<=1 ? fTRDpid[specie] : -999.);}
81 Float_t TRDpidLQ2D(Int_t specie) const {return (specie>=0 && specie<=1 ? fTRDpidLQ2D[specie] : -999.);}
240ed454 82
83 Int_t CaloClusterId() const {return fCaloClusterId;}
f6e67fe7 84
240ed454 85 Float_t BayesPID(Int_t specie) const {return (specie>=0 && specie<=2 ? fBayesPID[specie] : -999.);}
f6e67fe7 86
0c09cae4 87 Bool_t UsedForQvector() const {return fFlags&(UShort_t(1)<<0);}
88 Bool_t TestFlag(UShort_t iflag) const {return (iflag<8*sizeof(UShort_t) ? fFlags&(UShort_t(1)<<iflag) : kFALSE);}
89 Bool_t SetFlag(UShort_t iflag) {if (iflag>=8*sizeof(UShort_t)) return kFALSE; fFlags|=(UShort_t(1)<<iflag); return kTRUE;}
90 Bool_t IsGammaLeg() const {return fFlags&(UShort_t(1)<<1);}
6ab32c51 91 Bool_t IsPureGammaLeg() const {return fFlags&(UShort_t(1)<<8);}
0c09cae4 92 Bool_t IsK0sLeg() const {return fFlags&(UShort_t(1)<<2);}
6ab32c51 93 Bool_t IsPureK0sLeg() const {return fFlags&(UShort_t(1)<<9);}
0c09cae4 94 Bool_t IsLambdaLeg() const {return fFlags&(UShort_t(1)<<3);}
6ab32c51 95 Bool_t IsPureLambdaLeg() const {return fFlags&(UShort_t(1)<<10);}
0c09cae4 96 Bool_t IsALambdaLeg() const {return fFlags&(UShort_t(1)<<4);}
6ab32c51 97 Bool_t IsPureALambdaLeg() const {return fFlags&(UShort_t(1)<<11);}
0c09cae4 98 Bool_t IsKink(Int_t i=0) const {return (i>=0 && i<3 ? fFlags&(UShort_t(1)<<(5+i)) : kFALSE);}
99 Bool_t TestFlagMore(UShort_t iflag) const {return (iflag<8*sizeof(ULong_t) ? fMoreFlags&(ULong_t(1)<<iflag) : kFALSE);}
100 Bool_t SetFlagMore(UShort_t iflag) {if(iflag>=8*sizeof(ULong_t)) return kFALSE; fMoreFlags|=(ULong_t(1)<<iflag); return kTRUE;}
101 Bool_t UnsetFlagMore(UShort_t iflag) {if(iflag>=8*sizeof(ULong_t)) return kFALSE; fMoreFlags^=(ULong_t(1)<<iflag); return kTRUE;}
102 ULong_t GetFlagsMore() const {return fMoreFlags;}
240ed454 103
104 private:
105 UShort_t fTrackId; // track id
106 ULong_t fStatus; // tracking status
107 Float_t fGlobalPhi; // phi at the vertex from global track, in the [0,2pi) interval
108 Float_t fGlobalPt; // pt*charge at the vertex from global track
109 Float_t fGlobalEta; // eta at the vertex from global track
110 Float_t fTPCPhi; // phi at the vertex from TPC alone tracking , in the [0,2pi) interval
111 Float_t fTPCPt; // pt at the vertex from TPC alone tracking
112 Float_t fTPCEta; // eta at the vertex from TPC alone tracking
113 Float_t fMomentumInner; // inner param momentum (only the magnitude)
114 Float_t fDCA[2]; // DCA xy,z
6ab32c51 115 Float_t fTrackLength; // track length
240ed454 116
117 // ITS
118 UChar_t fITSclusterMap; // ITS cluster map
119 Float_t fITSsignal; // ITS signal
f6e67fe7 120 Float_t fITSnSig[4]; // 0-electron; 1-pion; 2-kaon; 3-proton
6ab32c51 121 Float_t fITSchi2; // ITS chi2 / cls
240ed454 122
123 // TPC
124 UChar_t fTPCNcls; // TPC ncls
125 UChar_t fTPCCrossedRows; // TPC crossed rows
126 UChar_t fTPCNclsF; // TPC findable ncls
127 UChar_t fTPCNclsIter1; // TPC no clusters after first iteration
128 UChar_t fTPCClusterMap; // TPC cluster distribution map
129 Float_t fTPCsignal; // TPC de/dx
6ab32c51 130 UChar_t fTPCsignalN; // TPC no clusters de/dx
240ed454 131 Float_t fTPCnSig[4]; // 0-electron; 1-pion; 2-kaon; 3-proton
6ab32c51 132 Float_t fTPCchi2; // TPC chi2 / cls
240ed454 133
134 // TOF
135 Float_t fTOFbeta; // TOF pid info
136 Float_t fTOFnSig[4]; // TOF n-sigma deviation from expected signal
6ab32c51 137 Short_t fTOFdeltaBC; // BC(event) - BC(track) estimated by TOF
240ed454 138
139 // TRD
140 UChar_t fTRDntracklets[2]; // 0 - AliESDtrack::GetTRDntracklets(); 1 - AliESDtrack::GetTRDntrackletsPID() TODO: use only 1 char
6ab32c51 141 Float_t fTRDpid[2]; // TRD pid 1D likelihoods, [0]-electron , [1]- pion
142 Float_t fTRDpidLQ2D[2]; // TRD pid 2D likelihoods, [0]-electron , [1]- pion
240ed454 143
144 // EMCAL/PHOS
145 Int_t fCaloClusterId; // ID for the calorimeter cluster (if any)
146
147 // Bayesian PID
f6e67fe7 148 Float_t fBayesPID[3]; // Combined Bayesian PID pi/K/p
149
150 UShort_t fFlags; // BIT0 toggled if track used for TPC event plane
151 // BIT1 toggled if track belongs to a gamma conversion
152 // BIT2 toggled if track belongs to a K0s
153 // BIT3 toggled if track belongs to a Lambda
154 // BIT4 toggled if track belongs to an Anti-Lambda
155 // BIT5 toggled if the track has kink0 index > 0
156 // BIT6 toggled if the track has kink1 index > 0
157 // BIT7 toggled if the track has kink2 index > 0
6ab32c51 158 // BIT8 toggled if track belongs to a pure gamma conversion
159 // BIT9 toggled if track belongs to a pure K0s
160 // BIT10 toggled if track belongs to a pure Lambda
161 // BIT11 toggled if track belongs to a pure ALambda
f6e67fe7 162 ULong_t fMoreFlags; // Space reserved for more information which might be needed later for analysis
163
240ed454 164 AliReducedTrack(const AliReducedTrack &c);
165 AliReducedTrack& operator= (const AliReducedTrack &c);
166
6ab32c51 167 ClassDef(AliReducedTrack, 4);
240ed454 168};
169
170
171//_____________________________________________________________________
172class AliReducedPair : public TObject {
173
174 friend class AliAnalysisTaskReducedTree; // friend analysis task which fills the object
175
176 public:
177 enum CandidateType {
178 kK0sToPiPi=0,
179 kPhiToKK,
180 kLambda0ToPPi,
181 kALambda0ToPPi,
182 kJpsiToEE,
183 kUpsilon,
f6e67fe7 184 kGammaConv,
240ed454 185 kNMaxCandidateTypes
186 };
187 AliReducedPair();
188 AliReducedPair(const AliReducedPair &c);
189 ~AliReducedPair();
190
191 // getters
192 Char_t CandidateId() const {return fCandidateId;}
193 Char_t PairType() const {return fPairType;}
194 Int_t LegId(Int_t leg) const {return (leg==0 || leg==1 ? fLegIds[leg] : -1);}
f6e67fe7 195 Float_t Mass(Int_t idx=0) const {return (idx>=0 && idx<4 ? fMass[idx] : -999.);}
240ed454 196 Float_t Px() const {return fPt*TMath::Cos(fPhi);}
197 Float_t Py() const {return fPt*TMath::Sin(fPhi);}
198 Float_t Pz() const {return fPt*TMath::SinH(fEta);}
199 Float_t P() const {return fPt*TMath::CosH(fEta);}
200 Float_t Phi() const {return fPhi;}
201 Float_t Pt() const {return fPt;}
202 Float_t Eta() const {return fEta;}
203 Float_t Energy() const;
204 Float_t Rapidity() const;
205 Float_t Theta() const {return TMath::ACos(TMath::TanH(fEta));}
206 Float_t Lxy() const {return fLxy;}
6ab32c51 207 Float_t DecayRadius() const {return fLxy;}
240ed454 208 Float_t LxyErr() const {return fLxyErr;}
f6e67fe7 209 Float_t PointingAngle() const {return fPointingAngle;}
2ed1b6ff 210 Float_t Chi2() const {return fChisquare;}
240ed454 211 Bool_t IsOnTheFly() const {return fPairType;}
0c09cae4 212 Bool_t IsPureV0K0s() const {return (fMCid&(UInt_t(1)<<1));}
213 Bool_t IsPureV0Lambda() const {return (fMCid&(UInt_t(1)<<2));}
214 Bool_t IsPureV0ALambda() const {return (fMCid&(UInt_t(1)<<3));}
215 Bool_t IsPureV0Gamma() const {return (fMCid&(UInt_t(1)<<4));}
240ed454 216 UInt_t MCid() const {return fMCid;}
217 Bool_t CheckMC(const Int_t flag) const {return (flag<32 ? (fMCid&(1<<flag)) : kFALSE);}
218
219 private:
220 Char_t fCandidateId; // candidate type (K0s, Lambda, J/psi, phi, etc)
221 Char_t fPairType; // 0 ++; 1 +-; 2 -- for dielectron pairs; 0- offline, 1- on the fly for V0 candidates
222 UShort_t fLegIds[2]; // leg ids
f6e67fe7 223 Float_t fMass[4]; // invariant mass for pairs (3 extra mass values for other V0 pid assumptions)
224 // idx=0 -> K0s assumption; idx=1 -> Lambda; idx=2 -> anti-Lambda; idx=3 -> gamma conversion
240ed454 225 Float_t fPhi; // pair phi in the [0,2*pi) interval
226 Float_t fPt; // pair pt
227 Float_t fEta; // pair eta
2ed1b6ff 228 Float_t fLxy; // pseudo-proper decay length (pair candidates) or radius of the secondary vertex for V0s
240ed454 229 Float_t fLxyErr; // error on Lxy
f6e67fe7 230 Float_t fPointingAngle; // angle between the pair momentum vector and the secondary vertex position vector
2ed1b6ff 231 Float_t fChisquare; // chi2 for the legs matching
240ed454 232 UInt_t fMCid; // Bit map with Monte Carlo info about the pair
233
234 AliReducedPair& operator= (const AliReducedPair &c);
235
2ed1b6ff 236 ClassDef(AliReducedPair, 3);
240ed454 237};
238
239
6ab32c51 240//_____________________________________________________________________
241class AliReducedFMD : public TObject {
242
243 friend class AliAnalysisTaskReducedTree; // friend analysis task which fills the object
244
245 public:
246 AliReducedFMD();
247 ~AliReducedFMD();
248
249 // getters
250 UShort_t Multiplicity() const {return fMultiplicity;}
251 //Float_t Eta() const {return fEta;}
252 UShort_t Id() const {return fId;}
253
254 //void SetIgnoreSteamer();
255
256 private:
257
258 UShort_t fMultiplicity;
259 //Float_t fEta;
260 UShort_t fId;
261
262
263 AliReducedFMD(const AliReducedFMD &c);
264 AliReducedFMD& operator= (const AliReducedFMD &c);
265
266 ClassDef(AliReducedFMD, 1);
267};
268
269
240ed454 270//_________________________________________________________________________
271class AliReducedEventFriend : public TObject {
272
273 friend class AliAnalysisTaskReducedTree; // friend analysis task which fills the object
274
275 public:
276 enum EventPlaneStatus {
277 kRaw=0,
278 kCalibrated,
279 kRecentered,
280 kShifted,
281 kNMaxFlowFlags
282 };
283 enum EventPlaneDetector {
284 kTPC=0,
285 kTPCptWeights,
286 kTPCpos,
287 kTPCneg,
288 kVZEROA,
289 kVZEROC,
290 kFMD,
291 kZDCA,
292 kZDCC,
293 kNdetectors
294 };
295
296 AliReducedEventFriend();
297 ~AliReducedEventFriend();
298
299 Double_t Qx(Int_t det, Int_t harmonic) const {return (det>=0 && det<kNdetectors && harmonic>0 && harmonic<=fgkNMaxHarmonics ? fQvector[det][harmonic-1][0] : -999.);}
300 Double_t Qy(Int_t det, Int_t harmonic) const {return (det>=0 && det<kNdetectors && harmonic>0 && harmonic<=fgkNMaxHarmonics ? fQvector[det][harmonic-1][1] : -999.);}
301 Double_t EventPlane(Int_t det, Int_t h) const;
c243cfc4 302 UChar_t GetEventPlaneStatus(Int_t det, Int_t h) const {return (det>=0 && det<kNdetectors && h>0 && h<=fgkNMaxHarmonics ? fEventPlaneStatus[det][h-1] : UChar_t(255));}
240ed454 303 Bool_t CheckEventPlaneStatus(Int_t det, Int_t h, EventPlaneStatus flag) const;
304 void CopyEvent(const AliReducedEventFriend* event);
305
306 void SetQx(Int_t det, Int_t harmonic, Float_t qx) { if(det>=0 && det<kNdetectors && harmonic>0 && harmonic<=fgkNMaxHarmonics) fQvector[det][harmonic-1][0]=qx;}
307 void SetQy(Int_t det, Int_t harmonic, Float_t qy) { if(det>=0 && det<kNdetectors && harmonic>0 && harmonic<=fgkNMaxHarmonics) fQvector[det][harmonic-1][1]=qy;}
308 void SetEventPlaneStatus(Int_t det, Int_t harmonic, EventPlaneStatus status) {
309 if(det>=0 && det<kNdetectors && harmonic>0 && harmonic<=fgkNMaxHarmonics)
310 fEventPlaneStatus[det][harmonic-1] |= (1<<status);
311 }
312
313 private:
314 // Q-vectors for the first 10 harmonics from TPC, VZERO, FMD and ZDC detectors
315 Double_t fQvector[kNdetectors][fgkNMaxHarmonics][2]; // Q vector components for all detectors and 6 harmonics
316 UChar_t fEventPlaneStatus[kNdetectors][fgkNMaxHarmonics]; // Bit maps for the event plane status (1 char per detector and per harmonic)
317
318 void ClearEvent();
319 AliReducedEventFriend(const AliReducedEventFriend &c);
320 AliReducedEventFriend& operator= (const AliReducedEventFriend &c);
321
322 ClassDef(AliReducedEventFriend, 1);
323};
324
325
326//_________________________________________________________________________
327class AliReducedCaloCluster : public TObject {
328
329 friend class AliAnalysisTaskReducedTree; // friend analysis task which fills the object
330
331 public:
332 enum ClusterType {
333 kUndefined=0, kEMCAL, kPHOS
334 };
335
336 AliReducedCaloCluster();
337 ~AliReducedCaloCluster();
338
6ab32c51 339 Bool_t IsEMCAL() const {return (fType==kEMCAL ? kTRUE : kFALSE);}
340 Bool_t IsPHOS() const {return (fType==kPHOS ? kTRUE : kFALSE);}
341 Float_t Energy() const {return fEnergy;}
342 Float_t Dx() const {return fTrackDx;}
343 Float_t Dz() const {return fTrackDz;}
344 Float_t M20() const {return fM20;}
345 Float_t M02() const {return fM02;}
346 Float_t Dispersion() const {return fDispersion;}
240ed454 347
348 private:
349 Char_t fType; // cluster type (EMCAL/PHOS)
350 Float_t fEnergy; // cluster energy
351 Float_t fTrackDx; // distance to closest track in phi
352 Float_t fTrackDz; // distance to closest track in z
0c09cae4 353 Float_t fM20; // short axis
354 Float_t fM02; // long axis
355 Float_t fDispersion; // dispersion
240ed454 356
357 AliReducedCaloCluster(const AliReducedCaloCluster &c);
358 AliReducedCaloCluster& operator= (const AliReducedCaloCluster &c);
359
0c09cae4 360 ClassDef(AliReducedCaloCluster, 2);
240ed454 361};
362
363
364//_________________________________________________________________________
365class AliReducedEvent : public TObject {
366
367 friend class AliAnalysisTaskReducedTree; // friend analysis task which fills the object
368
369 public:
370 AliReducedEvent();
371 AliReducedEvent(const Char_t* name);
372 ~AliReducedEvent();
373
374 // getters
6ab32c51 375 ULong64_t EventTag() const {return fEventTag;}
376 Bool_t EventTag(UShort_t bit) const {return (bit<8*sizeof(ULong64_t) ? (fEventTag&(ULong64_t(1)<<bit)) : kFALSE);}
377 Int_t EventNumberInFile() const {return fEventNumberInFile;}
378 UInt_t L0TriggerInputs() const {return fL0TriggerInputs;}
379 Bool_t L0TriggerInput(UShort_t bit) const {return (bit<8*sizeof(UInt_t) ? (fL0TriggerInputs&(UInt_t(1)<<bit)) : kFALSE);}
380 UInt_t L1TriggerInputs() const {return fL1TriggerInputs;}
381 Bool_t L1TriggerInput(UShort_t bit) const {return (bit<8*sizeof(UInt_t) ? (fL1TriggerInputs&(UInt_t(1)<<bit)) : kFALSE);}
382 UShort_t L2TriggerInputs() const {return fL2TriggerInputs;}
383 Bool_t L2TriggerInput(UShort_t bit) const {return (bit<8*sizeof(UShort_t) ? (fL2TriggerInputs&(UShort_t(1)<<bit)) : kFALSE);}
240ed454 384 Int_t RunNo() const {return fRunNo;}
385 UShort_t BC() const {return fBC;}
2ed1b6ff 386 UInt_t TimeStamp() const {return fTimeStamp;}
387 UInt_t EventType() const {return fEventType;}
240ed454 388 ULong64_t TriggerMask() const {return fTriggerMask;}
389 Bool_t IsPhysicsSelection() const {return fIsPhysicsSelection;}
2ed1b6ff 390 Bool_t IsSPDPileup() const {return fIsSPDPileup;}
6ab32c51 391 Bool_t IsSPDPileupMultBins() const {return fIsSPDPileupMultBins;}
392 Int_t IRIntClosestIntMap(Int_t id) const {return (id>=0 && id<2 ? fIRIntClosestIntMap[id] : -999);}
393 Bool_t IsFMDReduced() const {return fIsFMDReduced;}
240ed454 394 Float_t Vertex(Int_t axis) const {return (axis>=0 && axis<=2 ? fVtx[axis] : 0);}
395 Int_t VertexNContributors() const {return fNVtxContributors;}
396 Float_t VertexTPC(Int_t axis) const {return (axis>=0 && axis<=2 ? fVtxTPC[axis] : 0);}
397 Int_t VertexTPCContributors() const {return fNVtxTPCContributors;}
6ab32c51 398 Float_t VertexTZERO() const {return fT0zVertex;}
2ed1b6ff 399 Int_t NpileupSPD() const {return fNpileupSPD;}
400 Int_t NpileupTracks() const {return fNpileupTracks;}
401 Int_t NPMDtracks() const {return fNPMDtracks;}
402 Int_t NTRDtracks() const {return fNTRDtracks;}
403 Int_t NTRDtracklets() const {return fNTRDtracklets;}
240ed454 404 Float_t CentralityVZERO() const {return fCentrality[0];}
405 Float_t CentralitySPD() const {return fCentrality[1];}
406 Float_t CentralityTPC() const {return fCentrality[2];}
407 Float_t CentralityZEMvsZDC() const {return fCentrality[3];}
408 Int_t CentralityQuality() const {return fCentQuality;}
409 Int_t NV0CandidatesTotal() const {return fNV0candidates[0];}
410 Int_t NV0Candidates() const {return fNV0candidates[1];}
411 Int_t NDielectrons() const {return fNDielectronCandidates;}
412 Int_t NTracksTotal() const {return fNtracks[0];}
413 Int_t NTracks() const {return fNtracks[1];}
414 Int_t SPDntracklets() const {return fSPDntracklets;}
6ab32c51 415 Int_t SPDntracklets(Int_t bin) const {return (bin>=0 && bin<32 ? fSPDntrackletsEta[bin] : -999);}
2ed1b6ff 416 Int_t TracksPerTrackingFlag(Int_t flag) const {return (flag>=0 && flag<32 ? fNtracksPerTrackingFlag[flag] : -999);}
6ab32c51 417 UShort_t NFMDchannels(Int_t det) const {return (det>=0 && det<5 ? fNFMDchannels[det] : 0);}
418 UShort_t FMDtotalMult(Int_t det) const {return (det>=0 && det<5 ? fFMDtotalMult[det] : 0);}
240ed454 419
420 Float_t MultChannelVZERO(Int_t channel) const {return (channel>=0 && channel<=63 ? fVZEROMult[channel] : -999.);}
421 Float_t MultVZEROA() const;
422 Float_t MultVZEROC() const;
423 Float_t MultVZERO() const;
424 Float_t MultRingVZEROA(Int_t ring) const;
425 Float_t MultRingVZEROC(Int_t ring) const;
426
6ab32c51 427 Float_t AmplitudeTZEROA() const;
428 Float_t AmplitudeTZEROC() const;
429 Float_t AmplitudeTZERO() const;
430 Float_t AmplitudeTZEROch(Int_t ch) const {return (ch>=0 && ch<=25 ? fT0amplitude[ch] : -999.);}
431 Float_t EventTZEROStartTime() const {return fT0start;}
432 Float_t EventTZEROStartTimeTOFfirst(Int_t side) const {return (side>=0 && side<3 ? fT0TOF[side] : -999.);}
433 Float_t EventTZEROStartTimeTOFbest(Int_t side) const {return (side>=0 && side<3 ? fT0TOFbest[side] : -999.);}
434 Bool_t IsPileupTZERO() const {return fT0pileup;}
435 Bool_t IsSatteliteCollisionTZERO() const {return fT0sattelite;}
436
437 Float_t EnergyZDCnTree(UShort_t channel) const {return (channel<10 ? fZDCnEnergy[channel] : -999.);};
438 Float_t EnergyZDCpTree(UShort_t channel) const {return (channel<10 ? fZDCpEnergy[channel] : -999.);};
439 Float_t EnergyZDCn(Int_t channel) const;
440 Float_t EnergyZDCA() const;
441 Float_t EnergyZDCC() const;
442 Float_t EnergyZDC() const;
443
444 Bool_t TestEventTag(UShort_t iflag) const {return (iflag<8*sizeof(ULong64_t) ? fEventTag&(ULong64_t(1)<<iflag) : kFALSE);}
445 Bool_t SetEventTag(UShort_t iflag) {if (iflag>=8*sizeof(ULong64_t)) return kFALSE; fEventTag|=(ULong64_t(1)<<iflag); return kTRUE;}
240ed454 446
447 AliReducedTrack* GetTrack(Int_t i) const
448 {return (i<fNtracks[1] ? (AliReducedTrack*)fTracks->At(i) : 0x0);}
449 AliReducedPair* GetV0Pair(Int_t i) const
450 {return (i>=0 && i<fNV0candidates[1] ? (AliReducedPair*)fCandidates->At(i) : 0x0);}
451 AliReducedPair* GetDielectronPair(Int_t i) const
452 {return (i>=0 && i<fNDielectronCandidates ? (AliReducedPair*)fCandidates->At(i+fNV0candidates[1]) : 0x0);}
453 TClonesArray* GetPairs() const {return fCandidates;}
454 TClonesArray* GetTracks() const {return fTracks;}
6ab32c51 455 TClonesArray* GetFMD(Int_t det) const {return (det==0 ? fFMD1 :
456 (det==1 ? fFMD2I :
457 (det==2 ? fFMD2O :
458 (det==3 ? fFMD3I :
459 (det==4 ? fFMD3O :
460 0)))));}
461 TClonesArray* GetFMD1() const {return fFMD1;}
462 TClonesArray* GetFMD2I() const {return fFMD2I;}
463 TClonesArray* GetFMD2O() const {return fFMD2O;}
464 TClonesArray* GetFMD3I() const {return fFMD3I;}
465 TClonesArray* GetFMD3O() const {return fFMD3O;}
466 AliReducedFMD* GetFMD1Channel(UShort_t ch) const {return (ch<fNFMDchannels[0] ? (AliReducedFMD*)fFMD1->At(ch) : 0x0);}
467 AliReducedFMD* GetFMD2IChannel(UShort_t ch) const {return (ch<fNFMDchannels[1] ? (AliReducedFMD*)fFMD2I->At(ch) : 0x0);}
468 AliReducedFMD* GetFMD2OChannel(UShort_t ch) const {return (ch<fNFMDchannels[2] ? (AliReducedFMD*)fFMD2O->At(ch) : 0x0);}
469 AliReducedFMD* GetFMD3IChannel(UShort_t ch) const {return (ch<fNFMDchannels[3] ? (AliReducedFMD*)fFMD3I->At(ch) : 0x0);}
470 AliReducedFMD* GetFMD3OChannel(UShort_t ch) const {return (ch<fNFMDchannels[4] ? (AliReducedFMD*)fFMD3O->At(ch) : 0x0);}
471
240ed454 472 Int_t GetNCaloClusters() const {return fNCaloClusters;}
473 AliReducedCaloCluster* GetCaloCluster(Int_t i) const
474 {return (i>=0 && i<fNCaloClusters ? (AliReducedCaloCluster*)fCaloClusters->At(i) : 0x0);}
475
476 void GetQvector(Double_t Qvec[][2], Int_t det, Float_t etaMin=-0.8, Float_t etaMax=+0.8, Bool_t (*IsTrackSelected)(AliReducedTrack*)=NULL);
477 Int_t GetTPCQvector(Double_t Qvec[][2], Int_t det, Float_t etaMin=-0.8, Float_t etaMax=+0.8, Bool_t (*IsTrackSelected)(AliReducedTrack*)=NULL);
478 void GetVZEROQvector(Double_t Qvec[][2], Int_t det) ;
479 void GetVZEROQvector(Double_t Qvec[][2], Int_t det, Float_t* vzeroMult);
480 void GetZDCQvector(Double_t Qvec[][2], Int_t det) const;
6ab32c51 481 void GetZDCQvector(Double_t Qvec[][2], Int_t det, const Float_t* zdcEnergy) const;
f6e67fe7 482 void SubtractParticleFromQvector(AliReducedTrack* particle, Double_t Qvec[][2], Int_t det,
483 Float_t etaMin=-0.8, Float_t etaMax=+0.8,
484 Bool_t (*IsTrackSelected)(AliReducedTrack*)=NULL);
240ed454 485
486 private:
6ab32c51 487 ULong64_t fEventTag; // Event tags to be used either during analysis or to filter events
488 Int_t fEventNumberInFile; // Event number in ESD file
489 UInt_t fL0TriggerInputs; // L0 trigger inputs
490 UInt_t fL1TriggerInputs; // L1 trigger inputs
491 UShort_t fL2TriggerInputs; // L2 trigger inputs
240ed454 492 Int_t fRunNo; // run number
493 UShort_t fBC; // bunch crossing
2ed1b6ff 494 UInt_t fTimeStamp; // time stamp of the event (NEW)
495 UInt_t fEventType; // event type (NEW)
240ed454 496 ULong64_t fTriggerMask; // trigger mask
497 Bool_t fIsPhysicsSelection; // PhysicsSelection passed event
2ed1b6ff 498 Bool_t fIsSPDPileup; // identified as pileup event by SPD
6ab32c51 499 Bool_t fIsSPDPileupMultBins; // identified as pileup event by SPD in multiplicity bins
500 Int_t fIRIntClosestIntMap[2]; // out of bunch interactions, [0]-Int1, [1]-Int2
501 Bool_t fIsFMDReduced; // FMD info, if present, is reduced (NEW)
240ed454 502 Float_t fVtx[3]; // global event vertex vector in cm
503 Int_t fNVtxContributors; // global event vertex contributors
504 Float_t fVtxTPC[3]; // TPC only event vertex
505 Int_t fNVtxTPCContributors; // TPC only event vertex contributors
2ed1b6ff 506 Int_t fNpileupSPD; // number of pileup vertices from SPD (NEW)
507 Int_t fNpileupTracks; // number of pileup vertices from tracks (NEW)
508 Int_t fNPMDtracks; // number of PMD tracks (NEW)
509 Int_t fNTRDtracks; // number of TRD tracks (NEW)
510 Int_t fNTRDtracklets; // number of TRD tracklets (NEW)
240ed454 511 Float_t fCentrality[4]; // centrality; 0-VZERO, 1-SPD, 2-TPC, 3-ZEMvsZDC
512 Int_t fCentQuality; // quality flag for the centrality
513 Int_t fNV0candidates[2]; // number of V0 candidates, [0]-total, [1]-selected for the tree
514 Int_t fNDielectronCandidates; // number of pairs selected as dielectrons
515 Int_t fNtracks[2]; // number of tracks, [0]-total, [1]-selected for the tree
516 Int_t fSPDntracklets; // number of SPD tracklets in |eta|<1.0
6ab32c51 517 Int_t fSPDntrackletsEta[32]; // number of SPD tracklets in equal eta bins between -1.6 --> +1.6
518 Int_t fNtracksPerTrackingFlag[32]; // number of tracks for each tracking status bit
2ed1b6ff 519
240ed454 520 Float_t fVZEROMult[64]; // VZERO multiplicity in all 64 channels
6ab32c51 521 Float_t fZDCnEnergy[10]; // neutron ZDC energy in all 8 channels
522 Float_t fZDCpEnergy[10]; // neutron ZDC energy in all 8 channels
523 Float_t fT0amplitude[26]; // T0 amplitude in all 24 channels
524 Float_t fT0TOF[3]; // T0 timing for A&C, A, and C (first time)
525 Float_t fT0TOFbest[3]; // T0 timing for A&C, A, and C (best time)
526 Float_t fT0zVertex; // T0 z vertex estimation
527 Float_t fT0start; // T0 timing
528 Bool_t fT0pileup; // TZERO pileup flag
529 Bool_t fT0sattelite; // TZERO flag for collisions from sattelite bunches
240ed454 530
531 TClonesArray* fTracks; //-> array containing global tracks
532 static TClonesArray* fgTracks; // global tracks
533
534 TClonesArray* fCandidates; //-> array containing pair candidates
535 static TClonesArray* fgCandidates; // pair candidates
536
6ab32c51 537 UShort_t fNFMDchannels[5]; // number of FMD channels read out (NEW)
538 UShort_t fFMDtotalMult[5]; // number of FMD channels read out (NEW)
539 TClonesArray* fFMD1; //-> array containing fmd readout (NEW)
540 static TClonesArray* fgFMD1; // fmd readout (NEW)
541 TClonesArray* fFMD2I; //-> array containing fmd readout (NEW)
542 static TClonesArray* fgFMD2I; // fmd readout (NEW)
543 TClonesArray* fFMD2O; //-> array containing fmd readout (NEW)
544 static TClonesArray* fgFMD2O; // fmd readout (NEW)
545 TClonesArray* fFMD3I; //-> array containing fmd readout (NEW)
546 static TClonesArray* fgFMD3I; // fmd readout (NEW)
547 TClonesArray* fFMD3O; //-> array containing fmd readout (NEW)
548 static TClonesArray* fgFMD3O; // fmd readout (NEW)
549
240ed454 550 Int_t fNCaloClusters; // number of calorimeter clusters
551 TClonesArray* fCaloClusters; //-> array containing calorimeter clusters
552 static TClonesArray* fgCaloClusters; // calorimeter clusters
553
554 void ClearEvent();
555 AliReducedEvent(const AliReducedEvent &c);
556 AliReducedEvent& operator= (const AliReducedEvent &c);
557
6ab32c51 558 ClassDef(AliReducedEvent, 5);
240ed454 559};
560
561//_______________________________________________________________________________
562inline UShort_t AliReducedTrack::ITSncls() const
563{
564 //
565 // ITS number of clusters from the cluster map
566 //
567 UShort_t ncls=0;
568 for(Int_t i=0; i<6; ++i) ncls += (ITSLayerHit(i) ? 1 : 0);
569 return ncls;
570}
571
572
573//_______________________________________________________________________________
574inline Int_t AliReducedTrack::TPCClusterMapBitsFired() const
575{
576 //
577 // Count the number of bits fired in the TPC cluster map
578 //
579 Int_t nbits=0;
580 for(Int_t i=0; i<8; ++i) nbits += (TPCClusterMapBitFired(i) ? 1 : 0);
581 return nbits;
582}
583
584
585//_______________________________________________________________________________
586inline Float_t AliReducedPair::Energy() const
587{
588 //
589 // Return the energy
590 //
591 Float_t mass=fMass[0];
592 switch (fCandidateId) {
593 case kK0sToPiPi:
594 mass = fMass[0];
595 break;
596 case kLambda0ToPPi:
597 mass = fMass[1];
598 break;
599 case kALambda0ToPPi:
600 mass = fMass[2];
601 break;
f6e67fe7 602 case kGammaConv:
603 mass = fMass[3];
604 break;
240ed454 605 default:
606 mass = fMass[0];
607 break;
608 }
609 Float_t p = P();
610 return TMath::Sqrt(mass*mass+p*p);
611}
612
613
614//_______________________________________________________________________________
615inline Float_t AliReducedPair::Rapidity() const
616{
617 //
618 // return rapidity
619 //
620 Float_t e = Energy();
621 Float_t pz = Pz();
622 if(e-TMath::Abs(pz)>1.0e-10)
623 return 0.5*TMath::Log((e+pz)/(e-pz));
624 else
625 return -999.;
626}
627
628
629//_______________________________________________________________________________
630inline Double_t AliReducedEventFriend::EventPlane(Int_t det, Int_t harmonic) const
631{
632 //
633 // Event plane from detector "det" and harmonic "harmonic"
634 //
635 if(det<0 || det>=kNdetectors || harmonic<1 || harmonic>fgkNMaxHarmonics) return -999.;
636 return TMath::ATan2(fQvector[det][harmonic-1][1], fQvector[det][harmonic-1][0])/Double_t(harmonic);
637}
638
639//_______________________________________________________________________________
640inline Bool_t AliReducedEventFriend::CheckEventPlaneStatus(Int_t det, Int_t h, EventPlaneStatus flag) const {
641 //
642 // Check the status of the event plane for a given detector and harmonic
643 //
644 if(det<0 || det>=kNdetectors || h<1 || h>fgkNMaxHarmonics) return kFALSE;
3389fd7d 645 return (flag<kNMaxFlowFlags ? (fEventPlaneStatus[det][h-1]&(1<<flag)) : kFALSE);
240ed454 646}
647
648#endif