]>
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 | : | |
888585e5 | 72 | AliVVevent(), |
6a33e0e9 | 73 | fContentSize(0), |
74 | fMagneticField(0), | |
75 | fPeriodNumber(0), | |
76 | fRunNumber(0), | |
77 | fOrbitNumber(0), | |
78 | fTimeStamp(0), | |
888585e5 | 79 | fEventSpecie(0), |
6a33e0e9 | 80 | fBunchCrossNumber(0), |
251a2c81 | 81 | fPrimaryVertexMask(0), |
6a33e0e9 | 82 | fTriggerMask(0), |
888585e5 | 83 | fTriggerMaskNext50(0), |
6a33e0e9 | 84 | fNTriggerClasses(0), |
85 | fNPrimaryVertices(0), | |
251a2c81 | 86 | fNTracks(0), |
27595dcc | 87 | fNV0s(0), |
6a33e0e9 | 88 | fTriggerPointer(0), |
888585e5 | 89 | fPrimaryVertexTracksPointer(0), |
90 | fPrimaryVertexSPDPointer(0), | |
91 | fTrackTablePointer(0), | |
6a33e0e9 | 92 | fTracksPointer(0), |
c6f15692 | 93 | fV0Pointer(0), |
94 | fFriendEvent(NULL) | |
251a2c81 | 95 | { |
6a33e0e9 | 96 | // Default constructor |
97 | fContent[0]=0; | |
251a2c81 | 98 | } |
99 | ||
251a2c81 | 100 | |
c2ea967e | 101 | AliFlatESDEvent::AliFlatESDEvent( AliVVConstructorReinitialisationFlag f ) |
102 | : | |
103 | AliVVevent( f ), | |
104 | fContentSize(fContentSize), | |
105 | fMagneticField(fMagneticField), | |
106 | fPeriodNumber(fPeriodNumber), | |
107 | fRunNumber(fRunNumber), | |
108 | fOrbitNumber(fOrbitNumber), | |
109 | fTimeStamp(fTimeStamp), | |
110 | fEventSpecie(fEventSpecie), | |
111 | fBunchCrossNumber(fBunchCrossNumber), | |
112 | fPrimaryVertexMask(fPrimaryVertexMask), | |
113 | fTriggerMask(fTriggerMask), | |
114 | fTriggerMaskNext50(fTriggerMaskNext50), | |
115 | fNTriggerClasses(fNTriggerClasses), | |
116 | fNPrimaryVertices(fNPrimaryVertices), | |
117 | fNTracks(fNTracks), | |
118 | fNV0s(fNV0s), | |
119 | fTriggerPointer(fTriggerPointer), | |
120 | fPrimaryVertexTracksPointer(fPrimaryVertexTracksPointer), | |
121 | fPrimaryVertexSPDPointer(fPrimaryVertexSPDPointer), | |
122 | fTrackTablePointer(fTrackTablePointer), | |
123 | fTracksPointer(fTracksPointer), | |
c6f15692 | 124 | fV0Pointer(fV0Pointer), |
125 | fFriendEvent(NULL) | |
c2ea967e | 126 | { |
127 | // Constructor for reinitialisation of vtable | |
128 | ||
129 | ||
130 | // Reinitialise trigger information | |
131 | { | |
132 | AliFlatESDTrigger * trigger = reinterpret_cast< AliFlatESDTrigger*>( fContent + fTriggerPointer ); | |
133 | for( UInt_t i=0; i<fNTriggerClasses; i++ ){ | |
134 | trigger->Reinitialize(); | |
135 | trigger = trigger->GetNextTriggerNonConst(); | |
136 | } | |
137 | } | |
138 | ||
139 | // Reinitialise primary vertices | |
140 | ||
141 | if( fPrimaryVertexMask & 0x1 ){ | |
142 | AliFlatESDVertex *vtxSPD = reinterpret_cast<AliFlatESDVertex*>(fContent + fPrimaryVertexSPDPointer); | |
143 | vtxSPD->Reinitialize(); | |
144 | } | |
145 | if( fPrimaryVertexMask & 0x2 ){ | |
146 | AliFlatESDVertex *vtxTracks = reinterpret_cast<AliFlatESDVertex*>(fContent + fPrimaryVertexTracksPointer); | |
147 | vtxTracks->Reinitialize(); | |
148 | } | |
149 | ||
150 | // Reinitialise tracks | |
151 | { | |
152 | AliFlatESDTrack *track = reinterpret_cast<AliFlatESDTrack*>( fContent + fTracksPointer ); | |
153 | for( UInt_t i=0; i<fNTracks; i++ ){ | |
154 | track->Reinitialize(); | |
155 | track = track->GetNextTrackNonConst(); | |
156 | } | |
157 | } | |
158 | ||
159 | // Reinitialise V0s | |
160 | { | |
161 | AliFlatESDV0 *v0 = reinterpret_cast<AliFlatESDV0*>( fContent + fV0Pointer ); | |
162 | for( UInt_t i=0; i < fNV0s; i++){ | |
163 | v0->Reinitialize(); | |
164 | v0 = v0->GetNextV0NonConst(); | |
165 | } | |
166 | } | |
167 | } | |
168 | ||
169 | ||
888585e5 | 170 | TString AliFlatESDEvent::GetFiredTriggerClasses() const |
251a2c81 | 171 | { |
888585e5 | 172 | // Fired trigger classes |
173 | TString trclasses; | |
174 | const AliFlatESDTrigger *tr = GetTriggerClasses(); | |
175 | ULong64_t mask = GetTriggerMask() | GetTriggerMaskNext50(); | |
176 | for(Int_t i = 0; i < GetNumberOfTriggerClasses(); i++) { | |
177 | int index = tr->GetTriggerIndex(); | |
178 | if( mask & (1ull<<index) ){ | |
179 | trclasses += " "; | |
180 | trclasses += tr->GetTriggerClassName(); | |
181 | trclasses += " "; | |
182 | } | |
183 | } | |
184 | tr = tr->GetNextTrigger(); | |
185 | return trclasses; | |
251a2c81 | 186 | } |
187 | ||
251a2c81 | 188 | |
888585e5 | 189 | void AliFlatESDEvent::Reset() |
6a33e0e9 | 190 | { |
191 | // Init | |
192 | ||
193 | fContentSize = 0; | |
194 | fMagneticField = 0; | |
195 | fPeriodNumber = 0; | |
196 | fRunNumber = 0; | |
197 | fOrbitNumber = 0; | |
198 | fTimeStamp = 0; | |
199 | fBunchCrossNumber = 0; | |
200 | fPrimaryVertexMask = 0; | |
201 | fTriggerMask = 0; | |
888585e5 | 202 | fTriggerMaskNext50 = 0; |
6a33e0e9 | 203 | fNTriggerClasses = 0; |
204 | fNPrimaryVertices = 0; | |
205 | fNTracks = 0; | |
206 | fNV0s = 0; | |
207 | fTriggerPointer = 0; | |
888585e5 | 208 | fPrimaryVertexTracksPointer = 0; |
209 | fPrimaryVertexSPDPointer = 0; | |
210 | fTrackTablePointer = 0; | |
6a33e0e9 | 211 | fTracksPointer = 0; |
212 | fV0Pointer = 0; | |
213 | } | |
214 | ||
251a2c81 | 215 | // _______________________________________________________________________________________________________ |
888585e5 | 216 | ULong64_t AliFlatESDEvent::EstimateSize(AliESDEvent *esd, Bool_t fillV0s) |
251a2c81 | 217 | { |
218 | // Estimate upper limit of the object size | |
219 | // -> Added objects have to be added here as well | |
220 | ||
221 | ULong64_t size = sizeof(AliFlatESDEvent); | |
222 | size += 2 * sizeof( AliFlatESDVertex ); | |
888585e5 | 223 | size += esd->GetNumberOfTracks() * ( AliFlatESDTrack::EstimateSize() + sizeof(Long64_t) ); |
251a2c81 | 224 | if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0); |
225 | return size; | |
226 | } | |
227 | ||
888585e5 | 228 | Int_t AliFlatESDEvent::SetPrimaryVertexTracks( const AliESDVertex *vtx, size_t allocatedVtxMemory ) |
251a2c81 | 229 | { |
888585e5 | 230 | // fill primary vertex tracks |
231 | if( !vtx ) return 0; | |
232 | if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1; | |
233 | fPrimaryVertexMask |= 0x1; | |
234 | fPrimaryVertexTracksPointer = fContentSize; | |
235 | AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize); | |
0d577a2c | 236 | flatVtx->SetFromESDVertex( *vtx ); |
888585e5 | 237 | fContentSize += flatVtx->GetSize(); |
238 | return 0; | |
251a2c81 | 239 | } |
240 | ||
888585e5 | 241 | Int_t AliFlatESDEvent::SetPrimaryVertexSPD( const AliESDVertex *vtx, size_t allocatedVtxMemory ) |
251a2c81 | 242 | { |
888585e5 | 243 | // fill primary vertex SPD |
244 | if( !vtx ) return 0; | |
245 | if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1; | |
246 | fPrimaryVertexMask |= 0x2; | |
247 | fPrimaryVertexSPDPointer = fContentSize; | |
248 | AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize); | |
0d577a2c | 249 | flatVtx->SetFromESDVertex( *vtx ); |
888585e5 | 250 | fContentSize += flatVtx->GetSize(); |
251a2c81 | 251 | return 0; |
252 | } | |
253 | ||
251a2c81 | 254 | |
255 | // _______________________________________________________________________________________________________ | |
888585e5 | 256 | Int_t AliFlatESDEvent::SetFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t fillV0s) |
251a2c81 | 257 | { |
258 | // Fill flat ESD event from normal ALiESDEvent | |
888585e5 | 259 | // - Fill tracks + v0s |
251a2c81 | 260 | // -> Added objects have to be added here as well |
6a33e0e9 | 261 | |
6a33e0e9 | 262 | if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1; |
251a2c81 | 263 | |
888585e5 | 264 | Reset(); |
251a2c81 | 265 | |
6a33e0e9 | 266 | if( !esd ) return 0; |
267 | ||
268 | Int_t err = 0; | |
269 | size_t freeSpace = allocatedMemorySize - GetSize(); | |
270 | ||
271 | // fill run info | |
272 | { | |
888585e5 | 273 | SetMagneticField( esd->GetMagneticField() ); |
274 | SetPeriodNumber( esd->GetPeriodNumber() ); | |
275 | SetRunNumber( esd->GetRunNumber() ); | |
276 | SetOrbitNumber( esd->GetOrbitNumber() ); | |
277 | SetBunchCrossNumber( esd->GetBunchCrossNumber() ); | |
278 | SetTimeStamp( esd->GetTimeStamp() ); | |
279 | SetEventSpecie( esd->GetEventSpecie() ); | |
6a33e0e9 | 280 | SetTriggerMask( esd->GetTriggerMask() ); |
888585e5 | 281 | SetTriggerMaskNext50( esd->GetTriggerMaskNext50() ); |
6a33e0e9 | 282 | } |
888585e5 | 283 | |
6a33e0e9 | 284 | // Fill trigger information |
285 | { | |
286 | size_t triggerSize = 0; | |
287 | int nTriggers = 0; | |
888585e5 | 288 | AliFlatESDTrigger *trigger = SetTriggersStart(); |
6a33e0e9 | 289 | const AliESDRun* esdRun = esd->GetESDRun(); |
290 | if( esdRun ){ | |
291 | for( int index=0; index<AliESDRun::kNTriggerClasses; index++){ | |
292 | const char* name = esdRun->GetTriggerClass(index); | |
293 | if( name && name[0]!='\0' ){ | |
294 | err = trigger->SetTriggerClass( name, index, freeSpace ); | |
295 | if( err!=0 ) return err; | |
296 | nTriggers++; | |
297 | freeSpace -= trigger->GetSize(); | |
298 | triggerSize += trigger->GetSize(); | |
888585e5 | 299 | trigger = trigger->GetNextTriggerNonConst(); |
6a33e0e9 | 300 | } |
301 | } | |
302 | } | |
888585e5 | 303 | SetTriggersEnd( nTriggers, triggerSize ); |
6a33e0e9 | 304 | } |
305 | ||
306 | // fill primary vertices | |
307 | ||
888585e5 | 308 | err = SetPrimaryVertexTracks( esd->GetPrimaryVertexTracks(), freeSpace ); |
6a33e0e9 | 309 | if( err!=0 ) return err; |
6a33e0e9 | 310 | freeSpace = allocatedMemorySize - GetSize(); |
311 | ||
888585e5 | 312 | err = SetPrimaryVertexSPD( esd->GetPrimaryVertexSPD(), freeSpace ); |
313 | if( err!=0 ) return err; | |
314 | freeSpace = allocatedMemorySize - GetSize(); | |
251a2c81 | 315 | |
888585e5 | 316 | // fill tracks |
317 | { | |
318 | size_t trackSize = 0; | |
319 | int nTracks = 0; | |
320 | Long64_t *table = NULL; | |
321 | AliFlatESDTrack *flatTrack = NULL; | |
322 | err = SetTracksStart( flatTrack, table, esd->GetNumberOfTracks(), freeSpace ); | |
323 | if( err!=0 ) return err; | |
324 | freeSpace = allocatedMemorySize - GetSize(); | |
325 | ||
326 | for (Int_t idxTrack = 0; idxTrack < esd->GetNumberOfTracks(); ++idxTrack) { | |
327 | AliESDtrack *esdTrack = esd->GetTrack(idxTrack); | |
328 | table[idxTrack] = -1; | |
329 | if (esdTrack) { | |
330 | table[idxTrack] = trackSize; | |
331 | if( freeSpace<flatTrack->EstimateSize() ) return -1; | |
332 | new (flatTrack) AliFlatESDTrack; | |
0d577a2c | 333 | flatTrack->SetFromESDTrack( esdTrack ); |
888585e5 | 334 | trackSize += flatTrack->GetSize(); |
335 | freeSpace -= flatTrack->GetSize(); | |
336 | nTracks++; | |
c2ea967e | 337 | flatTrack = flatTrack->GetNextTrackNonConst(); |
888585e5 | 338 | } |
339 | } | |
340 | SetTracksEnd( nTracks, trackSize ); | |
251a2c81 | 341 | } |
342 | ||
888585e5 | 343 | // fill V0s |
251a2c81 | 344 | |
251a2c81 | 345 | if( fillV0s ){ |
888585e5 | 346 | size_t v0size = 0; |
347 | int nV0s = 0; | |
348 | AliFlatESDV0 *flatV0 = SetV0sStart(); | |
251a2c81 | 349 | for( int i=0; i < esd->GetNumberOfV0s(); i++){ |
350 | AliESDv0 *esdV0 = esd->GetV0( i ); | |
888585e5 | 351 | if( !esdV0 || freeSpace < flatV0->GetSize() ) return -1; |
352 | new (flatV0) AliFlatESDV0; | |
353 | flatV0->SetNegTrackID( esdV0->GetNindex()); | |
354 | flatV0->SetPosTrackID( esdV0->GetPindex()); | |
355 | nV0s++; | |
356 | v0size += flatV0->GetSize(); | |
357 | freeSpace -= flatV0->GetSize(); | |
c2ea967e | 358 | flatV0 = flatV0->GetNextV0NonConst(); |
251a2c81 | 359 | } |
888585e5 | 360 | SetV0sEnd( nV0s, v0size ); |
251a2c81 | 361 | } |
888585e5 | 362 | |
251a2c81 | 363 | return 0; |
364 | } | |
365 |