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   AliVVevent(),
  73   fContentSize(0),
  74   fMagneticField(0),
  75   fPeriodNumber(0),
  76   fRunNumber(0),
  77   fOrbitNumber(0),
  78   fTimeStamp(0),
  79   fEventSpecie(0),
  80   fBunchCrossNumber(0),
  81   fPrimaryVertexMask(0),
  82   fTriggerMask(0),
  83   fTriggerMaskNext50(0),
  84   fNTriggerClasses(0),
  85   fNPrimaryVertices(0),
  86   fNTracks(0),
  87   fNV0s(0),
  88   fTriggerPointer(0),
  89   fPrimaryVertexTracksPointer(0),
  90   fPrimaryVertexSPDPointer(0),
  91   fTrackTablePointer(0),
  92   fTracksPointer(0),
  93   fV0Pointer(0)
  94 {
  95   // Default constructor
  96   fContent[0]=0;
  97 }
  98
  99
 100 AliFlatESDEvent::AliFlatESDEvent( AliVVConstructorReinitialisationFlag f )
 101   :
 102   AliVVevent( f ),
 103   fContentSize(fContentSize),
 104   fMagneticField(fMagneticField),
 105   fPeriodNumber(fPeriodNumber),
 106   fRunNumber(fRunNumber),
 107   fOrbitNumber(fOrbitNumber),
 108   fTimeStamp(fTimeStamp),
 109   fEventSpecie(fEventSpecie),
 110   fBunchCrossNumber(fBunchCrossNumber),
 111   fPrimaryVertexMask(fPrimaryVertexMask),
 112   fTriggerMask(fTriggerMask),
 113   fTriggerMaskNext50(fTriggerMaskNext50),
 114   fNTriggerClasses(fNTriggerClasses),
 115   fNPrimaryVertices(fNPrimaryVertices),
 116   fNTracks(fNTracks),
 117   fNV0s(fNV0s),
 118   fTriggerPointer(fTriggerPointer),
 119   fPrimaryVertexTracksPointer(fPrimaryVertexTracksPointer),
 120   fPrimaryVertexSPDPointer(fPrimaryVertexSPDPointer),
 121   fTrackTablePointer(fTrackTablePointer),
 122   fTracksPointer(fTracksPointer),
 123   fV0Pointer(fV0Pointer)
 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   if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0);
 223   return size;
 224 }
 225
 226 Int_t AliFlatESDEvent::SetPrimaryVertexTracks( const AliESDVertex *vtx, size_t allocatedVtxMemory )
 227 {
 228   // fill primary vertex tracks
 229   if( !vtx ) return 0;
 230   if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1;
 231   fPrimaryVertexMask |= 0x1;
 232   fPrimaryVertexTracksPointer = fContentSize;
 233   AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
 234   flatVtx->Set( *vtx );
 235   fContentSize += flatVtx->GetSize();
 236   return 0;
 237 }
 238
 239 Int_t AliFlatESDEvent::SetPrimaryVertexSPD( const AliESDVertex *vtx, size_t allocatedVtxMemory  )
 240 {
 241   // fill primary vertex SPD
 242   if( !vtx ) return 0;
 243   if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1;
 244   fPrimaryVertexMask |= 0x2;
 245   fPrimaryVertexSPDPointer = fContentSize;
 246   AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
 247   flatVtx->Set( *vtx );
 248   fContentSize += flatVtx->GetSize();
 249   return 0;
 250 }
 251
 252
 253 // _______________________________________________________________________________________________________
 254 Int_t AliFlatESDEvent::SetFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t fillV0s)
 255 {
 256   // Fill flat ESD event from normal ALiESDEvent
 257   // - Fill tracks + v0s
 258   // -> Added objects have to be added here as well
 259
 260   if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1;
 261
 262   Reset();
 263
 264   if( !esd ) return 0;
 265
 266   Int_t err = 0;
 267   size_t freeSpace = allocatedMemorySize - GetSize();
 268
 269   // fill run info
 270   {
 271     SetMagneticField( esd->GetMagneticField() );
 272     SetPeriodNumber( esd->GetPeriodNumber() );
 273     SetRunNumber( esd->GetRunNumber() );
 274     SetOrbitNumber( esd->GetOrbitNumber() );
 275     SetBunchCrossNumber( esd->GetBunchCrossNumber() );
 276     SetTimeStamp( esd->GetTimeStamp() );
 277     SetEventSpecie( esd->GetEventSpecie() );
 278     SetTriggerMask( esd->GetTriggerMask() );
 279     SetTriggerMaskNext50( esd->GetTriggerMaskNext50() );
 280   }
 281
 282   // Fill trigger information
 283   {
 284     size_t triggerSize = 0;
 285     int nTriggers = 0;
 286     AliFlatESDTrigger *trigger = SetTriggersStart();
 287     const AliESDRun*  esdRun = esd->GetESDRun();
 288     if( esdRun ){
 289       for( int index=0; index<AliESDRun::kNTriggerClasses; index++){
 290         const char* name = esdRun->GetTriggerClass(index);
 291         if( name && name[0]!='\0' ){
 292           err = trigger->SetTriggerClass( name, index, freeSpace );
 293           if( err!=0 ) return err;
 294           nTriggers++;
 295           freeSpace -= trigger->GetSize();
 296           triggerSize += trigger->GetSize();
 297           trigger = trigger->GetNextTriggerNonConst();
 298         }
 299       }
 300     }
 301     SetTriggersEnd( nTriggers, triggerSize );
 302   }
 303
 304   // fill primary vertices
 305
 306   err = SetPrimaryVertexTracks( esd->GetPrimaryVertexTracks(), freeSpace );
 307   if( err!=0 ) return err;
 308   freeSpace = allocatedMemorySize - GetSize();
 309
 310   err = SetPrimaryVertexSPD( esd->GetPrimaryVertexSPD(), freeSpace );
 311   if( err!=0 ) return err;
 312   freeSpace = allocatedMemorySize - GetSize();
 313
 314   // fill tracks
 315   {
 316    size_t trackSize = 0;
 317    int nTracks = 0;
 318    Long64_t *table = NULL;
 319    AliFlatESDTrack *flatTrack = NULL;
 320    err = SetTracksStart( flatTrack, table, esd->GetNumberOfTracks(), freeSpace );
 321    if( err!=0 ) return err;
 322    freeSpace = allocatedMemorySize - GetSize();
 323
 324    for (Int_t idxTrack = 0; idxTrack < esd->GetNumberOfTracks(); ++idxTrack) {
 325      AliESDtrack *esdTrack = esd->GetTrack(idxTrack);
 326      table[idxTrack] = -1;
 327      if (esdTrack) {
 328        table[idxTrack] = trackSize;
 329        if( freeSpace<flatTrack->EstimateSize() ) return -1;
 330        new (flatTrack) AliFlatESDTrack;
 331        flatTrack->Set( esdTrack );
 332        trackSize += flatTrack->GetSize();
 333        freeSpace -= flatTrack->GetSize();
 334        nTracks++;
 335        flatTrack = flatTrack->GetNextTrackNonConst();
 336      }
 337    }
 338    SetTracksEnd( nTracks, trackSize );
 339   }
 340
 341   // fill V0s
 342
 343   if( fillV0s ){
 344     size_t v0size = 0;
 345     int nV0s = 0;
 346     AliFlatESDV0 *flatV0 = SetV0sStart();
 347     for( int i=0; i < esd->GetNumberOfV0s(); i++){
 348       AliESDv0 *esdV0 = esd->GetV0( i );
 349       if( !esdV0 || freeSpace < flatV0->GetSize() ) return -1;
 350       new (flatV0) AliFlatESDV0;
 351       flatV0->SetNegTrackID( esdV0->GetNindex());
 352       flatV0->SetPosTrackID( esdV0->GetPindex());
 353       nV0s++;
 354       v0size += flatV0->GetSize();
 355       freeSpace -= flatV0->GetSize();
 356       flatV0 = flatV0->GetNextV0NonConst();
 357     }
 358     SetV0sEnd( nV0s, v0size );
 359   }
 360
 361   return 0;
 362 }
 363