]>
Commit | Line | Data |
---|---|---|
251a2c81 | 1 | /* $Id$ */ |
2 | ||
3 | /************************************************************************** | |
4 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
5 | * * | |
6 | * Author: The ALICE Off-line Project. * | |
7 | * Contributors are mentioned in the code where appropriate. * | |
8 | * * | |
9 | * Permission to use, copy, modify and distribute this software and its * | |
10 | * documentation strictly for non-commercial purposes is hereby granted * | |
11 | * without fee, provided that the above copyright notice appears in all * | |
12 | * copies and that both the copyright notice and this permission notice * | |
13 | * appear in the supporting documentation. The authors make no claims * | |
14 | * about the suitability of this software for any purpose. It is * | |
15 | * provided "as is" without express or implied warranty. * | |
16 | **************************************************************************/ | |
17 | ||
18 | /** | |
19 | * >> Flat structure representing an ESD << | |
20 | * | |
21 | * To be used in the online and offline calibration schema. | |
22 | * | |
23 | * Class provides interface methods for | |
24 | * - Filling from AliESDEvent, but also from HLT (to be added) | |
25 | * - Getter methods | |
26 | * | |
27 | * In the online case, the structure can be directly written into a shared | |
28 | * memory, in the offline case, the size has to be estimated first. | |
29 | * | |
30 | * | |
31 | * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli | |
32 | * | |
33 | * ************************************************************************ | |
34 | * Offline usage: | |
35 | * | |
36 | * ... | |
37 | * AliESDEvent* esd = ....; | |
38 | * Bool_t useESDFriends = kTRUE; | |
39 | * | |
40 | * // -- Book memory for AliFlatESDEvent | |
41 | * Byte_t *mem = new Byte_t[AliFlatESDEvent::EstimateSize(esd, useESDFriends)]; | |
42 | * AliFlatESDEvent *flatEsd = reinterpret_cast<AliFlatESDEvent*>(mem); | |
43 | * | |
44 | * // -- Fill AliFlatESDEvent | |
45 | * flatEsd->Fill(esd, useESDFriends); | |
46 | * ... | |
47 | * | |
48 | **************************************************************************/ | |
49 | ||
50 | #include "AliESDEvent.h" | |
51 | #include "AliESDtrack.h" | |
52 | #include "AliESDfriend.h" | |
27595dcc | 53 | #include "AliESDv0.h" |
251a2c81 | 54 | |
55 | #include "AliFlatESDEvent.h" | |
56 | #include "AliFlatESDTrack.h" | |
57 | #include "AliFlatTPCCluster.h" | |
58 | #include "AliFlatExternalTrackParam.h" | |
59 | #include "Riostream.h" | |
6a33e0e9 | 60 | |
251a2c81 | 61 | #include "AliFlatESDVertex.h" |
62 | ||
6a33e0e9 | 63 | #include "AliFlatESDV0.h" |
64 | #include "AliFlatESDTrigger.h" | |
65 | ||
66 | #include "AliESDEvent.h" | |
67 | #include "AliESDVertex.h" | |
68 | ||
251a2c81 | 69 | // _______________________________________________________________________________________________________ |
c2ea967e | 70 | AliFlatESDEvent::AliFlatESDEvent() |
71 | : | |
6a33e0e9 | 72 | fContentSize(0), |
73 | fMagneticField(0), | |
74 | fPeriodNumber(0), | |
75 | fRunNumber(0), | |
76 | fOrbitNumber(0), | |
77 | fTimeStamp(0), | |
888585e5 | 78 | fEventSpecie(0), |
6a33e0e9 | 79 | fBunchCrossNumber(0), |
251a2c81 | 80 | fPrimaryVertexMask(0), |
6a33e0e9 | 81 | fTriggerMask(0), |
888585e5 | 82 | fTriggerMaskNext50(0), |
6a33e0e9 | 83 | fNTriggerClasses(0), |
84 | fNPrimaryVertices(0), | |
251a2c81 | 85 | fNTracks(0), |
27595dcc | 86 | fNV0s(0), |
6a33e0e9 | 87 | fTriggerPointer(0), |
888585e5 | 88 | fPrimaryVertexTracksPointer(0), |
89 | fPrimaryVertexSPDPointer(0), | |
90 | fTrackTablePointer(0), | |
6a33e0e9 | 91 | fTracksPointer(0), |
c6f15692 | 92 | fV0Pointer(0), |
93 | fFriendEvent(NULL) | |
251a2c81 | 94 | { |
6a33e0e9 | 95 | // Default constructor |
96 | fContent[0]=0; | |
251a2c81 | 97 | } |
98 | ||
251a2c81 | 99 | |
98ccbd37 | 100 | AliFlatESDEvent::AliFlatESDEvent( AliVConstructorReinitialisationFlag /*f*/ ) |
a7751eb4 | 101 | // : |
102 | // fContentSize(fContentSize), | |
103 | // fMagneticField(fMagneticField), | |
104 | // fPeriodNumber(fPeriodNumber), | |
105 | // fRunNumber(fRunNumber), | |
106 | // fOrbitNumber(fOrbitNumber), | |
107 | // fTimeStamp(fTimeStamp), | |
108 | // fEventSpecie(fEventSpecie), | |
109 | // fBunchCrossNumber(fBunchCrossNumber), | |
110 | // fPrimaryVertexMask(fPrimaryVertexMask), | |
111 | // fTriggerMask(fTriggerMask), | |
112 | // fTriggerMaskNext50(fTriggerMaskNext50), | |
113 | // fNTriggerClasses(fNTriggerClasses), | |
114 | // fNPrimaryVertices(fNPrimaryVertices), | |
115 | // fNTracks(fNTracks), | |
116 | // fNV0s(fNV0s), | |
117 | // fTriggerPointer(fTriggerPointer), | |
118 | // fPrimaryVertexTracksPointer(fPrimaryVertexTracksPointer), | |
119 | // fPrimaryVertexSPDPointer(fPrimaryVertexSPDPointer), | |
120 | // fTrackTablePointer(fTrackTablePointer), | |
121 | // fTracksPointer(fTracksPointer), | |
122 | // fV0Pointer(fV0Pointer), | |
123 | // fFriendEvent(NULL) | |
c2ea967e | 124 | { |
125 | // Constructor for reinitialisation of vtable | |
126 | ||
127 | ||
128 | // Reinitialise trigger information | |
129 | { | |
130 | AliFlatESDTrigger * trigger = reinterpret_cast< AliFlatESDTrigger*>( fContent + fTriggerPointer ); | |
131 | for( UInt_t i=0; i<fNTriggerClasses; i++ ){ | |
132 | trigger->Reinitialize(); | |
133 | trigger = trigger->GetNextTriggerNonConst(); | |
134 | } | |
135 | } | |
136 | ||
137 | // Reinitialise primary vertices | |
138 | ||
139 | if( fPrimaryVertexMask & 0x1 ){ | |
140 | AliFlatESDVertex *vtxSPD = reinterpret_cast<AliFlatESDVertex*>(fContent + fPrimaryVertexSPDPointer); | |
141 | vtxSPD->Reinitialize(); | |
142 | } | |
143 | if( fPrimaryVertexMask & 0x2 ){ | |
144 | AliFlatESDVertex *vtxTracks = reinterpret_cast<AliFlatESDVertex*>(fContent + fPrimaryVertexTracksPointer); | |
145 | vtxTracks->Reinitialize(); | |
146 | } | |
147 | ||
148 | // Reinitialise tracks | |
149 | { | |
150 | AliFlatESDTrack *track = reinterpret_cast<AliFlatESDTrack*>( fContent + fTracksPointer ); | |
151 | for( UInt_t i=0; i<fNTracks; i++ ){ | |
152 | track->Reinitialize(); | |
153 | track = track->GetNextTrackNonConst(); | |
154 | } | |
155 | } | |
156 | ||
157 | // Reinitialise V0s | |
158 | { | |
159 | AliFlatESDV0 *v0 = reinterpret_cast<AliFlatESDV0*>( fContent + fV0Pointer ); | |
160 | for( UInt_t i=0; i < fNV0s; i++){ | |
161 | v0->Reinitialize(); | |
162 | v0 = v0->GetNextV0NonConst(); | |
163 | } | |
164 | } | |
165 | } | |
166 | ||
167 | ||
888585e5 | 168 | TString AliFlatESDEvent::GetFiredTriggerClasses() const |
251a2c81 | 169 | { |
888585e5 | 170 | // Fired trigger classes |
171 | TString trclasses; | |
172 | const AliFlatESDTrigger *tr = GetTriggerClasses(); | |
173 | ULong64_t mask = GetTriggerMask() | GetTriggerMaskNext50(); | |
174 | for(Int_t i = 0; i < GetNumberOfTriggerClasses(); i++) { | |
175 | int index = tr->GetTriggerIndex(); | |
176 | if( mask & (1ull<<index) ){ | |
177 | trclasses += " "; | |
178 | trclasses += tr->GetTriggerClassName(); | |
179 | trclasses += " "; | |
180 | } | |
181 | } | |
182 | tr = tr->GetNextTrigger(); | |
183 | return trclasses; | |
251a2c81 | 184 | } |
185 | ||
251a2c81 | 186 | |
888585e5 | 187 | void AliFlatESDEvent::Reset() |
6a33e0e9 | 188 | { |
189 | // Init | |
190 | ||
191 | fContentSize = 0; | |
192 | fMagneticField = 0; | |
193 | fPeriodNumber = 0; | |
194 | fRunNumber = 0; | |
195 | fOrbitNumber = 0; | |
196 | fTimeStamp = 0; | |
197 | fBunchCrossNumber = 0; | |
198 | fPrimaryVertexMask = 0; | |
199 | fTriggerMask = 0; | |
888585e5 | 200 | fTriggerMaskNext50 = 0; |
6a33e0e9 | 201 | fNTriggerClasses = 0; |
202 | fNPrimaryVertices = 0; | |
203 | fNTracks = 0; | |
204 | fNV0s = 0; | |
205 | fTriggerPointer = 0; | |
888585e5 | 206 | fPrimaryVertexTracksPointer = 0; |
207 | fPrimaryVertexSPDPointer = 0; | |
208 | fTrackTablePointer = 0; | |
6a33e0e9 | 209 | fTracksPointer = 0; |
210 | fV0Pointer = 0; | |
211 | } | |
212 | ||
251a2c81 | 213 | // _______________________________________________________________________________________________________ |
888585e5 | 214 | ULong64_t AliFlatESDEvent::EstimateSize(AliESDEvent *esd, Bool_t fillV0s) |
251a2c81 | 215 | { |
216 | // Estimate upper limit of the object size | |
217 | // -> Added objects have to be added here as well | |
218 | ||
219 | ULong64_t size = sizeof(AliFlatESDEvent); | |
220 | size += 2 * sizeof( AliFlatESDVertex ); | |
888585e5 | 221 | size += esd->GetNumberOfTracks() * ( AliFlatESDTrack::EstimateSize() + sizeof(Long64_t) ); |
5ec8009a | 222 | size += AliESDRun::kNTriggerClasses * sizeof(AliFlatESDTrigger) ; |
251a2c81 | 223 | if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0); |
224 | return size; | |
225 | } | |
226 | ||
888585e5 | 227 | Int_t AliFlatESDEvent::SetPrimaryVertexTracks( const AliESDVertex *vtx, size_t allocatedVtxMemory ) |
251a2c81 | 228 | { |
888585e5 | 229 | // fill primary vertex tracks |
230 | if( !vtx ) return 0; | |
231 | if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1; | |
232 | fPrimaryVertexMask |= 0x1; | |
233 | fPrimaryVertexTracksPointer = fContentSize; | |
234 | AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize); | |
0d577a2c | 235 | flatVtx->SetFromESDVertex( *vtx ); |
888585e5 | 236 | fContentSize += flatVtx->GetSize(); |
237 | return 0; | |
251a2c81 | 238 | } |
239 | ||
888585e5 | 240 | Int_t AliFlatESDEvent::SetPrimaryVertexSPD( const AliESDVertex *vtx, size_t allocatedVtxMemory ) |
251a2c81 | 241 | { |
888585e5 | 242 | // fill primary vertex SPD |
243 | if( !vtx ) return 0; | |
244 | if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1; | |
245 | fPrimaryVertexMask |= 0x2; | |
246 | fPrimaryVertexSPDPointer = fContentSize; | |
247 | AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize); | |
0d577a2c | 248 | flatVtx->SetFromESDVertex( *vtx ); |
888585e5 | 249 | fContentSize += flatVtx->GetSize(); |
251a2c81 | 250 | return 0; |
251 | } | |
252 | ||
251a2c81 | 253 | |
254 | // _______________________________________________________________________________________________________ | |
888585e5 | 255 | Int_t AliFlatESDEvent::SetFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t fillV0s) |
251a2c81 | 256 | { |
257 | // Fill flat ESD event from normal ALiESDEvent | |
888585e5 | 258 | // - Fill tracks + v0s |
251a2c81 | 259 | // -> Added objects have to be added here as well |
6a33e0e9 | 260 | |
6a33e0e9 | 261 | if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1; |
251a2c81 | 262 | |
888585e5 | 263 | Reset(); |
251a2c81 | 264 | |
6a33e0e9 | 265 | if( !esd ) return 0; |
266 | ||
267 | Int_t err = 0; | |
268 | size_t freeSpace = allocatedMemorySize - GetSize(); | |
269 | ||
270 | // fill run info | |
271 | { | |
888585e5 | 272 | SetMagneticField( esd->GetMagneticField() ); |
273 | SetPeriodNumber( esd->GetPeriodNumber() ); | |
274 | SetRunNumber( esd->GetRunNumber() ); | |
275 | SetOrbitNumber( esd->GetOrbitNumber() ); | |
276 | SetBunchCrossNumber( esd->GetBunchCrossNumber() ); | |
277 | SetTimeStamp( esd->GetTimeStamp() ); | |
278 | SetEventSpecie( esd->GetEventSpecie() ); | |
6a33e0e9 | 279 | SetTriggerMask( esd->GetTriggerMask() ); |
888585e5 | 280 | SetTriggerMaskNext50( esd->GetTriggerMaskNext50() ); |
6a33e0e9 | 281 | } |
888585e5 | 282 | |
6a33e0e9 | 283 | // Fill trigger information |
284 | { | |
285 | size_t triggerSize = 0; | |
286 | int nTriggers = 0; | |
888585e5 | 287 | AliFlatESDTrigger *trigger = SetTriggersStart(); |
6a33e0e9 | 288 | const AliESDRun* esdRun = esd->GetESDRun(); |
289 | if( esdRun ){ | |
290 | for( int index=0; index<AliESDRun::kNTriggerClasses; index++){ | |
291 | const char* name = esdRun->GetTriggerClass(index); | |
292 | if( name && name[0]!='\0' ){ | |
293 | err = trigger->SetTriggerClass( name, index, freeSpace ); | |
294 | if( err!=0 ) return err; | |
295 | nTriggers++; | |
296 | freeSpace -= trigger->GetSize(); | |
297 | triggerSize += trigger->GetSize(); | |
888585e5 | 298 | trigger = trigger->GetNextTriggerNonConst(); |
6a33e0e9 | 299 | } |
300 | } | |
301 | } | |
888585e5 | 302 | SetTriggersEnd( nTriggers, triggerSize ); |
6a33e0e9 | 303 | } |
304 | ||
305 | // fill primary vertices | |
306 | ||
888585e5 | 307 | err = SetPrimaryVertexTracks( esd->GetPrimaryVertexTracks(), freeSpace ); |
6a33e0e9 | 308 | if( err!=0 ) return err; |
6a33e0e9 | 309 | freeSpace = allocatedMemorySize - GetSize(); |
310 | ||
888585e5 | 311 | err = SetPrimaryVertexSPD( esd->GetPrimaryVertexSPD(), freeSpace ); |
312 | if( err!=0 ) return err; | |
313 | freeSpace = allocatedMemorySize - GetSize(); | |
251a2c81 | 314 | |
888585e5 | 315 | // fill tracks |
316 | { | |
317 | size_t trackSize = 0; | |
318 | int nTracks = 0; | |
319 | Long64_t *table = NULL; | |
320 | AliFlatESDTrack *flatTrack = NULL; | |
321 | err = SetTracksStart( flatTrack, table, esd->GetNumberOfTracks(), freeSpace ); | |
322 | if( err!=0 ) return err; | |
323 | freeSpace = allocatedMemorySize - GetSize(); | |
324 | ||
325 | for (Int_t idxTrack = 0; idxTrack < esd->GetNumberOfTracks(); ++idxTrack) { | |
326 | AliESDtrack *esdTrack = esd->GetTrack(idxTrack); | |
327 | table[idxTrack] = -1; | |
328 | if (esdTrack) { | |
329 | table[idxTrack] = trackSize; | |
330 | if( freeSpace<flatTrack->EstimateSize() ) return -1; | |
331 | new (flatTrack) AliFlatESDTrack; | |
0d577a2c | 332 | flatTrack->SetFromESDTrack( esdTrack ); |
888585e5 | 333 | trackSize += flatTrack->GetSize(); |
334 | freeSpace -= flatTrack->GetSize(); | |
335 | nTracks++; | |
c2ea967e | 336 | flatTrack = flatTrack->GetNextTrackNonConst(); |
888585e5 | 337 | } |
338 | } | |
339 | SetTracksEnd( nTracks, trackSize ); | |
251a2c81 | 340 | } |
341 | ||
888585e5 | 342 | // fill V0s |
251a2c81 | 343 | |
251a2c81 | 344 | if( fillV0s ){ |
888585e5 | 345 | size_t v0size = 0; |
346 | int nV0s = 0; | |
347 | AliFlatESDV0 *flatV0 = SetV0sStart(); | |
251a2c81 | 348 | for( int i=0; i < esd->GetNumberOfV0s(); i++){ |
349 | AliESDv0 *esdV0 = esd->GetV0( i ); | |
888585e5 | 350 | if( !esdV0 || freeSpace < flatV0->GetSize() ) return -1; |
351 | new (flatV0) AliFlatESDV0; | |
352 | flatV0->SetNegTrackID( esdV0->GetNindex()); | |
353 | flatV0->SetPosTrackID( esdV0->GetPindex()); | |
354 | nV0s++; | |
355 | v0size += flatV0->GetSize(); | |
356 | freeSpace -= flatV0->GetSize(); | |
c2ea967e | 357 | flatV0 = flatV0->GetNextV0NonConst(); |
251a2c81 | 358 | } |
888585e5 | 359 | SetV0sEnd( nV0s, v0size ); |
251a2c81 | 360 | } |
888585e5 | 361 | |
251a2c81 | 362 | return 0; |
363 | } | |
364 | ||
c8a50489 | 365 | AliVParticle* AliFlatESDEvent::GetTrack(Int_t i) const |
366 | { | |
367 | return const_cast<AliFlatESDTrack*>(GetFlatTrack(i)); | |
368 | } |