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         // one Long64_t per track for tracks table
 201   size += esd->GetNumberOfTracks() * ( AliFlatESDTrack::EstimateSize() + sizeof(Long64_t) );
 202   size += AliESDRun::kNTriggerClasses * sizeof(AliFlatESDTrigger) ;
 203   if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0);
 204   return size;
 205 }
 206
 207 Int_t AliFlatESDEvent::SetPrimaryVertexTracks( const AliESDVertex *vtx, size_t allocatedVtxMemory )
 208 {
 209   // fill primary vertex tracks
 210   if( !vtx ) return 0;
 211         if(!vtx->GetStatus()) return 0;
 212   if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1;
 213   fPrimaryVertexMask |= 0x1;
 214   fPrimaryVertexTracksPointer = fContentSize;
 215   AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
 216   flatVtx->SetFromESDVertex( *vtx );
 217   fContentSize += flatVtx->GetSize();
 218   return 0;
 219 }
 220
 221 Int_t AliFlatESDEvent::SetPrimaryVertexSPD( const AliESDVertex *vtx, size_t allocatedVtxMemory  )
 222 {
 223   // fill primary vertex SPD
 224   if( !vtx ) return 0;
 225         if(!vtx->GetStatus()) return 0;
 226   if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1;
 227   fPrimaryVertexMask |= 0x2;
 228   fPrimaryVertexSPDPointer = fContentSize;
 229   AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
 230   flatVtx->SetFromESDVertex( *vtx );
 231   fContentSize += flatVtx->GetSize();
 232   return 0;
 233 }
 234
 235
 236 // _______________________________________________________________________________________________________
 237 Int_t AliFlatESDEvent::SetFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t fillV0s)
 238 {
 239   // Fill flat ESD event from normal ALiESDEvent
 240   // - Fill tracks + v0s
 241   // -> Added objects have to be added here as well
 242
 243   if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1;
 244
 245   Reset();
 246
 247   if( !esd ) return 0;
 248
 249   Int_t err = 0;
 250   size_t freeSpace = allocatedMemorySize - GetSize();
 251
 252   // fill run info
 253   {
 254     SetMagneticField( esd->GetMagneticField() );
 255     SetPeriodNumber( esd->GetPeriodNumber() );
 256     SetRunNumber( esd->GetRunNumber() );
 257     SetOrbitNumber( esd->GetOrbitNumber() );
 258     SetBunchCrossNumber( esd->GetBunchCrossNumber() );
 259     SetTimeStamp( esd->GetTimeStamp() );
 260     SetEventSpecie( esd->GetEventSpecie() );
 261     SetTriggerMask( esd->GetTriggerMask() );
 262     SetTriggerMaskNext50( esd->GetTriggerMaskNext50() );
 263   }
 264
 265   // Fill trigger information
 266   {
 267     size_t triggerSize = 0;
 268     int nTriggers = 0;
 269     AliFlatESDTrigger *trigger = SetTriggersStart();
 270     const AliESDRun*  esdRun = esd->GetESDRun();
 271     if( esdRun ){
 272       for( int index=0; index<AliESDRun::kNTriggerClasses; index++){
 273         const char* name = esdRun->GetTriggerClass(index);
 274         if( name && name[0]!='\0' ){
 275           err = trigger->SetTriggerClass( name, index, freeSpace );
 276           if( err!=0 ) return err;
 277           nTriggers++;
 278           freeSpace -= trigger->GetSize();
 279           triggerSize += trigger->GetSize();
 280           trigger = trigger->GetNextTriggerNonConst();
 281         }
 282       }
 283     }
 284     SetTriggersEnd( nTriggers, triggerSize );
 285   }
 286
 287   // fill primary vertices
 288
 289   err = SetPrimaryVertexTracks( esd->GetPrimaryVertexTracks(), freeSpace );
 290   if( err!=0 ) return err;
 291   freeSpace = allocatedMemorySize - GetSize();
 292
 293   err = SetPrimaryVertexSPD( esd->GetPrimaryVertexSPD(), freeSpace );
 294   if( err!=0 ) return err;
 295   freeSpace = allocatedMemorySize - GetSize();
 296
 297   // fill tracks
 298   {
 299    size_t trackSize = 0;
 300    int nTracks = 0;
 301    Long64_t *table = NULL;
 302    AliFlatESDTrack *flatTrack = NULL;
 303    err = SetTracksStart( flatTrack, table, esd->GetNumberOfTracks(), freeSpace );
 304    if( err!=0 ) return err;
 305    freeSpace = allocatedMemorySize - GetSize();
 306
 307    for (Int_t idxTrack = 0; idxTrack < esd->GetNumberOfTracks(); ++idxTrack) {
 308      AliESDtrack *esdTrack = esd->GetTrack(idxTrack);
 309      table[idxTrack] = -1;
 310      if (esdTrack) {
 311        table[idxTrack] = trackSize;
 312        if( freeSpace<flatTrack->EstimateSize() ) return -1;
 313        new (flatTrack) AliFlatESDTrack;
 314        flatTrack->SetFromESDTrack( esdTrack );
 315        trackSize += flatTrack->GetSize();
 316        freeSpace -= flatTrack->GetSize();
 317        nTracks++;
 318        flatTrack = flatTrack->GetNextTrackNonConst();
 319      }
 320    }
 321    SetTracksEnd( nTracks, trackSize );
 322   }
 323
 324   // fill V0s
 325
 326   if( fillV0s ){
 327     size_t v0size = 0;
 328     int nV0s = 0;
 329     AliFlatESDV0 *flatV0 = SetV0sStart();
 330     for( int i=0; i < esd->GetNumberOfV0s(); i++){
 331       AliESDv0 *esdV0 = esd->GetV0( i );
 332       if( !esdV0 || freeSpace < flatV0->GetSize() ) return -1;
 333       new (flatV0) AliFlatESDV0;
 334       flatV0->SetNegTrackID( esdV0->GetNindex());
 335       flatV0->SetPosTrackID( esdV0->GetPindex());
 336       nV0s++;
 337       v0size += flatV0->GetSize();
 338       freeSpace -= flatV0->GetSize();
 339       flatV0 = flatV0->GetNextV0NonConst();
 340     }
 341     SetV0sEnd( nV0s, v0size );
 342   }
 343
 344   return 0;
 345 }
 346
 347 AliVParticle* AliFlatESDEvent::GetTrack(Int_t i) const
 348 {
 349   return const_cast<AliFlatESDTrack*>(GetFlatTrack(i));
 350 }
 351
 352 AliVEvent::EDataLayoutType AliFlatESDEvent::GetDataLayoutType() const
 353 {
 354   return AliVEvent::kFlat;
 355 }
 356