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   fFriendEvent(NULL)
  95 {
  96   // Default constructor
  97   fContent[0]=0;
  98 }
  99
 100
 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),
 124   fV0Pointer(fV0Pointer),
 125   fFriendEvent(NULL)
 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
 170 TString AliFlatESDEvent::GetFiredTriggerClasses() const
 171 {
 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;
 186 }
 187
 188
 189 void AliFlatESDEvent::Reset()
 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;
 202   fTriggerMaskNext50 = 0;
 203   fNTriggerClasses = 0;
 204   fNPrimaryVertices = 0;
 205   fNTracks = 0;
 206   fNV0s = 0;
 207   fTriggerPointer = 0;
 208   fPrimaryVertexTracksPointer = 0;
 209   fPrimaryVertexSPDPointer = 0;
 210   fTrackTablePointer = 0;
 211   fTracksPointer = 0;
 212   fV0Pointer = 0;
 213 }
 214
 215 // _______________________________________________________________________________________________________
 216   ULong64_t AliFlatESDEvent::EstimateSize(AliESDEvent *esd, Bool_t fillV0s)
 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 );
 223   size += esd->GetNumberOfTracks() * ( AliFlatESDTrack::EstimateSize() + sizeof(Long64_t) );
 224   if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0);
 225   return size;
 226 }
 227
 228 Int_t AliFlatESDEvent::SetPrimaryVertexTracks( const AliESDVertex *vtx, size_t allocatedVtxMemory )
 229 {
 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);
 236   flatVtx->SetFromESDVertex( *vtx );
 237   fContentSize += flatVtx->GetSize();
 238   return 0;
 239 }
 240
 241 Int_t AliFlatESDEvent::SetPrimaryVertexSPD( const AliESDVertex *vtx, size_t allocatedVtxMemory  )
 242 {
 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);
 249   flatVtx->SetFromESDVertex( *vtx );
 250   fContentSize += flatVtx->GetSize();
 251   return 0;
 252 }
 253
 254
 255 // _______________________________________________________________________________________________________
 256 Int_t AliFlatESDEvent::SetFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t fillV0s)
 257 {
 258   // Fill flat ESD event from normal ALiESDEvent
 259   // - Fill tracks + v0s
 260   // -> Added objects have to be added here as well
 261
 262   if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1;
 263
 264   Reset();
 265
 266   if( !esd ) return 0;
 267
 268   Int_t err = 0;
 269   size_t freeSpace = allocatedMemorySize - GetSize();
 270
 271   // fill run info
 272   {
 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() );
 280     SetTriggerMask( esd->GetTriggerMask() );
 281     SetTriggerMaskNext50( esd->GetTriggerMaskNext50() );
 282   }
 283
 284   // Fill trigger information
 285   {
 286     size_t triggerSize = 0;
 287     int nTriggers = 0;
 288     AliFlatESDTrigger *trigger = SetTriggersStart();
 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();
 299           trigger = trigger->GetNextTriggerNonConst();
 300         }
 301       }
 302     }
 303     SetTriggersEnd( nTriggers, triggerSize );
 304   }
 305
 306   // fill primary vertices
 307
 308   err = SetPrimaryVertexTracks( esd->GetPrimaryVertexTracks(), freeSpace );
 309   if( err!=0 ) return err;
 310   freeSpace = allocatedMemorySize - GetSize();
 311
 312   err = SetPrimaryVertexSPD( esd->GetPrimaryVertexSPD(), freeSpace );
 313   if( err!=0 ) return err;
 314   freeSpace = allocatedMemorySize - GetSize();
 315
 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;
 333        flatTrack->SetFromESDTrack( esdTrack );
 334        trackSize += flatTrack->GetSize();
 335        freeSpace -= flatTrack->GetSize();
 336        nTracks++;
 337        flatTrack = flatTrack->GetNextTrackNonConst();
 338      }
 339    }
 340    SetTracksEnd( nTracks, trackSize );
 341   }
 342
 343   // fill V0s
 344
 345   if( fillV0s ){
 346     size_t v0size = 0;
 347     int nV0s = 0;
 348     AliFlatESDV0 *flatV0 = SetV0sStart();
 349     for( int i=0; i < esd->GetNumberOfV0s(); i++){
 350       AliESDv0 *esdV0 = esd->GetV0( i );
 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();
 358       flatV0 = flatV0->GetNextV0NonConst();
 359     }
 360     SetV0sEnd( nV0s, v0size );
 361   }
 362
 363   return 0;
 364 }
 365