HLT/global/AliFlatESDEvent.cxx

   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"
  53 #include "AliESDv0.h"
  54
  55 #include "AliFlatESDEvent.h"
  56 #include "AliFlatESDTrack.h"
  57 #include "AliFlatTPCCluster.h"
  58 #include "AliFlatExternalTrackParam.h"
  59 #include "Riostream.h"
  60
  61 #include "AliFlatESDVertex.h"
  62
  63 #include "AliFlatESDV0.h"
  64 #include "AliFlatESDTrigger.h"
  65
  66 #include "AliESDEvent.h"
  67 #include "AliESDVertex.h"
  68
  69 // _______________________________________________________________________________________________________
  70 AliFlatESDEvent::AliFlatESDEvent()
  71   :
  72   fContentSize(0),
  73   fMagneticField(0),
  74   fPeriodNumber(0),
  75   fRunNumber(0),
  76   fOrbitNumber(0),
  77   fTimeStamp(0),
  78   fEventSpecie(0),
  79   fBunchCrossNumber(0),
  80   fPrimaryVertexMask(0),
  81   fTriggerMask(0),
  82   fTriggerMaskNext50(0),
  83   fNTriggerClasses(0),
  84   fNPrimaryVertices(0),
  85   fNTracks(0),
  86   fNV0s(0),
  87   fTriggerPointer(0),
  88   fPrimaryVertexTracksPointer(0),
  89   fPrimaryVertexSPDPointer(0),
  90   fTrackTablePointer(0),
  91   fTracksPointer(0),
  92   fV0Pointer(0),
  93   fFriendEvent(NULL)
  94 {
  95   // Default constructor
  96   fContent[0]=0;
  97 }
  98
  99
 100 AliFlatESDEvent::AliFlatESDEvent( AliVConstructorReinitialisationFlag /*f*/ )
 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)
 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
 168 TString AliFlatESDEvent::GetFiredTriggerClasses() const
 169 {
 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;
 184 }
 185
 186
 187 void AliFlatESDEvent::Reset()
 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;
 200   fTriggerMaskNext50 = 0;
 201   fNTriggerClasses = 0;
 202   fNPrimaryVertices = 0;
 203   fNTracks = 0;
 204   fNV0s = 0;
 205   fTriggerPointer = 0;
 206   fPrimaryVertexTracksPointer = 0;
 207   fPrimaryVertexSPDPointer = 0;
 208   fTrackTablePointer = 0;
 209   fTracksPointer = 0;
 210   fV0Pointer = 0;
 211 }
 212
 213 // _______________________________________________________________________________________________________
 214   ULong64_t AliFlatESDEvent::EstimateSize(AliESDEvent *esd, Bool_t fillV0s)
 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 );
 221   size += esd->GetNumberOfTracks() * ( AliFlatESDTrack::EstimateSize() + sizeof(Long64_t) );
 222   size += AliESDRun::kNTriggerClasses * sizeof(AliFlatESDTrigger) ;
 223   if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0);
 224   return size;
 225 }
 226
 227 Int_t AliFlatESDEvent::SetPrimaryVertexTracks( const AliESDVertex *vtx, size_t allocatedVtxMemory )
 228 {
 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);
 235   flatVtx->SetFromESDVertex( *vtx );
 236   fContentSize += flatVtx->GetSize();
 237   return 0;
 238 }
 239
 240 Int_t AliFlatESDEvent::SetPrimaryVertexSPD( const AliESDVertex *vtx, size_t allocatedVtxMemory  )
 241 {
 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);
 248   flatVtx->SetFromESDVertex( *vtx );
 249   fContentSize += flatVtx->GetSize();
 250   return 0;
 251 }
 252
 253
 254 // _______________________________________________________________________________________________________
 255 Int_t AliFlatESDEvent::SetFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t fillV0s)
 256 {
 257   // Fill flat ESD event from normal ALiESDEvent
 258   // - Fill tracks + v0s
 259   // -> Added objects have to be added here as well
 260
 261   if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1;
 262
 263   Reset();
 264
 265   if( !esd ) return 0;
 266
 267   Int_t err = 0;
 268   size_t freeSpace = allocatedMemorySize - GetSize();
 269
 270   // fill run info
 271   {
 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() );
 279     SetTriggerMask( esd->GetTriggerMask() );
 280     SetTriggerMaskNext50( esd->GetTriggerMaskNext50() );
 281   }
 282
 283   // Fill trigger information
 284   {
 285     size_t triggerSize = 0;
 286     int nTriggers = 0;
 287     AliFlatESDTrigger *trigger = SetTriggersStart();
 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();
 298           trigger = trigger->GetNextTriggerNonConst();
 299         }
 300       }
 301     }
 302     SetTriggersEnd( nTriggers, triggerSize );
 303   }
 304
 305   // fill primary vertices
 306
 307   err = SetPrimaryVertexTracks( esd->GetPrimaryVertexTracks(), freeSpace );
 308   if( err!=0 ) return err;
 309   freeSpace = allocatedMemorySize - GetSize();
 310
 311   err = SetPrimaryVertexSPD( esd->GetPrimaryVertexSPD(), freeSpace );
 312   if( err!=0 ) return err;
 313   freeSpace = allocatedMemorySize - GetSize();
 314
 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;
 332        flatTrack->SetFromESDTrack( esdTrack );
 333        trackSize += flatTrack->GetSize();
 334        freeSpace -= flatTrack->GetSize();
 335        nTracks++;
 336        flatTrack = flatTrack->GetNextTrackNonConst();
 337      }
 338    }
 339    SetTracksEnd( nTracks, trackSize );
 340   }
 341
 342   // fill V0s
 343
 344   if( fillV0s ){
 345     size_t v0size = 0;
 346     int nV0s = 0;
 347     AliFlatESDV0 *flatV0 = SetV0sStart();
 348     for( int i=0; i < esd->GetNumberOfV0s(); i++){
 349       AliESDv0 *esdV0 = esd->GetV0( i );
 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();
 357       flatV0 = flatV0->GetNextV0NonConst();
 358     }
 359     SetV0sEnd( nV0s, v0size );
 360   }
 361
 362   return 0;
 363 }
 364
 365 AliVParticle* AliFlatESDEvent::GetTrack(Int_t i) const
 366 {
 367   return const_cast<AliFlatESDTrack*>(GetFlatTrack(i));
 368 }