#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(AliESDEvent *esd) :
- // Constructor
- fPrimaryVertexMask(0),
- fNTracks(0),
- fTracksPointer(0),
- fNV0s(0),
- fV0Pointer(0),
- fSize(0),
- fContent()
-{
- Fill(esd);
+#pragma GCC diagnostic ignored "-Weffc++"
+AliFlatESDEvent::AliFlatESDEvent( AliVConstructorReinitialisationFlag /*f*/ )
+ :
+ fFriendEvent(NULL)
+{
+ // Constructor for reinitialisation of vtable
+
+ // Reinitialise trigger information
+ {
+ AliFlatESDTrigger * trigger = reinterpret_cast< AliFlatESDTrigger*>( fContent + fTriggerPointer );
+ for( UInt_t i=0; i<fNTriggerClasses; i++ ){
+ trigger->Reinitialize();
+ trigger = trigger->GetNextTriggerNonConst();
+ }
+ }
+
+ // 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
+ {
+ AliFlatESDTrack *track = reinterpret_cast<AliFlatESDTrack*>( fContent + fTracksPointer );
+ for( UInt_t i=0; i<fNTracks; i++ ){
+ track->Reinitialize();
+ track = track->GetNextTrackNonConst();
+ }
+ }
+
+ // 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 )
-{
- // 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)
+Int_t AliFlatESDEvent::SetPrimaryVertexTracks( const AliESDVertex *vtx, size_t allocatedVtxMemory )
{
-
- // Fill primary vertex parameters
-
- if (!v) return;
-
- AliFlatESDVertex *vtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fSize);
- 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) {
- // 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;
}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff