X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2Fglobal%2FAliFlatESDEvent.cxx;h=3889e6cdb3dd5eacf7966c00f90de382b8fb12fa;hb=2e3382cc5851d7212bff666d39755026ef83196b;hp=d0669a43c80276db4c5f3d15beb133b2e4ef596f;hpb=8fcd85569c27a11b9ec6fc8787cdc1ef8c81f5ce;p=u%2Fmrichter%2FAliRoot.git

diff --git a/HLT/global/AliFlatESDEvent.cxx b/HLT/global/AliFlatESDEvent.cxx
index d0669a43c80..3889e6cdb3d 100644
--- a/HLT/global/AliFlatESDEvent.cxx
+++ b/HLT/global/AliFlatESDEvent.cxx
@@ -57,227 +57,300 @@
 #include "AliFlatTPCCluster.h"
 #include "AliFlatExternalTrackParam.h"
 #include "Riostream.h"
+
 #include "AliFlatESDVertex.h"
 
+#include "AliFlatESDV0.h"
+#include "AliFlatESDTrigger.h"
+
+#include "AliESDEvent.h"
+#include "AliESDVertex.h"
+
 // _______________________________________________________________________________________________________
-AliFlatESDEvent::AliFlatESDEvent() :
-  // Default constructor
+AliFlatESDEvent::AliFlatESDEvent() 
+  :
+  fContentSize(0),
+  fMagneticField(0),
+  fPeriodNumber(0),
+  fRunNumber(0),
+  fOrbitNumber(0),
+  fTimeStamp(0),
+  fEventSpecie(0),
+  fBunchCrossNumber(0),
   fPrimaryVertexMask(0),
+  fTriggerMask(0),
+  fTriggerMaskNext50(0),
+  fNTriggerClasses(0),
+  fNPrimaryVertices(0),
   fNTracks(0),
-  fTracksPointer(0),
   fNV0s(0),
+  fTriggerPointer(0),
+  fPrimaryVertexTracksPointer(0),
+  fPrimaryVertexSPDPointer(0),
+  fTrackTablePointer(0),
+  fTracksPointer(0),
   fV0Pointer(0),
-  fSize(0),
-  fContent() 
+  fFriendEvent(NULL)
 {
+  // Default constructor
+  fContent[0]=0;
 }
 
-// _______________________________________________________________________________________________________
-AliFlatESDEvent::AliFlatESDEvent(Bool_t)
+#pragma GCC diagnostic ignored "-Weffc++" 
+AliFlatESDEvent::AliFlatESDEvent( AliVConstructorReinitialisationFlag /*f*/ ) 
+  :
+ fFriendEvent(NULL)
 {
-  //special constructor, used to restore the vtable pointer
-  //uses the special dummy constructors of contained objects
-  AliFlatESDVertex* vertexSPD = const_cast<AliFlatESDVertex*>(GetPrimaryVertexSPD());
-  if (vertexSPD ) { new (vertexSPD) AliFlatESDVertex(1); }
-  AliFlatESDVertex* vertexTracks = const_cast<AliFlatESDVertex*>(GetPrimaryVertexTracks());
-  if (vertexTracks ) { new (vertexTracks) AliFlatESDVertex(1); }
-  AliFlatESDTrack* track = GetTracks();
-  for (Int_t i=0; i<GetNumberOfTracks(); i++)
+  // Constructor for reinitialisation of vtable
+  
+  // Reinitialise trigger information  
   {
-    new (track) AliFlatESDTrack(1);
-    track += track->GetSize();
+    AliFlatESDTrigger * trigger =  reinterpret_cast< AliFlatESDTrigger*>( fContent + fTriggerPointer ); 
+    for( UInt_t i=0; i<fNTriggerClasses; i++ ){
+      trigger->Reinitialize();
+      trigger = trigger->GetNextTriggerNonConst();
+    }
   }
-  AliFlatESDV0* v0 = GetV0s();
-  for (Int_t i=0; i<GetNumberOfV0s(); i++)
+
+  // Reinitialise primary vertices
+
+  if( fPrimaryVertexMask & 0x1 ){
+    AliFlatESDVertex *vtxSPD = reinterpret_cast<AliFlatESDVertex*>(fContent + fPrimaryVertexSPDPointer);
+    vtxSPD->Reinitialize();
+  }
+  if( fPrimaryVertexMask & 0x2 ){
+    AliFlatESDVertex *vtxTracks = reinterpret_cast<AliFlatESDVertex*>(fContent + fPrimaryVertexTracksPointer);
+    vtxTracks->Reinitialize();
+  }
+
+  // Reinitialise tracks 
   {
-    new (v0) AliFlatESDV0(1);
-    v0 += sizeof(AliFlatESDV0);
+    AliFlatESDTrack *track = reinterpret_cast<AliFlatESDTrack*>( fContent + fTracksPointer );
+    for( UInt_t i=0; i<fNTracks; i++ ){
+      track->Reinitialize();
+      track = track->GetNextTrackNonConst();
+    }
   }
-}
 
-/*
-AliFlatESDEvent::AliFlatESDEvent(const AliFlatESDEvent& ev) :
-  // Default constructor
-  fPrimaryVertexMask(ev.fPrimaryVertexMask),
-  fNTracks(ev.fNTracks),
-  fTracksPointer(ev.fTracksPointer),
-  fNV0s(ev.fNV0s),
-  fV0Pointer(ev.fV0Pointer),
-  fSize(ev.fSize),
-  fContent() 
-{
-}
-*/
-// _______________________________________________________________________________________________________
-AliFlatESDEvent::AliFlatESDEvent(AliESDEvent *esd) :
-  // Constructor
-  fPrimaryVertexMask(0),
-  fNTracks(0),
-  fTracksPointer(0),
-  fNV0s(0),
-  fV0Pointer(0),
-  fSize(0),
-  fContent() 
-{ 
-  Fill(esd);
+  // Reinitialise V0s
+  {
+    AliFlatESDV0 *v0 = reinterpret_cast<AliFlatESDV0*>( fContent + fV0Pointer ); 
+    for( UInt_t i=0; i < fNV0s; i++){
+      v0->Reinitialize();
+      v0 = v0->GetNextV0NonConst();
+    }
+  }
 }
+#pragma GCC diagnostic warning "-Weffc++" 
 
-// _______________________________________________________________________________________________________
-AliFlatESDEvent::AliFlatESDEvent(AliESDEvent *esd, Bool_t useESDFriends) :
-  // Constructor
-  fPrimaryVertexMask(0),
-  fNTracks(0),
-  fTracksPointer(0),
-  fNV0s(0),
-  fV0Pointer(0),
-  fSize(0),
-  fContent() 
+
+TString AliFlatESDEvent::GetFiredTriggerClasses() const 
 { 
-  Fill(esd, useESDFriends);
+  // Fired trigger classes
+  TString trclasses; 
+  const AliFlatESDTrigger *tr = GetTriggerClasses();
+  ULong64_t mask = GetTriggerMask() | GetTriggerMaskNext50();
+  for(Int_t i = 0; i < GetNumberOfTriggerClasses(); i++) {
+    int index = tr->GetTriggerIndex();    
+    if( mask & (1ull<<index) ){
+      trclasses += " ";
+      trclasses += tr->GetTriggerClassName();
+      trclasses += " ";
+    }
+  }
+  tr = tr->GetNextTrigger();
+  return trclasses;
 }
 
-// _______________________________________________________________________________________________________
-AliFlatESDEvent::~AliFlatESDEvent() 
+
+void AliFlatESDEvent::Reset()
 {
-  // Destructor
+  // Init
+
+  fContentSize = 0;
+  fMagneticField = 0;
+  fPeriodNumber = 0;
+  fRunNumber = 0;
+  fOrbitNumber = 0;
+  fTimeStamp = 0;
+  fBunchCrossNumber = 0;
+  fPrimaryVertexMask = 0;
+  fTriggerMask = 0;
+  fTriggerMaskNext50 = 0;
+  fNTriggerClasses = 0;
+  fNPrimaryVertices = 0;
+  fNTracks = 0;
+  fNV0s = 0;
+  fTriggerPointer = 0;
+  fPrimaryVertexTracksPointer = 0;
+  fPrimaryVertexSPDPointer = 0;
+  fTrackTablePointer = 0;
+  fTracksPointer = 0;
+  fV0Pointer = 0;
 }
 
 // _______________________________________________________________________________________________________
-  ULong64_t AliFlatESDEvent::EstimateSize(AliESDEvent *esd, Bool_t useESDFriends, Bool_t fillV0s) 
+  ULong64_t AliFlatESDEvent::EstimateSize(AliESDEvent *esd, Bool_t fillV0s) 
 {
   // Estimate upper limit of the object size
   // -> Added objects have to be added here as well
   
   ULong64_t size = sizeof(AliFlatESDEvent);
   size += 2 * sizeof( AliFlatESDVertex );
-  size += esd->GetNumberOfTracks() * AliFlatESDTrack::EstimateSize(useESDFriends);
+	// one Long64_t per track for tracks table
+  size += esd->GetNumberOfTracks() * ( AliFlatESDTrack::EstimateSize() + sizeof(Long64_t) );
+  size += AliESDRun::kNTriggerClasses * sizeof(AliFlatESDTrigger) ;
   if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0);
   return size;
 }
 
-void AliFlatESDEvent::FillPrimaryVertices( const AliESDVertex *vertexSPD,
-					    const AliESDVertex *vertexTracks )
+Int_t AliFlatESDEvent::SetPrimaryVertexTracks( const AliESDVertex *vtx, size_t allocatedVtxMemory )
 {
-  // fill primary vertices
-  
-  fPrimaryVertexMask = 0;
-  fSize = 0;
-
-  Byte_t flag = 0x1;
-  FillPrimaryVertex(vertexSPD, flag);
-
-  flag = 0x2;
-  FillPrimaryVertex(vertexTracks, flag);
-
-  fTracksPointer = fSize;
-  fV0Pointer = fSize;
-}
-
-void AliFlatESDEvent::FillPrimaryVertex(const AliESDVertex *v, Byte_t flag) 
-{
-  
-  // Fill primary vertex parameters
-
-  if (!v) return;
-
-  AliFlatESDVertex *vtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fSize);
-  new(vtx) AliFlatESDVertex;
-  vtx->Set( *v );    
-  fPrimaryVertexMask |= flag;
-  fSize += sizeof(AliFlatESDVertex);
+  // fill primary vertex tracks
+  if( !vtx ) return 0;
+	if(!vtx->GetStatus()) return 0;
+  if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1;
+  fPrimaryVertexMask |= 0x1;
+  fPrimaryVertexTracksPointer = fContentSize;
+  AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
+  flatVtx->SetFromESDVertex( *vtx );
+  fContentSize += flatVtx->GetSize();
+  return 0;
 }
 
-
-Int_t AliFlatESDEvent::FillNextTrack( const AliESDtrack* esdTrack, AliESDfriendTrack* friendTrack)
+Int_t AliFlatESDEvent::SetPrimaryVertexSPD( const AliESDVertex *vtx, size_t allocatedVtxMemory  )
 {
-  // fill next track
-
-  AliFlatESDTrack * flatTrack = reinterpret_cast<AliFlatESDTrack*>(fContent+fSize);
-  new(flatTrack) AliFlatESDTrack;
-  flatTrack->Fill(esdTrack, friendTrack);
-  fSize += flatTrack->GetSize();
-  ++fNTracks;
+  // fill primary vertex SPD
+  if( !vtx ) return 0;
+	if(!vtx->GetStatus()) return 0;
+  if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1;
+  fPrimaryVertexMask |= 0x2;
+  fPrimaryVertexSPDPointer = fContentSize;
+  AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
+  flatVtx->SetFromESDVertex( *vtx );
+  fContentSize += flatVtx->GetSize();
   return 0;
 }
 
-void AliFlatESDEvent::Reset()
-{
-  fSize = 0;
-  fNTracks=0;
-  fNV0s = 0;  
-  fPrimaryVertexMask = 0;
-  fTracksPointer = 0;  
-  fV0Pointer = 0; 
-}
 
 // _______________________________________________________________________________________________________
-Int_t AliFlatESDEvent::Fill(const AliESDEvent *esd, const Bool_t useESDFriends, const Bool_t fillV0s )
+Int_t AliFlatESDEvent::SetFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t fillV0s)
 {
   // Fill flat ESD event from normal ALiESDEvent
-  // - Fill tracks + friends (if requested)
+  // - Fill tracks + v0s
   // -> Added objects have to be added here as well
+ 
+  if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1;
 
   Reset();
   
-  FillPrimaryVertices( esd->GetPrimaryVertexSPD(), esd->GetPrimaryVertexTracks() );
-
-  // -- Get ESD friends
-  // -------------------------------------------------------
-  Bool_t connectESDFriends = useESDFriends;
-  AliESDfriend* esdFriend  = NULL;
-
-   if (connectESDFriends) {
-    esdFriend = dynamic_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));  
-    if (!esdFriend) {
-      connectESDFriends = kFALSE;
-      Printf("WARNING: friends not available, cluster information will not be included");
+  if( !esd ) return 0;
+  
+  Int_t err = 0;
+  size_t freeSpace = allocatedMemorySize - GetSize();
+
+  // fill run info
+  {
+    SetMagneticField( esd->GetMagneticField() );
+    SetPeriodNumber( esd->GetPeriodNumber() );
+    SetRunNumber( esd->GetRunNumber() );
+    SetOrbitNumber( esd->GetOrbitNumber() );
+    SetBunchCrossNumber( esd->GetBunchCrossNumber() );
+    SetTimeStamp( esd->GetTimeStamp() );
+    SetEventSpecie( esd->GetEventSpecie() );
+    SetTriggerMask( esd->GetTriggerMask() );
+    SetTriggerMaskNext50( esd->GetTriggerMaskNext50() );
+  }
+ 
+  // Fill trigger information  
+  {
+    size_t triggerSize = 0;
+    int nTriggers = 0;
+    AliFlatESDTrigger *trigger = SetTriggersStart();
+    const AliESDRun*  esdRun = esd->GetESDRun();
+    if( esdRun ){ 
+      for( int index=0; index<AliESDRun::kNTriggerClasses; index++){
+        const char* name = esdRun->GetTriggerClass(index);
+	if( name && name[0]!='\0' ){
+          err = trigger->SetTriggerClass( name, index, freeSpace );
+	  if( err!=0 ) return err;
+	  nTriggers++;
+	  freeSpace -= trigger->GetSize();
+	  triggerSize += trigger->GetSize();
+	  trigger = trigger->GetNextTriggerNonConst();
+        }
+      }
     }
-    else 
-      Printf("INFO: friends are available, cluster information will be included");
+    SetTriggersEnd( nTriggers, triggerSize );    
   }
 
-  // -- Track loop, fill AliFlatESDTrack sub structure
-  // -------------------------------------------------------
-  for (Int_t idxTrack = 0; idxTrack < esd->GetNumberOfTracks(); ++idxTrack) {
-    AliESDtrack       *esdTrack    = esd->GetTrack(idxTrack);
-    AliESDfriendTrack *friendTrack = NULL;
+  // fill primary vertices
 
-    if (esdTrack) {
-      if (connectESDFriends){
-	friendTrack = esdFriend->GetTrack(idxTrack);
-      }
-      FillNextTrack( esdTrack, friendTrack);
-    }
+  err = SetPrimaryVertexTracks( esd->GetPrimaryVertexTracks(), freeSpace );
+  if( err!=0 ) return err;
+  freeSpace = allocatedMemorySize - GetSize();
+
+  err = SetPrimaryVertexSPD( esd->GetPrimaryVertexSPD(), freeSpace );
+  if( err!=0 ) return err;
+  freeSpace = allocatedMemorySize - GetSize();
+
+  // fill tracks 
+  {
+   size_t trackSize = 0;
+   int nTracks = 0;
+   Long64_t *table = NULL;
+   AliFlatESDTrack *flatTrack = NULL;
+   err = SetTracksStart( flatTrack, table, esd->GetNumberOfTracks(), freeSpace );
+   if( err!=0 ) return err;
+   freeSpace = allocatedMemorySize - GetSize();
+
+   for (Int_t idxTrack = 0; idxTrack < esd->GetNumberOfTracks(); ++idxTrack) {
+     AliESDtrack *esdTrack = esd->GetTrack(idxTrack);
+     table[idxTrack] = -1;
+     if (esdTrack) {
+       table[idxTrack] = trackSize;
+       if( freeSpace<flatTrack->EstimateSize() ) return -1;
+       new (flatTrack) AliFlatESDTrack;       
+       flatTrack->SetFromESDTrack( esdTrack );
+       trackSize += flatTrack->GetSize();
+       freeSpace -= flatTrack->GetSize();
+       nTracks++;
+       flatTrack = flatTrack->GetNextTrackNonConst();
+     }
+   }
+   SetTracksEnd( nTracks, trackSize );
   }
 
-  // Fill V0s
-  
-  fV0Pointer = fSize;
-  fNV0s = 0;
+  // fill V0s
+
   if( fillV0s ){
+    size_t v0size = 0;
+    int nV0s = 0; 
+    AliFlatESDV0 *flatV0 = SetV0sStart();
     for( int i=0; i < esd->GetNumberOfV0s(); i++){
       AliESDv0 *esdV0 = esd->GetV0( i );
-      AliFlatESDV0 *v0 = GetNextV0Pointer();
-      if( !v0 ) continue;
-      v0->fNegTrackID = esdV0->GetNindex();
-      v0->fPosTrackID = esdV0->GetNindex();
-      StoreLastV0();      
+      if( !esdV0 || freeSpace < flatV0->GetSize() ) return -1;
+      new (flatV0) AliFlatESDV0;
+      flatV0->SetNegTrackID( esdV0->GetNindex());
+      flatV0->SetPosTrackID( esdV0->GetPindex());
+      nV0s++;
+      v0size += flatV0->GetSize();
+      freeSpace -= flatV0->GetSize(); 
+      flatV0 = flatV0->GetNextV0NonConst();
     }
+    SetV0sEnd( nV0s, v0size );
   }
-
+  
   return 0;
 }
 
-UInt_t AliFlatESDEvent::CountBits(Byte_t field, UInt_t mask) const {
-  // Count bits in field
-  UInt_t count = 0; 
-  UInt_t reg = 0x0; 
-  
-  reg |= field;   
-  reg &= mask;
+AliVParticle* AliFlatESDEvent::GetTrack(Int_t i) const
+{
+  return const_cast<AliFlatESDTrack*>(GetFlatTrack(i));
+}
   
-  for (count = 0; reg; count++)
-    reg &= reg - 1; 
-
-  return count;
+AliVEvent::EDataLayoutType AliFlatESDEvent::GetDataLayoutType() const 
+{
+  return AliVEvent::kFlat;
 }
+