-
Notifications
You must be signed in to change notification settings - Fork 257
/
AliAODEvent.h
404 lines (350 loc) · 18 KB
/
AliAODEvent.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
#ifndef AliAODEvent_H
#define AliAODEvent_H
/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
/* $Id$ */
/// \class AliAODEvent
/// \brief AOD base class
///
/// \author Markus Oldenburg, CERN
#include <TBuffer.h>
#include <TClonesArray.h>
#include <TList.h>
#include <TTree.h>
#include <TNamed.h>
#include "AliVEvent.h"
#include "AliVParticle.h"
#include "AliVHeader.h"
#include "AliAODHeader.h"
#include "AliNanoAODHeader.h"
#include "AliAODTrack.h"
#include "AliAODVertex.h"
#include "AliAODv0.h"
#include "AliAODkink.h"
#include "AliAODcascade.h"
#include "AliAODTracklets.h"
#include "AliAODJet.h"
#include "AliAODCaloCells.h"
#include "AliAODCaloCluster.h"
#include "AliAODCaloTrigger.h"
#include "AliAODPmdCluster.h"
#include "AliAODFmdCluster.h"
#include "AliAODDimuon.h"
#include "AliAODTZERO.h"
#include "AliAODVZERO.h"
#include "AliAODHMPIDrings.h"
#include "AliAODZDC.h"
#include "AliAODAD.h"
#include "AliAODTrdTrack.h"
class TTree;
class TFolder;
class AliCentrality;
class AliEventplane;
class AliAODEvent : public AliVEvent {
public:
enum AODListIndex_t {kAODHeader,
kAODTracks,
kAODVertices,
kAODv0,
kAODkink,
kAODcascade,
kAODTracklets,
kAODJets,
kAODEmcalCells,
kAODPhosCells,
kAODCaloClusters,
kAODEMCALTrigger,
kAODPHOSTrigger,
kAODFmdClusters,
kAODPmdClusters,
kAODHMPIDrings,
kAODDimuons,
kAODTZERO,
kAODVZERO,
kAODZDC,
kAODAD,
kTOFHeader,
kAODTrdTracks,
kAODListN
};
AliAODEvent();
virtual ~AliAODEvent();
AliAODEvent(const AliAODEvent& aodevent);
AliAODEvent& operator=(const AliAODEvent& aodevent);
void AddObject(TObject *obj);
void RemoveObject(TObject *obj);
TObject *FindListObject(const char *objName) const;
TList *GetList() const { return fAODObjects; }
void SetConnected(Bool_t conn=kTRUE) {fConnected=conn;}
Bool_t GetConnected() const {return fConnected;}
Bool_t AreTracksConnected() const {return fTracksConnected;}
// -- Header
AliVHeader *GetHeader() const { return fHeader; }
void AddHeader(const AliVHeader* hdx)
{
delete fHeader;
if(dynamic_cast<const AliAODHeader*>(hdx)) {
fHeader = new AliAODHeader(*(const AliAODHeader*)hdx);
} else if (dynamic_cast<const AliNanoAODHeader*>(hdx)) {
fHeader = new AliNanoAODHeader(*(const AliNanoAODHeader*)hdx);
}
else {
AliError(Form("Unknown header type %s", hdx->ClassName()));
}
fAODObjects->FirstLink()->SetObject(fHeader);
}
virtual Bool_t InitMagneticField() const {return fHeader ? fHeader->InitMagneticField() : kFALSE;}
void SetDAQAttributes(UInt_t attributes) {if (fHeader) fHeader->SetDAQAttributes(attributes);}
UInt_t GetDAQAttributes() const {return fHeader ? fHeader->GetDAQAttributes() : 0;}
Bool_t IsIncompleteDAQ();
virtual Bool_t IsDetectorOn(ULong_t detMask) const { return fHeader ? fHeader->IsDetectorOn(UInt_t(detMask)) : kTRUE; }
// setters and getters for header information
void SetRunNumber(Int_t n) {if (fHeader) fHeader->SetRunNumber(n);}
void SetPeriodNumber(UInt_t n){if (fHeader) fHeader->SetPeriodNumber(n);}
void SetOrbitNumber(UInt_t n) {if (fHeader) fHeader->SetOrbitNumber(n);}
void SetBunchCrossNumber(UShort_t n) {if (fHeader) fHeader->SetBunchCrossNumber(n);}
void SetTimeStamp(UInt_t tstamp) {if (fHeader) fHeader->SetTimeStamp(tstamp);}
void SetMagneticField(Double_t mf){if (fHeader) fHeader->SetMagneticField(mf);}
void SetMuonMagFieldScale(Double_t mf){if (fHeader) fHeader->SetMuonMagFieldScale(mf);}
void SetDiamond(Float_t xy[2],Float_t cov[3]){if (fHeader) fHeader->SetDiamond(xy,cov);}
void SetDiamondZ(Float_t z, Float_t sig2z){if (fHeader) fHeader->SetDiamondZ(z,sig2z);}
Int_t GetRunNumber() const {return fHeader ? fHeader->GetRunNumber() : -999;}
UInt_t GetPeriodNumber() const {return fHeader ? fHeader->GetPeriodNumber() : 0;}
UInt_t GetOrbitNumber() const {return fHeader ? fHeader->GetOrbitNumber() : 0;}
UShort_t GetBunchCrossNumber() const {return fHeader ? fHeader->GetBunchCrossNumber() : 0;}
UInt_t GetTimeStamp() const {return fHeader ? fHeader->GetTimeStamp() : 0;}
Double_t GetMagneticField() const {return fHeader ? fHeader->GetMagneticField() : -999.;}
Double_t GetMuonMagFieldScale() const {return fHeader ? fHeader->GetMuonMagFieldScale() : -999.;}
Double_t GetDiamondX() const {return fHeader ? fHeader->GetDiamondX() : -999.;}
Double_t GetDiamondY() const {return fHeader ? fHeader->GetDiamondY() : -999.;}
Double_t GetDiamondZ() const {return fHeader ? fHeader->GetDiamondZ() : -999.;}
void GetDiamondCovXY(Float_t cov[3]) const {cov[0]=-999.; if(fHeader) fHeader->GetDiamondCovXY(cov);}
Double_t GetSigma2DiamondX() const {return fHeader ? fHeader->GetSigma2DiamondX() : -999.;}
Double_t GetSigma2DiamondY() const {return fHeader ? fHeader->GetSigma2DiamondY() : -999.;}
Double_t GetSigma2DiamondZ() const {return fHeader ? fHeader->GetSigma2DiamondZ() : -999.;}
void SetEventType(UInt_t eventType){fHeader->SetEventType(eventType);}
void SetTriggerMask(ULong64_t n) {fHeader->SetTriggerMask(n);}
void SetTriggerCluster(UChar_t n) {fHeader->SetTriggerCluster(n);}
UInt_t GetEventType() const { return fHeader ? fHeader->GetEventType() : 0;}
ULong64_t GetTriggerMask() const { return fHeader ? fHeader->GetTriggerMask() : 0;}
UChar_t GetTriggerCluster() const { return fHeader ? fHeader->GetTriggerCluster() : 0;}
TString GetFiredTriggerClasses()const { return fHeader->GetFiredTriggerClasses();};
Double_t GetZDCN1Energy() const { return fHeader ? fHeader->GetZDCN1Energy() : -999.; }
Double_t GetZDCP1Energy() const { return fHeader ? fHeader->GetZDCP1Energy() : -999.; }
Double_t GetZDCN2Energy() const { return fHeader ? fHeader->GetZDCN2Energy() : -999.; }
Double_t GetZDCP2Energy() const { return fHeader ? fHeader->GetZDCP2Energy() : -999.; }
Double_t GetZDCEMEnergy(Int_t i) const { return fHeader ? fHeader->GetZDCEMEnergy(i) : -999.; }
Int_t GetNumberOfESDTracks() const { return fHeader ? fHeader->GetNumberOfESDTracks() : 0; }
Int_t GetNumberOfTPCTracks() const { return fHeader ? fHeader->GetNumberOfTPCTracks() : 0; }
Int_t GetNTPCTrackBeforeClean() const { return fHeader ? ((AliAODHeader*)fHeader)->GetNTPCTrackBeforeClean() : 0;}
Int_t GetNumberOfTPCClusters() const { return fHeader ? fHeader->GetNumberOfTPCClusters() : 0; }
Int_t GetNumberOfITSClusters(Int_t lr) const {return fHeader ? (int)fHeader->GetNumberOfITSClusters(lr) : 0;}
void SetTOFHeader(const AliTOFHeader * tofEventTime);
const AliTOFHeader *GetTOFHeader() const {return fTOFHeader;}
Float_t GetEventTimeSpread() const {if (fTOFHeader) return fTOFHeader->GetT0spread(); else return 0.;}
Float_t GetTOFTimeResolution() const {if (fTOFHeader) return fTOFHeader->GetTOFResolution(); else return 0.;}
Float_t GetT0spread(Int_t i) const {return fHeader->GetT0spread(i);}
// -- Tracks
TClonesArray *GetTracks() const { return fTracks; }
void ConnectTracks();
Int_t GetNumberOfTracks() const { return fTracks? fTracks->GetEntriesFast() : 0; }
AliVTrack *GetTrack(Int_t nTrack) const { return fTracks ? (AliVTrack*)fTracks->UncheckedAt(nTrack):0; }
Int_t AddTrack(const AliAODTrack* trk);
Int_t GetMuonTracks(TRefArray *muonTracks) const;
Int_t GetNumberOfMuonTracks() const;
Int_t GetMuonGlobalTracks(TRefArray *muonGlobalTracks) const; // AU
Int_t GetNumberOfMuonGlobalTracks() const; // AU
// -- Vertex
TClonesArray *GetVertices() const { return fVertices; }
Int_t GetNumberOfVertices() const { return fVertices?fVertices->GetEntriesFast():0; }
AliAODVertex *GetVertex(Int_t nVertex) const { return fVertices?(AliAODVertex*)fVertices->At(nVertex):0; }
Int_t AddVertex(const AliAODVertex* vtx)
{new((*fVertices)[fVertices->GetEntriesFast()]) AliAODVertex(*vtx); return fVertices->GetEntriesFast()-1;}
// primary vertex
using AliVEvent::GetPrimaryVertex;
using AliVEvent::GetPrimaryVertexSPD;
using AliVEvent::GetPrimaryVertexTPC;
virtual AliAODVertex *GetPrimaryVertex() const { return GetVertex(0); }
virtual AliAODVertex *GetPrimaryVertexSPD() const;
virtual AliAODVertex *GetVertex() const { return GetPrimaryVertexSPD(); }
virtual AliAODVertex *GetPrimaryVertexTPC() const;
virtual AliAODVertex *GetPrimaryVertexTracks() const {return GetVertex(0);}
// -- Pileup vertices
Int_t GetNumberOfPileupVerticesTracks() const;
Int_t GetNumberOfPileupVerticesSPD() const;
virtual AliAODVertex *GetPileupVertexSPD(Int_t iV=0) const;
virtual AliAODVertex *GetPileupVertexTracks(Int_t iV=0) const;
virtual Bool_t IsPileupFromSPD(Int_t minContributors=5, Double_t minZdist=0.8, Double_t nSigmaZdist=3., Double_t nSigmaDiamXY=2., Double_t nSigmaDiamZ=5.) const;
virtual Bool_t IsPileupFromSPDInMultBins() const;
// V0
TClonesArray *GetV0s() const { return fV0s; }
Int_t GetNumberOfV0s() const { return fV0s->GetEntriesFast(); }
using AliVEvent::GetV0;
AliAODv0 *GetV0(Int_t nV0) const { return (AliAODv0*)fV0s->UncheckedAt(nV0); }
Int_t AddV0(const AliAODv0* v0)
{new((*fV0s)[fV0s->GetEntriesFast()]) AliAODv0(*v0); return fV0s->GetEntriesFast()-1;}
// Kinks
TClonesArray *GetKinks() const { return fKinks; }
Int_t GetNumberOfKinks() const { return fKinks ? fKinks->GetEntriesFast() : 0; }
//using AliVEvent::GetKink;
AliAODkink *GetAODkink(Int_t nkink) const { return fKinks ? (AliAODkink*)fKinks->UncheckedAt(nkink) : 0; }
Int_t AddKink(const AliAODkink* kink)
{new((*fKinks)[fKinks->GetEntriesFast()]) AliAODkink(*kink); return fKinks->GetEntriesFast()-1;}
// Cascades
TClonesArray *GetCascades(){
FixCascades();
return fCascades;
}
Int_t GetNumberOfCascades() const { return fCascades->GetEntriesFast(); }
AliAODcascade *GetCascade(Int_t nCasc){
FixCascades();
return (AliAODcascade*)fCascades->UncheckedAt(nCasc);
}
Int_t AddCascade(const AliAODcascade* cascade)
{new((*fCascades)[fCascades->GetEntriesFast()]) AliAODcascade(*cascade); return fCascades->GetEntriesFast()-1;}
// -- EMCAL and PHOS Cluster
TClonesArray *GetCaloClusters() const { return fCaloClusters; }
Int_t GetNumberOfCaloClusters() const { return fCaloClusters?fCaloClusters->GetEntriesFast():0; }
AliAODCaloCluster *GetCaloCluster(Int_t nCluster) const { return fCaloClusters?(AliAODCaloCluster*)fCaloClusters->UncheckedAt(nCluster):0x0; }
Int_t AddCaloCluster(const AliAODCaloCluster* clus)
{new((*fCaloClusters)[fCaloClusters->GetEntriesFast()]) AliAODCaloCluster(*clus); return fCaloClusters->GetEntriesFast()-1;}
AliAODCaloTrigger *GetCaloTrigger(TString calo) const
{
if (calo.Contains("EMCAL")) return fEMCALTrigger;
else
return fPHOSTrigger;
}
Int_t GetEMCALClusters(TRefArray *clusters) const;
Int_t GetPHOSClusters(TRefArray *clusters) const;
// -- FMD Cluster
TClonesArray *GetFmdClusters() const { return fFmdClusters; }
Int_t GetNFmdClusters() const { return fFmdClusters->GetEntriesFast(); }
AliAODFmdCluster *GetFmdCluster(Int_t nCluster) const { return (AliAODFmdCluster*)fFmdClusters->UncheckedAt(nCluster); }
Int_t AddFmdCluster(const AliAODFmdCluster* clus)
{new((*fFmdClusters)[fFmdClusters->GetEntriesFast()]) AliAODFmdCluster(*clus); return fFmdClusters->GetEntriesFast()-1;}
// -- PMD Cluster
TClonesArray *GetPmdClusters() const { return fPmdClusters; }
Int_t GetNPmdClusters() const { return fPmdClusters->GetEntriesFast(); }
AliAODPmdCluster *GetPmdCluster(Int_t nCluster) const { return (AliAODPmdCluster*)fPmdClusters->UncheckedAt(nCluster); }
Int_t AddPmdCluster(const AliAODPmdCluster* clus)
{new((*fPmdClusters)[fPmdClusters->GetEntriesFast()]) AliAODPmdCluster(*clus); return fPmdClusters->GetEntriesFast()-1;}
// -- HMPID objects
TClonesArray *GetHMPIDrings() const {return fHMPIDrings; }
Int_t GetNHMPIDrings() const;
AliAODHMPIDrings *GetHMPIDring(Int_t nRings) const;
Int_t AddHMPIDrings(const AliAODHMPIDrings* ring)
{new((*fHMPIDrings)[fHMPIDrings->GetEntriesFast()]) AliAODHMPIDrings(*ring); return fHMPIDrings->GetEntriesFast()-1;}
AliAODHMPIDrings *GetHMPIDringForTrackID(Int_t trackID) const;
// -- Jet
TClonesArray *GetJets() const { return fJets; }
Int_t GetNJets() const { return fJets?fJets->GetEntriesFast():0; }
AliAODJet *GetJet(Int_t nJet) const { return fJets?(AliAODJet*)fJets->UncheckedAt(nJet):0; }
Int_t AddJet(const AliAODJet* vtx)
{new((*fJets)[fJets->GetEntriesFast()]) AliAODJet(*vtx); return fJets->GetEntriesFast()-1;}
// -- Tracklets
using AliVEvent::GetMultiplicity;
AliAODTracklets *GetTracklets() const { return fTracklets; }
virtual AliAODTracklets *GetMultiplicity() const { return GetTracklets(); }
// -- Calorimeter Cells
AliAODCaloCells *GetEMCALCells() const { return fEmcalCells; }
AliAODCaloCells *GetPHOSCells() const { return fPhosCells; }
const TGeoHMatrix* GetPHOSMatrix(Int_t /*i*/) const { return NULL; }
const TGeoHMatrix* GetEMCALMatrix(Int_t /*i*/)const { return NULL; }
// -- Dimuons (\deprecated)
TClonesArray *GetDimuons() const;
Int_t GetNDimuons() const;
Int_t GetNumberOfDimuons() const;
AliAODDimuon *GetDimuon(Int_t nDimu) const;
Int_t AddDimuon(const AliAODDimuon* dimu);
// // -- TRD
Int_t GetNumberOfTrdTracks() const { return fTrdTracks ? fTrdTracks->GetEntriesFast() : 0; }
AliAODTrdTrack* GetTrdTrack(Int_t i) const {
return (AliAODTrdTrack *) (fTrdTracks ? fTrdTracks->At(i) : 0x0);
}
AliAODTrdTrack& AddTrdTrack(const AliVTrdTrack *track);
// -- Services
void CreateStdContent();
void SetStdNames();
void GetStdContent();
void CreateStdFolders();
void ResetStd(Int_t trkArrSize = 0,
Int_t vtxArrSize = 0,
Int_t v0ArrSize = 0,
Int_t kinkArrSize = 0,
Int_t cascadeArrSize = 0,
Int_t jetSize = 0,
Int_t caloClusSize = 0,
Int_t fmdClusSize = 0,
Int_t pmdClusSize = 0,
Int_t hmpidRingsSize = 0,
Int_t dimuonArrsize =0,
Int_t nTrdTracks = 0
);
void ClearStd();
void Reset();
void ReadFromTree(TTree *tree, Option_t* opt = "");
void WriteToTree(TTree* tree) const {tree->Branch(fAODObjects);}
void Print(Option_t *option="") const;
void MakeEntriesReferencable();
static void AssignIDtoCollection(const TCollection* col);
//Following needed only for mixed event
virtual Int_t EventIndex(Int_t) const {return 0;}
virtual Int_t EventIndexForCaloCluster(Int_t) const {return 0;}
virtual Int_t EventIndexForPHOSCell(Int_t) const {return 0;}
virtual Int_t EventIndexForEMCALCell(Int_t) const {return 0;}
AliCentrality* GetCentrality() {return fHeader->GetCentralityP();}
AliEventplane* GetEventplane() {return fHeader->GetEventplaneP();}
// TZERO
AliAODTZERO *GetTZEROData() const { return fAODTZERO; }
Double32_t GetT0TOF(Int_t icase) const { return fAODTZERO?fAODTZERO->GetT0TOF(icase):999999;}
const Double32_t * GetT0TOF() const { return fAODTZERO?fAODTZERO->GetT0TOF():0x0;}
// VZERO
using AliVEvent::GetVZEROData;
virtual AliAODVZERO *GetVZEROData() const { return fAODVZERO; }
virtual const Float_t* GetVZEROEqFactors() const {return fHeader?fHeader->GetVZEROEqFactors():0x0;}
virtual Float_t GetVZEROEqMultiplicity(Int_t i) const;
virtual void SetVZEROEqFactors(Float_t factors[64]) const {
if(fHeader)
fHeader->SetVZEROEqFactors(factors);}
//ZDC
AliAODZDC *GetZDCData() const { return fAODZDC; }
//AD
AliAODAD *GetADData() const { return fAODAD; }
virtual AliVEvent::EDataLayoutType GetDataLayoutType() const;
void FixCascades();
private:
TList *fAODObjects; ///< list of AODObjects
TFolder *fAODFolder; ///< folder structure of branches
Bool_t fConnected; //!<! flag if leaves are alreday connected
Bool_t fTracksConnected; //!<! flag if tracks have already pointer to event set
// standard content
AliVAODHeader *fHeader; //!<! event information
TClonesArray *fTracks; //!<! charged tracks
TClonesArray *fVertices; //!<! vertices
TClonesArray *fV0s; //!<! V0s
TClonesArray *fKinks; //!<! kinks
TClonesArray *fCascades; //!<! Cascades
AliAODTracklets *fTracklets; //!<! SPD tracklets
TClonesArray *fJets; //!<! jets
AliAODCaloCells *fEmcalCells; //!<! EMCAL calorimenter cells
AliAODCaloCells *fPhosCells; //!<! PHOS calorimenter cells
TClonesArray *fCaloClusters; //!<! calorimeter clusters
AliAODCaloTrigger *fEMCALTrigger; //!<! EMCAL Trigger information
AliAODCaloTrigger *fPHOSTrigger; //!<! PHOS Trigger information
TClonesArray *fFmdClusters; //!<! FMDclusters
TClonesArray *fPmdClusters; //!<! PMDclusters
TClonesArray *fHMPIDrings; //!<! HMPID signals
TClonesArray *fDimuons; //!<! dimuons
AliAODTZERO *fAODTZERO; //!<! TZERO AOD
AliAODVZERO *fAODVZERO; //!<! VZERO AOD
AliAODZDC *fAODZDC; //!<! ZDC AOD
AliAODAD *fAODAD; //!<! AD AOD
AliTOFHeader *fTOFHeader; //!<! event times (and sigmas) as estimated by TOF
// combinatorial algorithm.
// It contains also TOF time resolution
// and T0spread as written in OCDB
TClonesArray *fTrdTracks; //!<! TRD AOD tracks (triggered)
static const char* fAODListName[kAODListN]; //!<!
ClassDef(AliAODEvent,95);
};
#endif