HLT/global/AliFlatESDEvent.h

   1 #ifndef ALIFLATESDEVENT_H
   2 #define ALIFLATESDEVENT_H
   3
   4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  * See cxx source for full Copyright notice                               *
   6  * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli     */
   7
   8 /*
   9  * See implementation file for documentation
  10  */
  11
  12 #include "Rtypes.h"
  13 #include "AliVMisc.h"
  14 #include "AliVEvent.h"
  15 #include "AliFlatESDTrack.h"
  16 #include "AliFlatESDVertex.h"
  17 #include "AliFlatESDFriend.h"
  18 #include "AliESDVertex.h"
  19
  20 class AliFlatESDV0;
  21 class AliFlatESDTrigger;
  22
  23 class AliESDEvent;
  24 class AliESDVertex;
  25
  26 class AliFlatESDEvent :public AliVEvent {
  27  public:
  28   // --------------------------------------------------------------------------------
  29   // -- Constructor / Destructors
  30   AliFlatESDEvent();
  31   ~AliFlatESDEvent() {}
  32
  33   // constructor and method for reinitialisation of virtual table
  34   AliFlatESDEvent( AliVConstructorReinitialisationFlag );
  35   void Reinitialize() { new (this) AliFlatESDEvent( AliVReinitialize ); }
  36
  37   // --------------------------------------------------------------------------------
  38
  39   Double_t  GetMagneticField() const { return fMagneticField; }
  40   UInt_t    GetPeriodNumber()  const { return fPeriodNumber; }
  41   Int_t     GetRunNumber()     const { return fRunNumber; }
  42   UInt_t    GetOrbitNumber()   const { return fOrbitNumber; }
  43   UShort_t  GetBunchCrossNumber() const { return fBunchCrossNumber; }
  44   ULong64_t GetTriggerMask()      const { return fTriggerMask; }
  45   ULong64_t GetTriggerMaskNext50()   const { return fTriggerMaskNext50; }
  46   TString   GetFiredTriggerClasses() const ;
  47
  48   Int_t GetNumberOfTracks() const { return fNTracks; }
  49   Int_t GetNumberOfV0s()    const { return fNV0s; }
  50
  51   void Reset();
  52   void ConnectTracks(){} // initialisation, needed by the ESD event, part of VVevent interface
  53
  54   UInt_t GetTimeStamp()     const { return fTimeStamp; }
  55   UInt_t GetEventSpecie()   const { return fEventSpecie; }
  56   Int_t  GetNumberOfKinks() const { return 0; }
  57
  58   AliVTrack  *GetVTrack( Int_t i ) const { return GetFlatTrackNonConst(i); }
  59   AliESDkink *GetKink(Int_t /*i*/) const { return NULL;}
  60
  61   using AliVEvent::GetPrimaryVertex;
  62   using AliVEvent::GetPrimaryVertexTPC;
  63   using AliVEvent::GetPrimaryVertexSPD;
  64   using AliVEvent::GetPrimaryVertexTracks;
  65   Int_t GetPrimaryVertex( AliESDVertex &v ) const ;
  66   Int_t GetPrimaryVertexTPC( AliESDVertex &v ) const ;
  67   Int_t GetPrimaryVertexSPD( AliESDVertex &v ) const ;
  68   Int_t GetPrimaryVertexTracks( AliESDVertex &v ) const ;
  69
  70   AliVfriendEvent* FindFriend() const { return fFriendEvent; }
  71
  72   // --------------------------------------------------------------------------------
  73   // Own methods
  74
  75   // -- Set methods
  76
  77   Int_t SetFromESD( size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t fillV0s=kTRUE );
  78
  79   void SetFriendEvent( AliFlatESDFriend *f ) { fFriendEvent=f; }
  80
  81   void  SetMagneticField( Double_t mf ){ fMagneticField = mf; }
  82   void  SetPeriodNumber( Int_t n ) { fPeriodNumber = n; }
  83   void  SetRunNumber( Int_t n ) { fRunNumber = n; }
  84   void  SetOrbitNumber( UInt_t n ) { fOrbitNumber = n; }
  85   void  SetBunchCrossNumber( UShort_t n ) { fBunchCrossNumber = n; }
  86   void  SetTimeStamp( UInt_t timeStamp ){ fTimeStamp = timeStamp; }
  87   void  SetEventSpecie(UInt_t eventSpecie){ fEventSpecie = eventSpecie; }
  88   void  SetTriggerMask(ULong64_t n) { fTriggerMask = n; }
  89   void  SetTriggerMaskNext50(ULong64_t n) { fTriggerMaskNext50 = n; }
  90
  91   Int_t  SetPrimaryVertexTracks( const AliESDVertex *v, size_t allocatedVtxMemory );
  92   Int_t  SetPrimaryVertexSPD( const AliESDVertex *v, size_t allocatedVtxMemory  );
  93
  94   AliFlatESDTrigger *SetTriggersStart();
  95   void SetTriggersEnd( Int_t nTriggerClasses, size_t triggersSize );
  96
  97   Int_t SetTracksStart( AliFlatESDTrack* &t, Long64_t* &table, Int_t nTracks, size_t freeMem);
  98   void SetTracksEnd( Int_t nTracks, size_t tracksSize );
  99
 100   AliFlatESDV0 *SetV0sStart();
 101   void SetV0sEnd( Int_t nV0s, size_t v0sSize );
 102
 103   // --------------------------------------------------------------------------------
 104   // -- Getter methods
 105
 106   const AliFlatESDVertex* GetFlatPrimaryVertexSPD() const ;
 107   const AliFlatESDVertex* GetFlatPrimaryVertexTracks() const ;
 108
 109   Int_t GetNumberOfTriggerClasses() const { return fNTriggerClasses; }
 110
 111   const AliFlatESDTrigger *GetTriggerClasses() const { return reinterpret_cast<const AliFlatESDTrigger*>( fContent + fTriggerPointer ); }
 112   const AliFlatESDTrack   *GetTracks() const { return reinterpret_cast<const AliFlatESDTrack*>( fContent + fTracksPointer ); }
 113   const AliFlatESDV0      *GetV0s() const { return reinterpret_cast<const AliFlatESDV0*>( fContent + fV0Pointer ); }
 114
 115   const AliFlatESDTrack  *GetFlatTrack( Int_t i ) const ;
 116   AliFlatESDTrack  *GetFlatTrackNonConst( Int_t i ) const;
 117
 118   // --------------------------------------------------------------------------------
 119   // -- Size methods
 120
 121   ULong64_t  GetSize()  const { return fContent + fContentSize - reinterpret_cast<const Byte_t*>(this); }
 122
 123   static ULong64_t EstimateSize(AliESDEvent*esd, Bool_t fillV0s=kTRUE );
 124
 125   // --------------------------------------------------------------------------------
 126   // AliVEvent interface
 127   virtual void Print(Option_t *option="") const {if (option){}; return;}
 128   virtual void AddObject(TObject* /*obj*/) {}
 129   virtual TObject* FindListObject(const char* /*name*/) const {return NULL;}
 130   virtual TList* GetList() const {return NULL;}
 131   virtual void CreateStdContent() {}
 132   virtual void GetStdContent() {}
 133   virtual void ReadFromTree(TTree* /*tree*/, Option_t* /*opt*/) {}
 134   virtual void WriteToTree(TTree* /*tree*/) const {}
 135   virtual void SetStdNames() {}
 136   virtual AliVHeader* GetHeader() const {return NULL;}
 137   virtual void SetPeriodNumber(UInt_t) {}
 138   virtual void SetEventType(UInt_t) {}
 139   virtual void SetTriggerCluster(UChar_t) {}
 140   virtual UInt_t GetEventType() const {return 0;}
 141   virtual UChar_t GetTriggerCluster() const {return 0;}
 142   virtual Double_t GetZDCN1Energy() const {return 0.;}
 143   virtual Double_t GetZDCP1Energy() const {return 0.;}
 144   virtual Double_t GetZDCN2Energy() const {return 0.;}
 145   virtual Double_t GetZDCP2Energy() const {return 0.;}
 146   virtual Double_t GetZDCEMEnergy(Int_t) const {return 0.;}
 147   virtual AliVParticle* GetTrack(Int_t) const;
 148   virtual Int_t GetNumberOfCascades() const {return 0;}
 149   virtual AliCentrality* GetCentrality() {return NULL;}
 150   virtual AliEventplane* GetEventplane() {return NULL;}
 151   virtual Int_t EventIndex(Int_t) const {return 0;}
 152   virtual Int_t EventIndexForCaloCluster(Int_t) const {return 0;}
 153   virtual Int_t EventIndexForPHOSCell(Int_t) const {return 0;}
 154   virtual Int_t EventIndexForEMCALCell(Int_t) const {return 0;}
 155   virtual AliVVZERO* GetVZEROData() const {return NULL;}
 156   virtual AliVZDC   *GetZDCData() const {return NULL;}
 157   virtual AliVEvent::EDataLayoutType GetDataLayoutType() const;
 158
 159  private:
 160
 161   AliFlatESDEvent( const AliFlatESDEvent& );
 162   AliFlatESDEvent& operator=( const AliFlatESDEvent& );
 163
 164   // --------------------------------------------------------------------------------
 165
 166   // -- Fixed size member objects ( try to align in memory )
 167
 168   size_t     fContentSize;     // Size of fContent
 169   Double32_t fMagneticField;   // Solenoid Magnetic Field in kG : for compatibility with AliMagF
 170   UInt_t     fPeriodNumber;    // PeriodNumber
 171   Int_t      fRunNumber;       // Run Number
 172   UInt_t     fOrbitNumber;     // Orbit Number
 173   UInt_t     fTimeStamp;         // Time stamp
 174   UInt_t     fEventSpecie;       // Reconstruction event specie (1-default,2-lowM,4-highM,8-cosmic,16-cal)
 175   UShort_t   fBunchCrossNumber;  // Bunch Crossing Number
 176   Byte_t     fPrimaryVertexMask;            // Bit mask specfifying which primary vertices are present
 177   ULong64_t  fTriggerMask;      // Trigger mask, first 50 bits
 178   ULong64_t  fTriggerMaskNext50;      // Trigger mask, next 50 bits
 179
 180   UInt_t  fNTriggerClasses;  // N trigger classes
 181   UInt_t  fNPrimaryVertices; // Number of primary vertices in array
 182   UInt_t  fNTracks;          // Number of tracks in array
 183   UInt_t  fNV0s;             // Number of v0's
 184
 185   // Pointers to specific data in fContent
 186
 187   size_t fTriggerPointer;        // position of the first trigger description in fContent
 188   size_t fPrimaryVertexTracksPointer; // position of primary vertex tracks in fContent
 189   size_t fPrimaryVertexSPDPointer;  // position of primary vertex SPD in fContent
 190   size_t fTrackTablePointer;     // position of the first track pointer in fContent
 191   size_t fTracksPointer;         // position of the first track in fContent
 192   size_t fV0Pointer;             // position of the first V0 in fContent
 193
 194   //
 195   AliFlatESDFriend *fFriendEvent;
 196
 197   // --------------------------------------------------------------------------------
 198
 199   // -- Variable Size Object
 200
 201   Byte_t fContent[1];                  // Variale size object, which contains all data
 202
 203   ClassDef(AliFlatESDEvent,0)
 204 };
 205
 206 // Inline implementations
 207
 208 inline AliFlatESDTrack  *AliFlatESDEvent::GetFlatTrackNonConst( Int_t i ) const
 209 {
 210   const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
 211   if( i<0 || i>(int) fNTracks || table[i]<0 ) return NULL;
 212   return reinterpret_cast<AliFlatESDTrack*>( const_cast<Byte_t*>(fContent + table[i]) );
 213 }
 214
 215 inline const AliFlatESDTrack  *AliFlatESDEvent::GetFlatTrack( Int_t i ) const
 216 {
 217   const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
 218   if( i<0 || i>(int) fNTracks || table[i]<0 ) return NULL;
 219   return reinterpret_cast<const AliFlatESDTrack*>( fContent + table[i] );
 220 }
 221
 222
 223 inline Int_t AliFlatESDEvent::SetTracksStart( AliFlatESDTrack* &t, Long64_t* &table, Int_t nTracks, size_t freeMem)
 224 {
 225   fNTracks = 0;
 226   if( nTracks*sizeof(Long64_t)  > freeMem ) return -1;
 227   fTrackTablePointer = fContentSize;
 228   fContentSize += nTracks*sizeof(Long64_t);
 229   fTracksPointer = fContentSize;
 230   table = reinterpret_cast< Long64_t* >( fContent + fTrackTablePointer );
 231   t = reinterpret_cast< AliFlatESDTrack* >( fContent + fTracksPointer );
 232   return 0;
 233 }
 234
 235 inline void AliFlatESDEvent::SetTracksEnd( Int_t nTracks, size_t tracksSize )
 236 {
 237   if( nTracks<0 ) return;
 238   Long64_t *table = reinterpret_cast< Long64_t*> (fContent + fTrackTablePointer);
 239   for( int i=0; i<nTracks; i++ ) table[i]+=fTracksPointer;
 240   fNTracks = nTracks;
 241   fContentSize += tracksSize;
 242 }
 243
 244 inline AliFlatESDV0 *AliFlatESDEvent::SetV0sStart()
 245 {
 246   fNV0s = 0;
 247   fV0Pointer = fContentSize;
 248   return reinterpret_cast< AliFlatESDV0* >( fContent + fContentSize );
 249 }
 250
 251 inline void AliFlatESDEvent::SetV0sEnd( Int_t nV0s, size_t v0sSize )
 252 {
 253   fNV0s = nV0s;
 254   fContentSize += v0sSize;
 255 }
 256
 257 inline AliFlatESDTrigger *AliFlatESDEvent::SetTriggersStart()
 258 {
 259   fNTriggerClasses = 0;
 260   fTriggerPointer = fContentSize;
 261   return reinterpret_cast< AliFlatESDTrigger* >( fContent + fContentSize );
 262 }
 263
 264 inline void AliFlatESDEvent::SetTriggersEnd( Int_t nTriggerClasses, size_t triggersSize )
 265 {
 266   fNTriggerClasses = nTriggerClasses;
 267   fContentSize += triggersSize;
 268 }
 269
 270 inline const AliFlatESDVertex* AliFlatESDEvent::GetFlatPrimaryVertexTracks() const
 271 {
 272   return (fPrimaryVertexMask & 0x1) ? (reinterpret_cast<const AliFlatESDVertex*>(fContent + fPrimaryVertexTracksPointer)  ) : NULL;
 273 }
 274
 275 inline const AliFlatESDVertex* AliFlatESDEvent::GetFlatPrimaryVertexSPD() const
 276 {
 277   return (fPrimaryVertexMask & 0x2) ? reinterpret_cast<const AliFlatESDVertex*>(fContent + fPrimaryVertexSPDPointer) : NULL;
 278 }
 279
 280 inline Int_t AliFlatESDEvent::GetPrimaryVertexSPD( AliESDVertex &v ) const
 281 {
 282   const AliFlatESDVertex* flatVertex = GetFlatPrimaryVertexSPD();
 283   if( !flatVertex ) return -1;
 284   flatVertex->GetESDVertex( v );
 285   return 0;
 286 }
 287
 288 inline Int_t AliFlatESDEvent::GetPrimaryVertexTracks( AliESDVertex &v ) const
 289 {
 290   const AliFlatESDVertex* flatVertex = GetFlatPrimaryVertexTracks();
 291   if( !flatVertex ) return -1;
 292   flatVertex->GetESDVertex( v );
 293   return 0;
 294 }
 295
 296 inline Int_t AliFlatESDEvent::GetPrimaryVertexTPC( AliESDVertex &/*v*/ ) const
 297 {
 298   return -1;
 299 }
 300
 301 inline Int_t AliFlatESDEvent::GetPrimaryVertex( AliESDVertex &v ) const
 302 {
 303   int ret = GetPrimaryVertexTracks( v );
 304   if( ret<0 ) ret = GetPrimaryVertexSPD( v );
 305   return ret;
 306 }
 307
 308
 309 #endif