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