#include "AliESDVertex.h"
// _______________________________________________________________________________________________________
-AliFlatESDEvent::AliFlatESDEvent() :
+AliFlatESDEvent::AliFlatESDEvent()
+ :
AliVVevent(),
fContentSize(0),
fMagneticField(0),
}
+AliFlatESDEvent::AliFlatESDEvent( AliVVConstructorReinitialisationFlag f )
+ :
+ AliVVevent( f ),
+ fContentSize(fContentSize),
+ fMagneticField(fMagneticField),
+ fPeriodNumber(fPeriodNumber),
+ fRunNumber(fRunNumber),
+ fOrbitNumber(fOrbitNumber),
+ fTimeStamp(fTimeStamp),
+ fEventSpecie(fEventSpecie),
+ fBunchCrossNumber(fBunchCrossNumber),
+ fPrimaryVertexMask(fPrimaryVertexMask),
+ fTriggerMask(fTriggerMask),
+ fTriggerMaskNext50(fTriggerMaskNext50),
+ fNTriggerClasses(fNTriggerClasses),
+ fNPrimaryVertices(fNPrimaryVertices),
+ fNTracks(fNTracks),
+ fNV0s(fNV0s),
+ fTriggerPointer(fTriggerPointer),
+ fPrimaryVertexTracksPointer(fPrimaryVertexTracksPointer),
+ fPrimaryVertexSPDPointer(fPrimaryVertexSPDPointer),
+ fTrackTablePointer(fTrackTablePointer),
+ fTracksPointer(fTracksPointer),
+ fV0Pointer(fV0Pointer)
+{
+ // 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();
+ }
+ }
+}
+
+
TString AliFlatESDEvent::GetFiredTriggerClasses() const
{
// Fired trigger classes
trackSize += flatTrack->GetSize();
freeSpace -= flatTrack->GetSize();
nTracks++;
- flatTrack = flatTrack->GetNextTrack();
+ flatTrack = flatTrack->GetNextTrackNonConst();
}
}
SetTracksEnd( nTracks, trackSize );
nV0s++;
v0size += flatV0->GetSize();
freeSpace -= flatV0->GetSize();
+ flatV0 = flatV0->GetNextV0NonConst();
}
SetV0sEnd( nV0s, v0size );
}
*/
#include "Rtypes.h"
+#include "AliVVMisc.h"
#include "AliVVevent.h"
#include "AliFlatESDTrack.h"
#include "AliFlatESDVertex.h"
AliFlatESDEvent();
~AliFlatESDEvent() {}
+ // constructor and method for reinitialisation of virtual table
+ AliFlatESDEvent( AliVVConstructorReinitialisationFlag );
+ void Reinitialize() { new (this) AliFlatESDEvent( AliVVReinitialize ); }
+
// --------------------------------------------------------------------------------
// Interface to AliVVEvent
// _______________________________________________________________________________________________________
AliFlatESDTrack::AliFlatESDTrack() :
// Default constructor
+ AliVVtrack(),
fTrackParamMask(0),
fNTPCClusters(0),
fNITSClusters(0),
{
}
+AliFlatESDTrack::AliFlatESDTrack( AliVVConstructorReinitialisationFlag f )
+ :
+ AliVVtrack( f ),
+ fTrackParamMask(fTrackParamMask ),
+ fNTPCClusters( fNTPCClusters ),
+ fNITSClusters( fNITSClusters ),
+ fContentSize( fContentSize )
+{
+ // Constructor for reinitialisation of vtable
+}
+
// _______________________________________________________________________________________________________
*/
#include "Rtypes.h"
-
+#include "AliVVMisc.h"
#include "AliVVtrack.h"
#include "AliFlatExternalTrackParam.h"
AliFlatESDTrack();
~AliFlatESDTrack() {}
- // --------------------------------------------------------------------------------
+ // constructor and method for reinitialisation of virtual table
+ AliFlatESDTrack( AliVVConstructorReinitialisationFlag );
+ void Reinitialize() { new (this) AliFlatESDTrack( AliVVReinitialize ); }
+
+ // --------------------------------------------------------------------------------
// -- Set methods
Int_t Set( const AliESDtrack* track );
// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
- AliFlatESDTrack *GetNextTrack() {return reinterpret_cast<AliFlatESDTrack*>(fContent+fContentSize);}
-
+ const AliFlatESDTrack *GetNextTrack() const { return reinterpret_cast<const AliFlatESDTrack*>(fContent+fContentSize); }
+ AliFlatESDTrack *GetNextTrackNonConst() { return reinterpret_cast<AliFlatESDTrack*>(fContent+fContentSize); }
+
// --------------------------------------------------------------------------------
// -- Size methods
*/
#include "Rtypes.h"
+#include "AliVVMisc.h"
#include <string>
class AliFlatESDTrigger{
AliFlatESDTrigger();
~AliFlatESDTrigger();
+ // constructor and method for reinitialisation of virtual table
+ AliFlatESDTrigger( AliVVConstructorReinitialisationFlag );
+ void Reinitialize() const {} // no virtual table - do nothing
+
// --------------------------------------------------------------------------------
// -- Fill / Set methods
// Destructor
}
+inline AliFlatESDTrigger::AliFlatESDTrigger( AliVVConstructorReinitialisationFlag ) :
+ fContentSize(fContentSize),
+ fTriggerIndex(fTriggerIndex)
+{
+ // do nothing
+}
+
inline Int_t AliFlatESDTrigger::SetTriggerClass( const char *TriggerClassName, Int_t TriggerIndex, ULong64_t MaxSize )
{
// Set trigger class, returns non-zero when the memory needed exeeeds MaxSize
*/
#include "Rtypes.h"
+#include "AliVVMisc.h"
class AliFlatESDV0
{
public:
+ // -- Constructor / Destructors
+
AliFlatESDV0(): fNegTrackID(-1), fPosTrackID(-1) {}
~AliFlatESDV0(){}
-
+
+ // constructor and method for reinitialisation of virtual table
+ AliFlatESDV0( AliVVConstructorReinitialisationFlag ): fNegTrackID(fNegTrackID), fPosTrackID(fPosTrackID) {}
+ void Reinitialize() const {} // no virtual table - do nothing
+
+ //--
+
static size_t GetSize(){ return sizeof(AliFlatESDV0); }
void SetNegTrackID( Int_t id ){ fNegTrackID = id; }
Int_t GetNegTrackID() const { return fNegTrackID; }
Int_t GetPosTrackID() const { return fPosTrackID; }
+ // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
+
+ const AliFlatESDV0 *GetNextV0() const { return reinterpret_cast<const AliFlatESDV0*>( this+GetSize() ); }
+ AliFlatESDV0 *GetNextV0NonConst() { return reinterpret_cast<AliFlatESDV0*>( this+GetSize() ); }
+
private:
AliFlatESDV0(const AliFlatESDV0&);
*/
#include "Rtypes.h"
+#include "AliVVMisc.h"
#include "AliESDVertex.h"
struct AliFlatESDVertex
{
+ // -- Constructor / Destructors
+
+ AliFlatESDVertex();
+ ~AliFlatESDVertex() {}
+
+ // constructor and method for reinitialisation of virtual table
+ AliFlatESDVertex( AliVVConstructorReinitialisationFlag );
+ void Reinitialize() const {} // no virtual table - do nothing
+
+ //--
Double32_t fPosition[3]; // vertex position
Double32_t fCov[6]; // vertex covariance matrix
Char_t fBCID; // BC ID assigned to vertex
*/
- AliFlatESDVertex() :fNContributors(0), fChi2(0){
- for( int i=0; i<3; i++) fPosition[i] = -9999;
- for( int i=0; i<6; i++) fCov[i] = -9999;
- }
void Set(const AliESDVertex &v );
};
+inline AliFlatESDVertex::AliFlatESDVertex() :
+fNContributors(0),
+fChi2(0)
+{
+ for( int i=0; i<3; i++) fPosition[i] = -9999;
+ for( int i=0; i<6; i++) fCov[i] = -9999;
+}
+
+inline AliFlatESDVertex::AliFlatESDVertex( AliVVConstructorReinitialisationFlag ):
+fNContributors(fNContributors),
+fChi2(fChi2)
+{
+ // do nothing
+ for( int i=0; i<3; i++) fPosition[i] = fPosition[i];
+ for( int i=0; i<6; i++) fCov[i] = fCov[i];
+}
+
inline void AliFlatESDVertex::Set(const AliESDVertex &v )
{
fPosition[0] = v.GetX();
//_______________________________________________________________________
AliESDtrack::AliESDtrack(const AliESDtrack& track):
AliExternalTrackParam(track),
+ AliVVtrack(),
fCp(0),
fIp(0),
fTPCInner(0),
*/
#include "Rtypes.h"
#include "TString.h"
+#include "AliVVMisc.h"
+
class TList;
//class AliVVvertex;
class AliVVtrack;
AliVVevent() {}
+ // constructor and method for reinitialisation of virtual table
+ AliVVevent( AliVVConstructorReinitialisationFlag ){}
+
protected:
virtual ~AliVVevent() {}
*/
#include "Rtypes.h"
-
+#include "AliVVMisc.h"
class AliExternalTrackParam;
class AliVVtrack {
AliVVtrack() {}
virtual ~AliVVtrack() {}
+ // constructor and method for reinitialisation of virtual table
+ AliVVtrack( AliVVConstructorReinitialisationFlag ) {}
+ void Reinitialize() { new (this) AliVVtrack( AliVVReinitialize ); }
+
+ // --------------------------------------------------------------------------------
+
// --------------------------------------------------------------------------------
// -- Getter methods
/*