#include "AliESDEvent.h"
#include "AliESDVertex.h"
-ClassImp(AliFlatESDEvent);
-
// _______________________________________________________________________________________________________
AliFlatESDEvent::AliFlatESDEvent() :
+ AliVVevent(),
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),
fNV0s(0),
fTriggerPointer(0),
- fPrimaryVertexPointer(0),
+ fPrimaryVertexTracksPointer(0),
+ fPrimaryVertexSPDPointer(0),
+ fTrackTablePointer(0),
fTracksPointer(0),
fV0Pointer(0)
{
fContent[0]=0;
}
-/*
-// _______________________________________________________________________________________________________
-AliFlatESDEvent::AliFlatESDEvent(AliESDEvent *esd) :
- fSize(0),
- fMagneticField(0),
- fPeriodNumber(0),
- fRunNumber(0),
- fOrbitNumber(0),
- fTimeStamp(0),
- fBunchCrossNumber(0),
- fPrimaryVertexMask(0),
- fTriggerMask(0),
- fNTriggerClasses(0),
- fNPrimaryVertices(0),
- fNTracks(0),
- fNV0s(0),
- fTriggerPointer(0),
- fPrimaryVertexPointer(0),
- fTracksPointer(0),
- fV0Pointer(0)
-{
- fContent[0]=0;
- Fill(esd);
-}
-// _______________________________________________________________________________________________________
-AliFlatESDEvent::AliFlatESDEvent(AliESDEvent *esd, Bool_t useESDFriends) :
- // Constructor
- fPrimaryVertexMask(0),
- fNTracks(0),
- fTracksPointer(0),
- fNV0s(0),
- fV0Pointer(0),
- fSize(0),
- fMagneticField(0),
- fPeriodNumber(0),
- fRunNumber(0),
- fOrbitNumber(0),
- fBunchCrossNumber(0),
- fTimeStamp(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()
-{
- // Destructor
-}
-void AliFlatESDEvent::Init()
+void AliFlatESDEvent::Reset()
{
// Init
fBunchCrossNumber = 0;
fPrimaryVertexMask = 0;
fTriggerMask = 0;
+ fTriggerMaskNext50 = 0;
fNTriggerClasses = 0;
fNPrimaryVertices = 0;
fNTracks = 0;
fNV0s = 0;
fTriggerPointer = 0;
- fPrimaryVertexPointer = 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);
+ size += esd->GetNumberOfTracks() * ( AliFlatESDTrack::EstimateSize() + sizeof(Long64_t) );
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;
- fContentSize = 0;
-
- Byte_t flag = 0x1;
- FillPrimaryVertex(vertexSPD, flag);
-
- flag = 0x2;
- FillPrimaryVertex(vertexTracks, flag);
-
- fTracksPointer = fContentSize;
- fV0Pointer = fContentSize;
-}
-
-void AliFlatESDEvent::FillPrimaryVertex(const AliESDVertex *v, Byte_t flag)
-{
-
- // Fill primary vertex parameters
-
- if (!v) return;
-
- AliFlatESDVertex *vtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
- vtx->Set( *v );
- fPrimaryVertexMask |= flag;
- fContentSize += sizeof(AliFlatESDVertex);
+ // fill primary vertex tracks
+ if( !vtx ) return 0;
+ if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1;
+ fPrimaryVertexMask |= 0x1;
+ fPrimaryVertexTracksPointer = fContentSize;
+ AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
+ flatVtx->Set( *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+fContentSize);
- //new (flatTrack) AliFlatESDTrack;
- flatTrack->Fill(esdTrack, friendTrack);
- fContentSize += flatTrack->GetSize();
- ++fNTracks;
+ // fill primary vertex SPD
+ if( !vtx ) return 0;
+ if( allocatedVtxMemory < sizeof(AliFlatESDVertex) ) return -1;
+ fPrimaryVertexMask |= 0x2;
+ fPrimaryVertexSPDPointer = fContentSize;
+ AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
+ flatVtx->Set( *vtx );
+ fContentSize += flatVtx->GetSize();
return 0;
}
-Int_t AliFlatESDEvent::AddTriggerClass( const char *TriggerClassName, Int_t TriggerIndex, ULong64_t MaxSize )
-{
- // add trigger class
- AliFlatESDTrigger *flatTrigger = reinterpret_cast<AliFlatESDTrigger*>(fContent+fContentSize);
- Int_t err = flatTrigger->SetTriggerClass( TriggerClassName, TriggerIndex, MaxSize );
- if( err==0 ){
- fContentSize+= flatTrigger->GetSize();
- fNTriggerClasses++;
- }
- return err;
-}
-
// _______________________________________________________________________________________________________
-Int_t AliFlatESDEvent::FillFromESD( const size_t allocatedMemorySize, 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
-#ifdef xxx
if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1;
- Init();
+ Reset();
if( !esd ) return 0;
// 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 = FillTriggersStart();
+ AliFlatESDTrigger *trigger = SetTriggersStart();
const AliESDRun* esdRun = esd->GetESDRun();
if( esdRun ){
for( int index=0; index<AliESDRun::kNTriggerClasses; index++){
nTriggers++;
freeSpace -= trigger->GetSize();
triggerSize += trigger->GetSize();
- trigger = trigger->GetNextTrigger();
+ trigger = trigger->GetNextTriggerNonConst();
}
}
}
- FillTriggersEnd( nTriggers, triggerSize );
+ SetTriggersEnd( nTriggers, triggerSize );
}
// fill primary vertices
-
- err = FillPrimaryVertices( freeSpace, esd->GetPrimaryVertexSPD(), esd->GetPrimaryVertexTracks() );
-
+ err = SetPrimaryVertexTracks( esd->GetPrimaryVertexTracks(), freeSpace );
if( err!=0 ) return err;
-
freeSpace = allocatedMemorySize - GetSize();
-
- ULong64_t GetTriggerMask() const {return fHeader?fHeader->GetTriggerMask():0;}
- TString GetFiredTriggerClasses() const {return (fESDRun&&fHeader)?fESDRun->GetFiredTriggerClasses(fHeader->GetTriggerMask()):"";}
- Bool_t IsTriggerClassFired(const char *name) const {return (fESDRun&&fHeader)?fESDRun->IsTriggerClassFired(fHeader->GetTriggerMask(),name):kFALSE;}
-
- const AliHLTCTPData* pCTPData=CTPData();
- if (pCTPData) {
- AliHLTUInt64_t mask=pCTPData->ActiveTriggers(trigData);
- for (int index=0; index<gkNCTPTriggerClasses; index++) {
- if ((mask&((AliHLTUInt64_t)0x1<<index)) == 0) continue;
- pESD->SetTriggerClass(pCTPData->Name(index), index);
- }
- pESD->SetTriggerMask(mask);
- }
-
-
- //allocatedMemorySize - GetSize();
-
- FillTriggersEnd(nTriggers, triggerSize );
-
- // -- Get ESD friends
- // -------------------------------------------------------
- Bool_t connectESDFriends = useESDFriends;
- AliESDfriend* esdFriend = NULL;
+ err = SetPrimaryVertexSPD( esd->GetPrimaryVertexSPD(), freeSpace );
+ if( err!=0 ) return err;
+ freeSpace = allocatedMemorySize - GetSize();
- if (connectESDFriends) {
- esdFriend = dynamic_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
- if (!esdFriend) {
- connectESDFriends = kFALSE;
- Printf("WARNING: friends not available, cluster information will not be included");
- }
- else
- Printf("INFO: friends are available, cluster information will be included");
+ // 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->Set( esdTrack );
+ trackSize += flatTrack->GetSize();
+ freeSpace -= flatTrack->GetSize();
+ nTracks++;
+ flatTrack = flatTrack->GetNextTrack();
+ }
+ }
+ SetTracksEnd( nTracks, trackSize );
}
- // -- Track loop, fill AliFlatESDTrack sub structure
- // -------------------------------------------------------
- for (Int_t idxTrack = 0; idxTrack < esd->GetNumberOfTracks(); ++idxTrack) {
- AliESDtrack *esdTrack = esd->GetTrack(idxTrack);
- AliESDfriendTrack *friendTrack = NULL;
+ // fill V0s
- if (esdTrack) {
- if (connectESDFriends){
- friendTrack = esdFriend->GetTrack(idxTrack);
- }
- FillNextTrack( esdTrack, friendTrack);
- }
- }
-
- // Fill V0s
-
- fV0Pointer = fContentSize;
- fNV0s = 0;
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();
}
+ SetV0sEnd( nV0s, v0size );
}
-#endif
+
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;
-
- for (count = 0; reg; count++)
- reg &= reg - 1;
-
- return count;
-}
#include "Rtypes.h"
#include "AliVVevent.h"
+#include "AliFlatESDTrack.h"
#include "AliFlatESDVertex.h"
-class AliFlatESDTrack;
class AliFlatESDV0;
class AliFlatESDTrigger;
class AliESDEvent;
class AliESDVertex;
-class AliESDtrack;
-class AliESDfriendTrack;
-class AliESDv0;
class AliFlatESDEvent :public AliVVevent {
public:
// --------------------------------------------------------------------------------
// -- Constructor / Destructors
AliFlatESDEvent();
- ~AliFlatESDEvent();
+ ~AliFlatESDEvent() {}
+ // --------------------------------------------------------------------------------
// Interface to AliVVEvent
- void Reset(){}
-
Double_t GetMagneticField() const { return fMagneticField; }
UInt_t GetPeriodNumber() const { return fPeriodNumber; }
Int_t GetRunNumber() const { return fRunNumber; }
UInt_t GetOrbitNumber() const { return fOrbitNumber; }
UShort_t GetBunchCrossNumber() const { return fBunchCrossNumber; }
- UInt_t GetTimeStamp() const { return fTimeStamp; }
- ULong64_t GetTriggerMask() const { return fTriggerMask; }
-
- TString GetFiredTriggerClasses() const { TString s; return s; } //!!
- UInt_t GetEventSpecie() const { return 0; } //!!
-
+ ULong64_t GetTriggerMask() const { return fTriggerMask; }
+ ULong64_t GetTriggerMaskNext50() const { return fTriggerMaskNext50; }
+ TString GetFiredTriggerClasses() const ;
+
Int_t GetNumberOfTracks() const { return fNTracks; }
- Int_t GetNumberOfV0s() const { return fNV0s; }
- Int_t GetNumberOfKinks() const { return 0; }
-
- AliVVtrack* GetVVTrack(Int_t /*i*/) const { return NULL; }
- //AliVVtrack* GetTrack(Int_t /*i*/) const { return NULL; }
- AliESDkink* GetKink(Int_t /*i*/) const { return NULL;}
+ Int_t GetNumberOfV0s() const { return fNV0s; }
+ void Reset();
void ConnectTracks(){} // initialisation, needed by the ESD event, part of VVevent interface
+ UInt_t GetTimeStamp() const { return fTimeStamp; }
+ UInt_t GetEventSpecie() const { return fEventSpecie; }
+ Int_t GetNumberOfKinks() const { return 0; }
+
+ const AliVVtrack* GetVVTrack(Int_t i) const { return GetFlatTrack(i); }
+ AliESDkink* GetKink(Int_t /*i*/) const { return NULL;}
+
// --------------------------------------------------------------------------------
- // -- Fill / Set methods
- void Init();
+ // Own methods
- Int_t FillFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t useESDFriends = kTRUE, const Bool_t fillV0s=kTRUE );
+ // -- Set methods
+
+ Int_t SetFromESD( size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t fillV0s=kTRUE );
void SetMagneticField( Double_t mf ){ fMagneticField = mf; }
void SetPeriodNumber( Int_t n ) { fPeriodNumber = n; }
void SetOrbitNumber( UInt_t n ) { fOrbitNumber = n; }
void SetBunchCrossNumber( UShort_t n ) { fBunchCrossNumber = n; }
void SetTimeStamp( UInt_t timeStamp ){ fTimeStamp = timeStamp; }
+ void SetEventSpecie(UInt_t eventSpecie){ fEventSpecie = eventSpecie; }
void SetTriggerMask(ULong64_t n) { fTriggerMask = n; }
+ void SetTriggerMaskNext50(ULong64_t n) { fTriggerMaskNext50 = n; }
- AliFlatESDTrigger *FillTriggersStart();
- void FillTriggersEnd( Int_t nTriggerClasses, size_t triggersSize );
-
- void FillPrimaryVertices( const AliESDVertex *vertexSPD, const AliESDVertex *vertexTracks );
+ Int_t SetPrimaryVertexTracks( const AliESDVertex *v, size_t allocatedVtxMemory );
+ Int_t SetPrimaryVertexSPD( const AliESDVertex *v, size_t allocatedVtxMemory );
- AliFlatESDTrack *FillTracksStart();
- void FillTracksEnd( Int_t nTracks, size_t tracksSize );
+ AliFlatESDTrigger *SetTriggersStart();
+ void SetTriggersEnd( Int_t nTriggerClasses, size_t triggersSize );
- AliFlatESDV0 *FillV0sStart();
- void FillV0sEnd( Int_t nV0s, size_t v0sSize );
+ Int_t SetTracksStart( AliFlatESDTrack* &t, Long64_t* &table, Int_t nTracks, size_t freeMem);
+ void SetTracksEnd( Int_t nTracks, size_t tracksSize );
+ AliFlatESDV0 *SetV0sStart();
+ void SetV0sEnd( Int_t nV0s, size_t v0sSize );
// --------------------------------------------------------------------------------
// -- Getter methods
-
const AliFlatESDVertex* GetPrimaryVertexSPD() const ;
const AliFlatESDVertex* GetPrimaryVertexTracks() const ;
const AliFlatESDTrack *GetTracks() const { return reinterpret_cast<const AliFlatESDTrack*>( fContent + fTracksPointer ); }
const AliFlatESDV0 *GetV0s() const { return reinterpret_cast<const AliFlatESDV0*>( fContent + fV0Pointer ); }
+ const AliFlatESDTrack *GetFlatTrack( Int_t i ) const ;
+
// --------------------------------------------------------------------------------
// -- Size methods
ULong64_t GetSize() const { return fContent + fContentSize - reinterpret_cast<const Byte_t*>(this); }
- static ULong64_t EstimateSize(AliESDEvent*esd, Bool_t useESDFriends = kTRUE, Bool_t fillV0s=kTRUE );
+ static ULong64_t EstimateSize(AliESDEvent*esd, Bool_t fillV0s=kTRUE );
private:
AliFlatESDEvent( const AliFlatESDEvent& );
AliFlatESDEvent& operator=( const AliFlatESDEvent& );
- Int_t AddTriggerClass( const char *TriggerClassName, Int_t TriggerIndex, ULong64_t MaxSize );
- void FillPrimaryVertex(const AliESDVertex *v, Byte_t flag);
- Int_t FillNextTrack( const AliESDtrack* esdTrack, AliESDfriendTrack* friendTrack);
- Int_t FillNextV0( const AliESDv0 *v0);
-
- const AliFlatESDVertex* GetFirstPrimaryVertex() const ;
- Byte_t *GetEndOfContent(){ return fContent + fContentSize; }
-
- UInt_t CountBits(Byte_t field, UInt_t mask) const;
-
// --------------------------------------------------------------------------------
// -- Fixed size member objects ( try to align in memory )
Int_t fRunNumber; // Run Number
UInt_t fOrbitNumber; // Orbit Number
UInt_t fTimeStamp; // Time stamp
+ UInt_t fEventSpecie; // Reconstruction event specie (1-default,2-lowM,4-highM,8-cosmic,16-cal)
UShort_t fBunchCrossNumber; // Bunch Crossing Number
Byte_t fPrimaryVertexMask; // Bit mask specfifying which primary vertices are present
- ULong64_t fTriggerMask; // Trigger mask
+ ULong64_t fTriggerMask; // Trigger mask, first 50 bits
+ ULong64_t fTriggerMaskNext50; // Trigger mask, next 50 bits
UInt_t fNTriggerClasses; // N trigger classes
UInt_t fNPrimaryVertices; // Number of primary vertices in array
// Pointers to specific data in fContent
size_t fTriggerPointer; // position of the first trigger description in fContent
- size_t fPrimaryVertexPointer; // position of the first primary vertex in fContent
+ size_t fPrimaryVertexTracksPointer; // position of primary vertex tracks in fContent
+ size_t fPrimaryVertexSPDPointer; // position of primary vertex SPD in fContent
+ size_t fTrackTablePointer; // position of the first track pointer in fContent
size_t fTracksPointer; // position of the first track in fContent
size_t fV0Pointer; // position of the first V0 in fContent
// -- Variable Size Object
Byte_t fContent[1]; // Variale size object, which contains all data
-
- ClassDef(AliFlatESDEvent,0)
};
// Inline implementations
-inline AliFlatESDTrack *AliFlatESDEvent::FillTracksStart()
+inline const AliFlatESDTrack *AliFlatESDEvent::GetFlatTrack( Int_t i ) const
+{
+ const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
+ if( i<0 || i>(int) fNTracks || table[i]<0 ) return NULL;
+ return reinterpret_cast<const AliFlatESDTrack*>( fContent + table[i] );
+}
+
+
+inline Int_t AliFlatESDEvent::SetTracksStart( AliFlatESDTrack* &t, Long64_t* &table, Int_t nTracks, size_t freeMem)
{
fNTracks = 0;
+ if( nTracks*sizeof(Long64_t) > freeMem ) return -1;
+ fTrackTablePointer = fContentSize;
+ fContentSize += nTracks*sizeof(Long64_t);
fTracksPointer = fContentSize;
- return reinterpret_cast< AliFlatESDTrack* >( fContent + fContentSize );
+ table = reinterpret_cast< Long64_t* >( fContent + fTrackTablePointer );
+ t = reinterpret_cast< AliFlatESDTrack* >( fContent + fTracksPointer );
+ return 0;
}
-inline void AliFlatESDEvent::FillTracksEnd( Int_t nTracks, size_t tracksSize )
+inline void AliFlatESDEvent::SetTracksEnd( Int_t nTracks, size_t tracksSize )
{
+ if( nTracks<0 ) return;
+ Long64_t *table = reinterpret_cast< Long64_t*> (fContent + fTrackTablePointer);
+ for( int i=0; i<nTracks; i++ ) table[i]+=fTracksPointer;
fNTracks = nTracks;
fContentSize += tracksSize;
}
-inline AliFlatESDV0 *AliFlatESDEvent::FillV0sStart()
+inline AliFlatESDV0 *AliFlatESDEvent::SetV0sStart()
{
fNV0s = 0;
fV0Pointer = fContentSize;
return reinterpret_cast< AliFlatESDV0* >( fContent + fContentSize );
}
-inline void AliFlatESDEvent::FillV0sEnd( Int_t nV0s, size_t v0sSize )
+inline void AliFlatESDEvent::SetV0sEnd( Int_t nV0s, size_t v0sSize )
{
fNV0s = nV0s;
fContentSize += v0sSize;
}
-inline AliFlatESDTrigger *AliFlatESDEvent::FillTriggersStart()
+inline AliFlatESDTrigger *AliFlatESDEvent::SetTriggersStart()
{
fNTriggerClasses = 0;
fTriggerPointer = fContentSize;
return reinterpret_cast< AliFlatESDTrigger* >( fContent + fContentSize );
}
-inline void AliFlatESDEvent::FillTriggersEnd( Int_t nTriggerClasses, size_t triggersSize )
+inline void AliFlatESDEvent::SetTriggersEnd( Int_t nTriggerClasses, size_t triggersSize )
{
fNTriggerClasses = nTriggerClasses;
fContentSize += triggersSize;
}
-inline const AliFlatESDVertex* AliFlatESDEvent::GetFirstPrimaryVertex() const
-{
- return reinterpret_cast<const AliFlatESDVertex*>(fContent + fPrimaryVertexPointer);
-}
-
inline const AliFlatESDVertex* AliFlatESDEvent::GetPrimaryVertexSPD() const
{
- return (fPrimaryVertexMask & 0x1) ? GetFirstPrimaryVertex() : NULL;
+ return (fPrimaryVertexMask & 0x1) ? reinterpret_cast<const AliFlatESDVertex*>(fContent + fPrimaryVertexSPDPointer) : NULL;
}
inline const AliFlatESDVertex* AliFlatESDEvent::GetPrimaryVertexTracks() const
{
- return (fPrimaryVertexMask & 0x2) ? (GetFirstPrimaryVertex() + (fPrimaryVertexMask & 0x1) ) : NULL;
+ return (fPrimaryVertexMask & 0x2) ? (reinterpret_cast<const AliFlatESDVertex*>(fContent + fPrimaryVertexTracksPointer) ) : NULL;
}
#endif
*
**************************************************************************/
-#include "TObject.h"
-
-#include "AliESDEvent.h"
+#include "Rtypes.h"
+#include "AliFlatESDTrack.h"
+#include "AliFlatExternalTrackParam.h"
#include "AliESDtrack.h"
-#include "AliESDfriendTrack.h"
#include "AliExternalTrackParam.h"
-#include "AliTPCseed.h"
-#include "AliTPCclusterMI.h"
-
-#include "AliFlatESDEvent.h"
-#include "AliFlatESDTrack.h"
#include "Riostream.h"
// _______________________________________________________________________________________________________
fTrackParamMask(0),
fNTPCClusters(0),
fNITSClusters(0),
-
- fSize(0),
- fContent() {
-
+ fContentSize(0)
+{
}
// _______________________________________________________________________________________________________
-AliFlatESDTrack::AliFlatESDTrack(const AliESDtrack* track, AliESDfriendTrack* friendTrack) :
- // Constructor
- fTrackParamMask(0),
- fNTPCClusters(0),
- fNITSClusters(0),
- fSize(0),
- fContent() {
-
- Fill(track, friendTrack);
-}
-// _______________________________________________________________________________________________________
-AliFlatESDTrack::~AliFlatESDTrack() {
- // Destructor
-
-}
// _______________________________________________________________________________________________________
-ULong64_t AliFlatESDTrack::EstimateSize(Bool_t useESDFriends, Int_t nTPCClusters ) {
- // Estimate upper limit of the object size
- // -> Added objects have to be added here as well
-
- ULong64_t size = sizeof(AliFlatESDTrack) + (6*sizeof(AliFlatExternalTrackParam));
-
- if (useESDFriends){
- size += nTPCClusters*sizeof(AliFlatTPCCluster);
- }
- return size;
-}
-
-
-// _______________________________________________________________________________________________________
-Int_t AliFlatESDTrack::Fill(const AliESDtrack* track, AliESDfriendTrack* friendTrack){
- // Fill external track parameters and friendTrack
-
+Int_t AliFlatESDTrack::Set(const AliESDtrack* track)
+{
+ // Fill external track parameters
fTrackParamMask = 0;
fNTPCClusters = 0;
fNITSClusters = 0;
- fSize = 0;
+ fContentSize = 0;
if( !track ) return 0;
- const AliExternalTrackParam *itsOut = 0;
- if (friendTrack) itsOut = friendTrack->GetITSOut();
-
- Int_t iResult = FillExternalTrackParam( track,
- track->GetInnerParam(),
- track->GetTPCInnerParam(),
- track->GetOuterParam(),
- track->GetConstrainedParam(),
- itsOut );
- fNITSClusters = track->GetNcls(0);
-
- // -- Fill clusters from friend track
- // -------------------------------------------------------
- if (friendTrack) {
- // Printf("DEBUG: Now filling clusters information for the current track");
-
- // -- Get seed object
- TObject* calibObject = NULL;
- AliTPCseed* seed = NULL;
- /*
- for (Int_t idx = 0; (calibObject = friendTrack->GetCalibObject(idx)); ++idx) {
- cout<<"Calibration object:"<<endl;
- std::cout<<calibObject->GetName()<<std::endl;
- calibObject->Print();
- cout<<"----------"<<endl;
- }
- friendTrack->Print();
- cout<<"ITS track: "<<(void*)friendTrack->GetITStrack()<<endl;
- cout<<"TRD track: "<<(void*)friendTrack->GetTRDtrack()<<endl;
- cout<<"ITS OUT track: "<<(void*)friendTrack->GetITSOut()<<endl;
- cout<<"ITS indices: ";
- if( friendTrack->GetITSindices() ){
- for( int i=0; i<friendTrack->GetMaxITScluster(); i++ ) cout<<friendTrack->GetITSindices()[i]<<" ";
- }
- cout<<endl;
- */
- for (Int_t idx = 0; (calibObject = friendTrack->GetCalibObject(idx)); ++idx) {
- if ((seed = dynamic_cast<AliTPCseed*>(calibObject))) break;
- }
-
- // -- Fill cluster
- if (seed) {
- for (Int_t idxRow = 0; idxRow < 160; idxRow++){
- AliTPCclusterMI* currentCl = seed->GetClusterPointer(idxRow);
- if (currentCl) {
- AliFlatTPCCluster &tmpCl = *GetNextTPCClusterPointer();
- tmpCl.SetX( currentCl->GetX() );
- tmpCl.SetY( currentCl->GetY() );
- tmpCl.SetZ( currentCl->GetZ() );
- tmpCl.SetPadRow( idxRow ); // TO BE CHECKED IF THIS NEEDED or currentCl->GetRow();
- tmpCl.SetSigmaY2( currentCl->GetSigmaY2() );
- tmpCl.SetSigmaZ2( currentCl->GetSigmaZ2() );
- tmpCl.SetCharge( currentCl->GetQ() );
- tmpCl.SetQMax( currentCl->GetMax() );
- StoreLastTPCCluster();
- }
- // else
- // Printf("DEBUG: No cluster for row %d", idxRow);
- }
- }
-
- /*
- AliTPCseed* seed = NULL;
- for (Int_t idx = 0; (calibObject = friendTrack->GetCalibObject(idx)); ++idx) {
- if ((seed = dynamic_cast<AliTPCseed*>(calibObject))) break;
- }
-
- // -- Fill cluster
- if (seed) {
- for (Int_t idxRow = 0; idxRow < 160; idxRow++){
- AliTPCclusterMI* currentCl = seed->GetTPCClusterPointer(idxRow);
- if (currentCl) {
- AliFlatTPCCluster &tmpCl = *GetNexTPCClusterPointer();
- tmpCl.fX = currentCl->GetX();
- tmpCl.fY = currentCl->GetY();
- tmpCl.fZ = currentCl->GetZ();
- tmpCl.fPadRow = idxRow; // TO BE CHECKED IF THIS NEEDED or currentCl->GetRow();
- tmpCl.fSigmaY2 = currentCl->GetSigmaY2();
- tmpCl.fSigmaZ2 = currentCl->GetSigmaZ2();
- tmpCl.fCharge = currentCl->GetQ();
- tmpCl.fQMax = currentCl->GetMax();
- StoreLastTPCCluster();
- }
- // else
- // Printf("DEBUG: No cluster for row %d", idxRow);
- }
- }
- */
-
- // else
- // Printf("DEBUG: No seed object");
-
- // Printf("DEBUG: Number of clusters for track = %d", fNTPCClusters);
-
- // -- Sorting clusters according to user defined function (increasing pad row numbering)
- std::sort(GetTPCClusters(), GetTPCClusters()+fNTPCClusters, AliFlatTPCCluster::SortClusters);
- }
+ Int_t iResult = SetExternalTrackParam( track,
+ track->GetInnerParam(),
+ track->GetTPCInnerParam(),
+ track->GetOuterParam(),
+ track->GetConstrainedParam(), NULL );
+ fNITSClusters = track->GetTPCNcls();
return iResult;
}
// _______________________________________________________________________________________________________
-Int_t AliFlatESDTrack::FillExternalTrackParam(
- const AliExternalTrackParam* refittedParam,
- const AliExternalTrackParam* innerParam,
- const AliExternalTrackParam* innerTPC,
- const AliExternalTrackParam* outerParam,
- const AliExternalTrackParam* constrainedParam,
- const AliExternalTrackParam* outerITS
- ){
+Int_t AliFlatESDTrack::SetExternalTrackParam(
+ const AliExternalTrackParam* refittedParam,
+ const AliExternalTrackParam* innerParam,
+ const AliExternalTrackParam* innerTPC,
+ const AliExternalTrackParam* outerParam,
+ const AliExternalTrackParam* constrainedParam,
+ const AliExternalTrackParam* outerITS
+ ){
// Fill external track parameters
fTrackParamMask = 0;
fNTPCClusters = 0;
- fSize = 0;
+ fContentSize = 0;
Int_t iResult = 0;
if (!param)
return -1;
- Printf(" DEBUG: CONTENT %d >> %p + 0x%07llx = %p", flag, fContent, fSize, fContent + fSize);
+ Printf(" DEBUG: CONTENT %d >> %p + 0x%07llx = %p", flag, fContent, fContentSize, fContent + fContentSize);
- AliFlatExternalTrackParam * current = reinterpret_cast<AliFlatExternalTrackParam*> (fContent + fSize);
+ AliFlatExternalTrackParam * current = reinterpret_cast<AliFlatExternalTrackParam*> (fContent + fContentSize);
current->SetAlpha(param->GetAlpha());
current->SetX(param->GetX());
current->SetY(param->GetY());
current->fC[idx] = cov[idx];
fTrackParamMask |= flag;
- fSize += sizeof(AliFlatExternalTrackParam);
+ fContentSize += sizeof(AliFlatExternalTrackParam);
return 0;
}
// _______________________________________________________________________________________________________
-UInt_t AliFlatESDTrack::CountBits(Byte_t field, UInt_t mask) {
- // Count bits in field
- UInt_t count = 0;
- UInt_t reg = 0x0;
-
- reg |= field;
- reg &= mask;
-
- for (count = 0; reg; count++)
- reg &= reg - 1;
-
- return count;
-}
#include "Rtypes.h"
-#include "AliFlatTPCCluster.h"
+#include "AliVVtrack.h"
#include "AliFlatExternalTrackParam.h"
class AliESDtrack;
-class AliESDfriendTrack;
class AliExternalTrackParam;
-class AliFlatESDTrack {
+class AliFlatESDTrack :public AliVVtrack {
public:
// --------------------------------------------------------------------------------
// -- Constructor / Destructors
- AliFlatESDTrack();
- AliFlatESDTrack(const AliESDtrack* track, AliESDfriendTrack* friendTrack);
- ~AliFlatESDTrack();
+
+ AliFlatESDTrack();
+ ~AliFlatESDTrack() {}
// --------------------------------------------------------------------------------
- // -- Fill / Set methods
- Int_t FillExternalTrackParam(
- const AliExternalTrackParam* refittedParam,
- const AliExternalTrackParam* innerParam,
- const AliExternalTrackParam* innerTPC,
- const AliExternalTrackParam* outerParam,
- const AliExternalTrackParam* constrainedParam,
- const AliExternalTrackParam* outerITSParam
- );
-
- AliFlatTPCCluster *GetNextTPCClusterPointer(){ return &GetTPCCluster(fNTPCClusters); }
-
- void StoreLastTPCCluster(){
- ++fNTPCClusters;
- fSize += sizeof(AliFlatTPCCluster);
- }
+ // -- Set methods
+
+ Int_t Set( const AliESDtrack* track );
+
+ Int_t SetExternalTrackParam(
+ const AliExternalTrackParam* refittedParam,
+ const AliExternalTrackParam* innerParam,
+ const AliExternalTrackParam* innerTPC,
+ const AliExternalTrackParam* outerParam,
+ const AliExternalTrackParam* constrainedParam,
+ const AliExternalTrackParam* outerITSParam
+ );
void SetNumberOfITSClusters( Int_t nCl ) { fNITSClusters = nCl; }
- Int_t Fill( const AliESDtrack* track, AliESDfriendTrack* friendTrack);
// --------------------------------------------------------------------------------
// -- Getter methods
return fNTPCClusters;
}
- AliFlatTPCCluster *GetTPCClusters() {
- return reinterpret_cast< AliFlatTPCCluster*>(fContent + sizeof(AliFlatExternalTrackParam)*CountBits(fTrackParamMask));
- }
-
- AliFlatTPCCluster &GetTPCCluster(Int_t ind) {
- return GetTPCClusters()[ind];
- }
-
Int_t GetNumberOfITSClusters() {
return fNITSClusters;
}
-
-
+
// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
- AliFlatESDTrack *GetNextTrack() {return reinterpret_cast<AliFlatESDTrack*>(fContent+fSize);}
+ AliFlatESDTrack *GetNextTrack() {return reinterpret_cast<AliFlatESDTrack*>(fContent+fContentSize);}
// --------------------------------------------------------------------------------
// -- Size methods
- static ULong64_t EstimateSize(Bool_t useESDFriends = kTRUE, Int_t nTPCClusters = 160 );
- ULong64_t GetSize() {return fContent - reinterpret_cast<Byte_t*>(this) + fSize;}
+
+ static size_t EstimateSize(){
+ return sizeof(AliFlatESDTrack) + 6*sizeof(AliFlatExternalTrackParam);
+ }
+
+ size_t GetSize() { return fContent - reinterpret_cast<Byte_t*>(this) + fContentSize; }
private:
AliFlatESDTrack(const AliFlatESDTrack&);
Int_t FillExternalTrackParam(const AliExternalTrackParam* param, UShort_t flag);
- UInt_t CountBits(Byte_t field, UInt_t mask = 0xFFFFFFFF);
+ static UInt_t CountBits(Byte_t field, UInt_t mask = 0xFFFFFFFF);
// --------------------------------------------------------------------------------
// -- Fixed size member objects
Int_t fNITSClusters; // Number of ITS clusters in track
// Bool_t fMCLabels;
- ULong64_t fSize; // Size of this object
+ ULong64_t fContentSize; // Size of this object
// --------------------------------------------------------------------------------
// -- Variable Size Object
Byte_t fContent[1]; // Variale size object, which contains all data
};
+
+inline UInt_t AliFlatESDTrack::CountBits(Byte_t field, UInt_t mask) {
+ // Count bits in field
+ UInt_t count = 0, reg = field & mask;
+ for (; reg; count++) reg &= reg - 1;
+ return count;
+}
+
#endif
// -- Getter methods
Int_t GetTriggerIndex() const { return fTriggerIndex; }
-
+
const Char_t *GetTriggerClassName() const { return reinterpret_cast<const Char_t*>( fContent ); }
// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
- AliFlatESDTrigger *GetNextTrigger() { return reinterpret_cast<AliFlatESDTrigger*>(fContent+fContentSize); }
-
+ const AliFlatESDTrigger *GetNextTrigger() const { return reinterpret_cast<const AliFlatESDTrigger*>(fContent+fContentSize); }
+
+ AliFlatESDTrigger *GetNextTriggerNonConst() { return reinterpret_cast<AliFlatESDTrigger*>(fContent+fContentSize); }
+
// --------------------------------------------------------------------------------
// -- Size methods
Double_t GetWDist(const AliESDVertex* v) const;
*/
-
+ static size_t GetSize() { return sizeof(AliFlatESDVertex); }
};
UInt_t GetDAQAttributes() const {return fDAQAttributes;}
// interface to AliVVevent
- AliESDtrack *GetVVTrack(Int_t i) const { return GetTrack(i); }
+ const AliVVtrack *GetVVTrack(Int_t i) const { return GetTrack(i); }
protected:
AliESDEvent(const AliESDEvent&);
// disable some methods from AliVEvent interface
UInt_t GetTimeStamp() const { return 0; }
- UInt_t GetEventSpecie() const { return 0; }
+ UInt_t GetEventSpecie() const { return 0; }
+ ULong64_t GetTriggerMaskNext50() const { return 0; }
+
Int_t GetNumberOfKinks() const { return 0; }
- AliVVtrack* GetVVTrack(Int_t /*i*/) const { return NULL; }
+ const AliVVtrack* GetVVTrack(Int_t /*i*/) const { return NULL; }
AliESDkink* GetKink(Int_t /*i*/) const { return NULL; }
public:
protected:
- ~AliVVevent() {}
+ virtual ~AliVVevent() {}
public:
// --------------------------------------------------------------------------------
virtual void Reset() = 0;
virtual void ConnectTracks() = 0;
-
+
// --------------------------------------------------------------------------------
// -- Methods, specific for AliVVevent (are disabled in AliVEvent interface)
// --------------------------------------------------------------------------------
-
+
virtual UInt_t GetTimeStamp() const = 0;
virtual UInt_t GetEventSpecie() const = 0;
-
+ virtual ULong64_t GetTriggerMaskNext50() const = 0;
+
virtual Int_t GetNumberOfKinks() const = 0;
/*
virtual const AliVVvertex* GetPrimaryVertexTPC() const {return NULL;}
*/
- virtual AliVVtrack* GetVVTrack(Int_t /*i*/) const = 0;
+ virtual const AliVVtrack* GetVVTrack(Int_t /*i*/) const = 0;
virtual AliESDkink* GetKink(Int_t /*i*/) const = 0;
//virtual AliVVtrack* GetV0(Int_t /*i*/) const = 0;
// Track loop to fill a pT spectrum
for (Int_t iTracks = 0; iTracks < nESDtracks; iTracks++) {
Printf("Checking track %d: Note that with Flat, the GetTrack is not yet implemented!!!", iTracks);
- AliVVtrack* track = fESD->GetVVTrack(iTracks);
+ const AliVVtrack* track = fESD->GetVVTrack(iTracks);
if (!track) {
Printf("ERROR: Could not receive track %d", iTracks);
continue;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff