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   AliVVevent(),
  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 {
  94   // Default constructor
  95   fContent[0]=0;
  96 }
  97
  98
  99 TString AliFlatESDEvent::GetFiredTriggerClasses() const
 100 {
 101   // Fired trigger classes
 102   TString trclasses;
 103   const AliFlatESDTrigger *tr = GetTriggerClasses();
 104   ULong64_t mask = GetTriggerMask() | GetTriggerMaskNext50();
 105   for(Int_t i = 0; i < GetNumberOfTriggerClasses(); i++) {
 106     int index = tr->GetTriggerIndex();
 107     if( mask & (1ull<<index) ){
 108       trclasses += " ";
 109       trclasses += tr->GetTriggerClassName();
 110       trclasses += " ";
 111     }
 112   }
 113   tr = tr->GetNextTrigger();
 114   return trclasses;
 115 }
 116
 117
 118 void AliFlatESDEvent::Reset()
 119 {
 120   // Init
 121
 122   fContentSize = 0;
 123   fMagneticField = 0;
 124   fPeriodNumber = 0;
 125   fRunNumber = 0;
 126   fOrbitNumber = 0;
 127   fTimeStamp = 0;
 128   fBunchCrossNumber = 0;
 129   fPrimaryVertexMask = 0;
 130   fTriggerMask = 0;
 131   fTriggerMaskNext50 = 0;
 132   fNTriggerClasses = 0;
 133   fNPrimaryVertices = 0;
 134   fNTracks = 0;
 135   fNV0s = 0;
 136   fTriggerPointer = 0;
 137   fPrimaryVertexTracksPointer = 0;
 138   fPrimaryVertexSPDPointer = 0;
 139   fTrackTablePointer = 0;
 140   fTracksPointer = 0;
 141   fV0Pointer = 0;
 142 }
 143
 144 // _______________________________________________________________________________________________________
 145   ULong64_t AliFlatESDEvent::EstimateSize(AliESDEvent *esd, Bool_t fillV0s)
 146 {
 147   // Estimate upper limit of the object size
 148   // -> Added objects have to be added here as well
 149
 150   ULong64_t size = sizeof(AliFlatESDEvent);
 151   size += 2 * sizeof( AliFlatESDVertex );
 152   size += esd->GetNumberOfTracks() * ( AliFlatESDTrack::EstimateSize() + sizeof(Long64_t) );
 153   if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0);
 154   return size;
 155 }
 156
 157 Int_t AliFlatESDEvent::SetPrimaryVertexTracks( const AliESDVertex *vtx, size_t allocatedVtxMemory )
 158 {
 159   // fill primary vertex tracks
 160   if( !vtx ) return 0;
 161   if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1;
 162   fPrimaryVertexMask |= 0x1;
 163   fPrimaryVertexTracksPointer = fContentSize;
 164   AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
 165   flatVtx->Set( *vtx );
 166   fContentSize += flatVtx->GetSize();
 167   return 0;
 168 }
 169
 170 Int_t AliFlatESDEvent::SetPrimaryVertexSPD( const AliESDVertex *vtx, size_t allocatedVtxMemory  )
 171 {
 172   // fill primary vertex SPD
 173   if( !vtx ) return 0;
 174   if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1;
 175   fPrimaryVertexMask |= 0x2;
 176   fPrimaryVertexSPDPointer = fContentSize;
 177   AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
 178   flatVtx->Set( *vtx );
 179   fContentSize += flatVtx->GetSize();
 180   return 0;
 181 }
 182
 183
 184 // _______________________________________________________________________________________________________
 185 Int_t AliFlatESDEvent::SetFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t fillV0s)
 186 {
 187   // Fill flat ESD event from normal ALiESDEvent
 188   // - Fill tracks + v0s
 189   // -> Added objects have to be added here as well
 190
 191   if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1;
 192
 193   Reset();
 194
 195   if( !esd ) return 0;
 196
 197   Int_t err = 0;
 198   size_t freeSpace = allocatedMemorySize - GetSize();
 199
 200   // fill run info
 201   {
 202     SetMagneticField( esd->GetMagneticField() );
 203     SetPeriodNumber( esd->GetPeriodNumber() );
 204     SetRunNumber( esd->GetRunNumber() );
 205     SetOrbitNumber( esd->GetOrbitNumber() );
 206     SetBunchCrossNumber( esd->GetBunchCrossNumber() );
 207     SetTimeStamp( esd->GetTimeStamp() );
 208     SetEventSpecie( esd->GetEventSpecie() );
 209     SetTriggerMask( esd->GetTriggerMask() );
 210     SetTriggerMaskNext50( esd->GetTriggerMaskNext50() );
 211   }
 212
 213   // Fill trigger information
 214   {
 215     size_t triggerSize = 0;
 216     int nTriggers = 0;
 217     AliFlatESDTrigger *trigger = SetTriggersStart();
 218     const AliESDRun*  esdRun = esd->GetESDRun();
 219     if( esdRun ){
 220       for( int index=0; index<AliESDRun::kNTriggerClasses; index++){
 221         const char* name = esdRun->GetTriggerClass(index);
 222         if( name && name[0]!='\0' ){
 223           err = trigger->SetTriggerClass( name, index, freeSpace );
 224           if( err!=0 ) return err;
 225           nTriggers++;
 226           freeSpace -= trigger->GetSize();
 227           triggerSize += trigger->GetSize();
 228           trigger = trigger->GetNextTriggerNonConst();
 229         }
 230       }
 231     }
 232     SetTriggersEnd( nTriggers, triggerSize );
 233   }
 234
 235   // fill primary vertices
 236
 237   err = SetPrimaryVertexTracks( esd->GetPrimaryVertexTracks(), freeSpace );
 238   if( err!=0 ) return err;
 239   freeSpace = allocatedMemorySize - GetSize();
 240
 241   err = SetPrimaryVertexSPD( esd->GetPrimaryVertexSPD(), freeSpace );
 242   if( err!=0 ) return err;
 243   freeSpace = allocatedMemorySize - GetSize();
 244
 245   // fill tracks
 246   {
 247    size_t trackSize = 0;
 248    int nTracks = 0;
 249    Long64_t *table = NULL;
 250    AliFlatESDTrack *flatTrack = NULL;
 251    err = SetTracksStart( flatTrack, table, esd->GetNumberOfTracks(), freeSpace );
 252    if( err!=0 ) return err;
 253    freeSpace = allocatedMemorySize - GetSize();
 254
 255    for (Int_t idxTrack = 0; idxTrack < esd->GetNumberOfTracks(); ++idxTrack) {
 256      AliESDtrack *esdTrack = esd->GetTrack(idxTrack);
 257      table[idxTrack] = -1;
 258      if (esdTrack) {
 259        table[idxTrack] = trackSize;
 260        if( freeSpace<flatTrack->EstimateSize() ) return -1;
 261        new (flatTrack) AliFlatESDTrack;
 262        flatTrack->Set( esdTrack );
 263        trackSize += flatTrack->GetSize();
 264        freeSpace -= flatTrack->GetSize();
 265        nTracks++;
 266        flatTrack = flatTrack->GetNextTrack();
 267      }
 268    }
 269    SetTracksEnd( nTracks, trackSize );
 270   }
 271
 272   // fill V0s
 273
 274   if( fillV0s ){
 275     size_t v0size = 0;
 276     int nV0s = 0;
 277     AliFlatESDV0 *flatV0 = SetV0sStart();
 278     for( int i=0; i < esd->GetNumberOfV0s(); i++){
 279       AliESDv0 *esdV0 = esd->GetV0( i );
 280       if( !esdV0 || freeSpace < flatV0->GetSize() ) return -1;
 281       new (flatV0) AliFlatESDV0;
 282       flatV0->SetNegTrackID( esdV0->GetNindex());
 283       flatV0->SetPosTrackID( esdV0->GetPindex());
 284       nV0s++;
 285       v0size += flatV0->GetSize();
 286       freeSpace -= flatV0->GetSize();
 287     }
 288     SetV0sEnd( nV0s, v0size );
 289   }
 290
 291   return 0;
 292 }
 293