AliHLTV0FinderComponent.h
AliFlatESDEvent.h
AliFlatESDVertex.h
+ AliFlatESDTrigger.h
AliFlatESDTrack.h
AliFlatESDV0.h
AliFlatESDFriend.h
#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
+ fContentSize(0),
+ fMagneticField(0),
+ fPeriodNumber(0),
+ fRunNumber(0),
+ fOrbitNumber(0),
+ fTimeStamp(0),
+ fBunchCrossNumber(0),
fPrimaryVertexMask(0),
+ fTriggerMask(0),
+ fNTriggerClasses(0),
+ fNPrimaryVertices(0),
fNTracks(0),
- fTracksPointer(0),
fNV0s(0),
- fV0Pointer(0),
- fSize(0),
- fContent()
+ fTriggerPointer(0),
+ fPrimaryVertexPointer(0),
+ fTracksPointer(0),
+ fV0Pointer(0)
{
+ // Default constructor
+ fContent[0]=0;
}
-// _______________________________________________________________________________________________________
-void AliFlatESDEvent::Reinitialize()
-{
-//
-// Initializing function
-//
-// to be called after event is received via reinterpret_cast from memory
-
-
- new (this) AliFlatESDEvent(AliFlatESDReinitialize);
- AliFlatESDVertex* vertexSPD = const_cast<AliFlatESDVertex*>(GetPrimaryVertexSPD());
- if (vertexSPD ) {vertexSPD->Reinitialize(); }
- AliFlatESDVertex* vertexTracks = const_cast<AliFlatESDVertex*>(GetPrimaryVertexTracks());
- if (vertexTracks ) { vertexTracks->Reinitialize(); }
- AliFlatESDTrack* track = GetTracks();
-
- for (Int_t i=0; i<GetNumberOfTracks(); i++)
- {
- track->Reinitialize();
- track= track->GetNextTrack();
- }
- AliFlatESDV0* v0 = GetV0stmp();
- for (Int_t i=0; i<GetNumberOfV0s(); i++)
- {
- v0->Reinitialize();
- v0++;
- }
- }
-
/*
-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
+ fSize(0),
+ fMagneticField(0),
+ fPeriodNumber(0),
+ fRunNumber(0),
+ fOrbitNumber(0),
+ fTimeStamp(0),
+ fBunchCrossNumber(0),
fPrimaryVertexMask(0),
+ fTriggerMask(0),
+ fNTriggerClasses(0),
+ fNPrimaryVertices(0),
fNTracks(0),
- fTracksPointer(0),
fNV0s(0),
- fV0Pointer(0),
- fSize(0),
- fContent()
+ fTriggerPointer(0),
+ fPrimaryVertexPointer(0),
+ fTracksPointer(0),
+ fV0Pointer(0)
{
+ fContent[0]=0;
Fill(esd);
}
fNV0s(0),
fV0Pointer(0),
fSize(0),
+ fMagneticField(0),
+ fPeriodNumber(0),
+ fRunNumber(0),
+ fOrbitNumber(0),
+ fBunchCrossNumber(0),
+ fTimeStamp(0),
fContent()
{
Fill(esd, useESDFriends);
}
+*/
// _______________________________________________________________________________________________________
AliFlatESDEvent::~AliFlatESDEvent()
// Destructor
}
+void AliFlatESDEvent::Init()
+{
+ // Init
+
+ fContentSize = 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;
+}
+
// _______________________________________________________________________________________________________
ULong64_t AliFlatESDEvent::EstimateSize(AliESDEvent *esd, Bool_t useESDFriends, Bool_t fillV0s)
{
// fill primary vertices
fPrimaryVertexMask = 0;
- fSize = 0;
+ fContentSize = 0;
Byte_t flag = 0x1;
FillPrimaryVertex(vertexSPD, flag);
flag = 0x2;
FillPrimaryVertex(vertexTracks, flag);
- fTracksPointer = fSize;
- fV0Pointer = fSize;
+ fTracksPointer = fContentSize;
+ fV0Pointer = fContentSize;
}
void AliFlatESDEvent::FillPrimaryVertex(const AliESDVertex *v, Byte_t flag)
if (!v) return;
- AliFlatESDVertex *vtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fSize);
- new(vtx) AliFlatESDVertex;
+ AliFlatESDVertex *vtx = reinterpret_cast<AliFlatESDVertex*> (fContent + fContentSize);
vtx->Set( *v );
fPrimaryVertexMask |= flag;
- fSize += sizeof(AliFlatESDVertex);
+ fContentSize += sizeof(AliFlatESDVertex);
}
{
// fill next track
- AliFlatESDTrack * flatTrack = reinterpret_cast<AliFlatESDTrack*>(fContent+fSize);
- new(flatTrack) AliFlatESDTrack;
+ AliFlatESDTrack *flatTrack = reinterpret_cast<AliFlatESDTrack*>(fContent+fContentSize);
+ //new (flatTrack) AliFlatESDTrack;
flatTrack->Fill(esdTrack, friendTrack);
- fSize += flatTrack->GetSize();
+ fContentSize += flatTrack->GetSize();
++fNTracks;
return 0;
}
-void AliFlatESDEvent::Reset()
+Int_t AliFlatESDEvent::AddTriggerClass( const char *TriggerClassName, Int_t TriggerIndex, ULong64_t MaxSize )
{
- fSize = 0;
- fNTracks=0;
- fNV0s = 0;
- fPrimaryVertexMask = 0;
- fTracksPointer = 0;
- fV0Pointer = 0;
+ // 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::Fill(const AliESDEvent *esd, const Bool_t useESDFriends, const Bool_t fillV0s )
+Int_t AliFlatESDEvent::FillFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t useESDFriends, const Bool_t fillV0s)
{
// Fill flat ESD event from normal ALiESDEvent
// - Fill tracks + friends (if requested)
// -> Added objects have to be added here as well
+
+#ifdef xxx
+ if( allocatedMemorySize < sizeof(AliFlatESDEvent) ) return -1;
- Reset();
+ Init();
- FillPrimaryVertices( esd->GetPrimaryVertexSPD(), esd->GetPrimaryVertexTracks() );
+ if( !esd ) return 0;
+
+ Int_t err = 0;
+ size_t freeSpace = allocatedMemorySize - GetSize();
+
+ // fill run info
+ {
+ SetTriggerMask( esd->GetTriggerMask() );
+ }
+
+ // Fill trigger information
+ {
+ size_t triggerSize = 0;
+ int nTriggers = 0;
+ AliFlatESDTrigger *trigger = FillTriggersStart();
+ 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->GetNextTrigger();
+ }
+ }
+ }
+ FillTriggersEnd( nTriggers, triggerSize );
+ }
+
+ // fill primary vertices
+
+
+ err = FillPrimaryVertices( freeSpace, esd->GetPrimaryVertexSPD(), esd->GetPrimaryVertexTracks() );
+
+ 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;
// Fill V0s
- fV0Pointer = fSize;
+ fV0Pointer = fContentSize;
fNV0s = 0;
if( fillV0s ){
for( int i=0; i < esd->GetNumberOfV0s(); i++){
StoreLastV0();
}
}
-
+#endif
return 0;
}
*/
#include "Rtypes.h"
-#include "AliFlatESDTrack.h"
-#include "AliFlatESDV0.h"
#include "AliVVevent.h"
#include "AliFlatESDVertex.h"
-#include "AliFlatESDMisc.h"
+
+class AliFlatESDTrack;
+class AliFlatESDV0;
+class AliFlatESDTrigger;
class AliESDEvent;
class AliESDVertex;
-class AliESDV0;
-class TString;
+class AliESDtrack;
+class AliESDfriendTrack;
+class AliESDv0;
-class AliFlatESDEvent: public AliVVevent {
-//class AliFlatESDEvent {
+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; } //!!
+
+ Int_t GetNumberOfTracks() const { return fNTracks; }
+ Int_t GetNumberOfV0s() const { return fNV0s; }
+ Int_t GetNumberOfKinks() const { return 0; }
+ AliVVtrack* GetTrack(Int_t /*i*/) const { return NULL; }
+ AliESDkink* GetKink(Int_t /*i*/) const { return NULL;}
- AliFlatESDEvent(AliESDEvent *esd);
- AliFlatESDEvent(AliESDEvent *esd, Bool_t useESDFriends);
- virtual ~AliFlatESDEvent();
+ void ConnectTracks(){} // initialisation, needed by the ESD event, part of VVevent interface
// --------------------------------------------------------------------------------
// -- Fill / Set methods
- void Reset();
+ void Init();
- Int_t Fill( const AliESDEvent *esd, const Bool_t useESDFriends = kTRUE, const Bool_t fillV0s=kTRUE );
+ Int_t FillFromESD( const size_t allocatedMemorySize, const AliESDEvent *esd, const Bool_t useESDFriends = kTRUE, const Bool_t fillV0s=kTRUE );
- void FillPrimaryVertices( const AliESDVertex *vertexSPD,
- const AliESDVertex *vertexTracks );
+ void SetMagneticField( Double_t mf ){ fMagneticField = mf; }
+ void SetPeriodNumber( Int_t n ) { fPeriodNumber = n; }
+ void SetRunNumber( Int_t n ) { fRunNumber = n; }
+ void SetOrbitNumber( UInt_t n ) { fOrbitNumber = n; }
+ void SetBunchCrossNumber( UShort_t n ) { fBunchCrossNumber = n; }
+ void SetTimeStamp( UInt_t timeStamp ){ fTimeStamp = timeStamp; }
+ void SetTriggerMask(ULong64_t n) { fTriggerMask = n; }
+
+ AliFlatESDTrigger *FillTriggersStart();
+ void FillTriggersEnd( Int_t nTriggerClasses, size_t triggersSize );
-
- AliFlatESDTrack *GetNextTrackPointer(){
- return reinterpret_cast<AliFlatESDTrack*> (fContent + fSize);
- }
-
- void StoreLastTrack(){
- fNTracks++;
- fSize+= GetNextTrackPointer()->GetSize();
- fV0Pointer = fSize;
- }
-
- AliFlatESDV0 *GetNextV0Pointer(){
- return reinterpret_cast<AliFlatESDV0*> (fContent + fSize);
-}
+ void FillPrimaryVertices( const AliESDVertex *vertexSPD, const AliESDVertex *vertexTracks );
+
+ AliFlatESDTrack *FillTracksStart();
+ void FillTracksEnd( Int_t nTracks, size_t tracksSize );
+
+ AliFlatESDV0 *FillV0sStart();
+ void FillV0sEnd( Int_t nV0s, size_t v0sSize );
- void StoreLastV0(){
- fNV0s++;
- fSize+= sizeof(AliFlatESDV0);
- }
// --------------------------------------------------------------------------------
// -- Getter methods
- const AliFlatESDVertex* GetPrimaryVertexSPD() const {
- if (fPrimaryVertexMask & 0x1){
- return reinterpret_cast< AliFlatESDVertex*> (const_cast<Byte_t*>(fContent));
- }
- else return NULL;
- }
- const AliFlatESDVertex* GetPrimaryVertexTracks() const {
- if (fPrimaryVertexMask & 0x2){
- return reinterpret_cast< AliFlatESDVertex*> (const_cast<Byte_t*>(fContent)) + CountBits(fPrimaryVertexMask, 0x1);
- }
- else return NULL;
- }
+ const AliFlatESDVertex* GetPrimaryVertexSPD() const ;
+ const AliFlatESDVertex* GetPrimaryVertexTracks() const ;
- Int_t GetNumberOfV0s() const {return fNV0s;}
-
- Int_t GetNumberOfTracks() const {return fNTracks;}
-
- AliFlatESDV0* GetV0stmp() {
- return reinterpret_cast<AliFlatESDV0*> (fContent + fV0Pointer);
- }
-
- AliFlatESDTrack *GetTracks() {
- return reinterpret_cast<AliFlatESDTrack*> (fContent + fTracksPointer);
- }
-
- //const AliVVvertex* GetPrimaryVertex() const {return NULL;}
- //const AliVVvertex* GetPrimaryVertexTPC() const {return NULL;}
- AliFlatESDTrack* GetTrack(Int_t /*i*/) const {return NULL;}
- AliESDkink* GetKink(Int_t /*i*/) const { return NULL; }
- //AliFlatESDV0* GetV0(Int_t /*i*/) const {return NULL;}
- Int_t GetNumberOfKinks() const { return 0; }
- Int_t GetEventNumberInFile() const { return -1; }
- const AliMultiplicity* GetMultiplicity() const { return NULL; } //by default SPDmult
- Int_t GetRunNumber() const {return -1;}
- TString GetFiredTriggerClasses() const {TString string; return string;}
- TObject* FindListObject(const char* /*name*/) const {return NULL;}
- AliVVfriendEvent* FindFriend() const { return NULL; }
- ULong64_t GetTriggerMask() const {return 0;}
- Double_t GetMagneticField() const {return 0;}
- UInt_t GetTimeStamp() const { return 0;}
- UInt_t GetEventSpecie() const { return 0;}
- void ConnectTracks(){}
- void ReadFromTree(TTree* /*tree*/, Option_t* /*opt*/) {};
- TList* GetList() const;
+ Int_t GetNumberOfTriggerClasses() const { return fNTriggerClasses; }
+
+ const AliFlatESDTrigger *GetTriggerClasses() const { return reinterpret_cast<const AliFlatESDTrigger*>( fContent + fTriggerPointer ); }
+ const AliFlatESDTrack *GetTracks() const { return reinterpret_cast<const AliFlatESDTrack*>( fContent + fTracksPointer ); }
+ const AliFlatESDV0 *GetV0s() const { return reinterpret_cast<const AliFlatESDV0*>( fContent + fV0Pointer ); }
// --------------------------------------------------------------------------------
// -- Size methods
- static ULong64_t EstimateSize(AliESDEvent*esd, Bool_t useESDFriends = kTRUE, Bool_t fillV0s=kTRUE);
- ULong64_t GetSize() {return fContent - reinterpret_cast<Byte_t*>(this) + fSize;}
+ ULong64_t GetSize() const { return fContent + fContentSize - reinterpret_cast<const Byte_t*>(this); }
-//
-// Initializing function
-//
-// to be called after event is received via reinterpret_cast from memory
-
-void Reinitialize();
+ static ULong64_t EstimateSize(AliESDEvent*esd, Bool_t useESDFriends = kTRUE, Bool_t fillV0s=kTRUE );
private:
- AliFlatESDEvent(const AliFlatESDEvent&);
- AliFlatESDEvent& operator=(const AliFlatESDEvent&);
-
-// special constructor, to be called by placement new,
-// when accessing information after reinterpret_cast
-// so that vtable is generated, but values are not overwritten
- AliFlatESDEvent(AliFlatESDSpecialConstructorFlag){}
- void FillPrimaryVertex(const AliESDVertex *v, Byte_t flag);
+ 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);
- UInt_t CountBits(Byte_t field, UInt_t mask) const;
+ Int_t FillNextV0( const AliESDv0 *v0);
- // --------------------------------------------------------------------------------
- // -- Fixed size member objects
- // -> Try to align in memory
+ const AliFlatESDVertex* GetFirstPrimaryVertex() const ;
+ Byte_t *GetEndOfContent(){ return fContent + fContentSize; }
- Byte_t fPrimaryVertexMask; // Bit mask specfifying which primary vertices are present
- Int_t fNTracks; // Number of tracks in vector
- ULong64_t fTracksPointer; // position of the first track in fContent
- Int_t fNV0s; // Number of v0's
- ULong64_t fV0Pointer; // position of the first V0 in fContent
+ UInt_t CountBits(Byte_t field, UInt_t mask) const;
+ // --------------------------------------------------------------------------------
- ULong64_t fSize; // Size of this object
+ // -- Fixed size member objects ( try to align in memory )
+
+ size_t fContentSize; // Size of fContent
+ Double32_t fMagneticField; // Solenoid Magnetic Field in kG : for compatibility with AliMagF
+ UInt_t fPeriodNumber; // PeriodNumber
+ Int_t fRunNumber; // Run Number
+ UInt_t fOrbitNumber; // Orbit Number
+ UInt_t fTimeStamp; // Time stamp
+ UShort_t fBunchCrossNumber; // Bunch Crossing Number
+ Byte_t fPrimaryVertexMask; // Bit mask specfifying which primary vertices are present
+ ULong64_t fTriggerMask; // Trigger mask
+
+ UInt_t fNTriggerClasses; // N trigger classes
+ UInt_t fNPrimaryVertices; // Number of primary vertices in array
+ UInt_t fNTracks; // Number of tracks in array
+ UInt_t fNV0s; // Number of v0's
+ // 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 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
};
+
+// Inline implementations
+
+inline AliFlatESDTrack *AliFlatESDEvent::FillTracksStart()
+{
+ fNTracks = 0;
+ fTracksPointer = fContentSize;
+ return reinterpret_cast< AliFlatESDTrack* >( fContent + fContentSize );
+}
+
+inline void AliFlatESDEvent::FillTracksEnd( Int_t nTracks, size_t tracksSize )
+{
+ fNTracks = nTracks;
+ fContentSize += tracksSize;
+}
+
+inline AliFlatESDV0 *AliFlatESDEvent::FillV0sStart()
+{
+ fNV0s = 0;
+ fV0Pointer = fContentSize;
+ return reinterpret_cast< AliFlatESDV0* >( fContent + fContentSize );
+}
+
+inline void AliFlatESDEvent::FillV0sEnd( Int_t nV0s, size_t v0sSize )
+{
+ fNV0s = nV0s;
+ fContentSize += v0sSize;
+}
+
+inline AliFlatESDTrigger *AliFlatESDEvent::FillTriggersStart()
+{
+ fNTriggerClasses = 0;
+ fTriggerPointer = fContentSize;
+ return reinterpret_cast< AliFlatESDTrigger* >( fContent + fContentSize );
+}
+
+inline void AliFlatESDEvent::FillTriggersEnd( 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;
+}
+
+inline const AliFlatESDVertex* AliFlatESDEvent::GetPrimaryVertexTracks() const
+{
+ return (fPrimaryVertexMask & 0x2) ? (GetFirstPrimaryVertex() + (fPrimaryVertexMask & 0x1) ) : NULL;
+}
+
#endif
AliFlatESDFriendTrack( AliVVConstructorReinitialisationFlag );
//implementation of AliVVfriendTrack methods
+ Int_t GetTPCseed( AliTPCseed &) const {return -1;}
//AliVVTPCseed* GetTPCseed() const {return NULL;}
AliTPCseed* GetTPCseed() const { return NULL; }
//const AliExternalTrackParam * GetITSOut() const { return NULL; }
//const AliExternalTrackParam * GetTPCOut() const { return NULL; }
//const AliExternalTrackParam * GetTRDIn() const { return NULL; }
- const AliVVtrack * GetITSOut() const { return NULL; }
- const AliVVtrack * GetTPCOut() const { return NULL; }
- const AliVVtrack * GetTRDIn() const { return NULL; }
+ //const AliVVtrack * GetITSOut() const { return NULL; }
+ //const AliVVtrack * GetTPCOut() const { return NULL; }
+ //const AliVVtrack * GetTRDIn() const { return NULL; }
// own methods
}
-// _______________________________________________________________________________________________________
-void AliFlatESDTrack::Reinitialize()
-{
-//
-// Initializing function
-//
-// to be called after track is received via reinterpret_cast from memory
-
-
- new (this) AliFlatESDTrack(AliFlatESDReinitialize);
- AliFlatExternalTrackParam* trackParam = GetTrackParamRefitted();
- if (trackParam) { trackParam->Reinitialize(); }
- trackParam = GetTrackParamIp();
- if (trackParam) { trackParam->Reinitialize(); }
- trackParam = GetTrackParamTPCInner();
- if (trackParam) { trackParam->Reinitialize(); }
- trackParam = GetTrackParamOp();
- if (trackParam) { trackParam->Reinitialize(); }
- trackParam = GetTrackParamCp();
- if (trackParam) { trackParam->Reinitialize(); }
- trackParam = GetTrackParamITSOut();
- if (trackParam) { trackParam->Reinitialize(); }
-
- AliFlatTPCCluster* clusterTPC = GetTPCClusters();
- for (Int_t i=0; i<fNTPCClusters; i++){
- clusterTPC->Reinitialize();
- clusterTPC++;
- }
-}
-
// _______________________________________________________________________________________________________
AliFlatESDTrack::AliFlatESDTrack(const AliESDtrack* track, AliESDfriendTrack* friendTrack) :
// Constructor
for (Int_t idxRow = 0; idxRow < 160; idxRow++){
AliTPCclusterMI* currentCl = seed->GetClusterPointer(idxRow);
if (currentCl) {
- AliFlatTPCCluster* tmpCl = GetNextTPCClusterPointer();
- new(tmpCl) AliFlatTPCCluster;
- 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->SetPadRow(currentCl->GetRow());
- tmpCl->SetSigmaY2(currentCl->GetSigmaY2());
- tmpCl->SetSigmaZ2(currentCl->GetSigmaZ2());
- tmpCl->SetCharge(currentCl->GetQ());
- tmpCl->SetQMax(currentCl->GetMax());
+ 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: 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);
+ std::sort(GetTPCClusters(), GetTPCClusters()+fNTPCClusters, AliFlatTPCCluster::SortClusters);
}
return iResult;
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, fSize, fContent + fSize);
AliFlatExternalTrackParam * current = reinterpret_cast<AliFlatExternalTrackParam*> (fContent + fSize);
- new (current) AliFlatExternalTrackParam;
current->SetAlpha(param->GetAlpha());
current->SetX(param->GetX());
current->SetY(param->GetY());
#include "AliFlatTPCCluster.h"
#include "AliFlatExternalTrackParam.h"
-#include "AliVVtrack.h"
-#include "AliFlatESDMisc.h"
class AliESDtrack;
class AliESDfriendTrack;
class AliExternalTrackParam;
-class AliFlatESDTrack: public AliVVtrack {
+class AliFlatESDTrack {
public:
// --------------------------------------------------------------------------------
// -- Constructor / Destructors
- AliFlatESDTrack();
+ AliFlatESDTrack();
AliFlatESDTrack(const AliESDtrack* track, AliESDfriendTrack* friendTrack);
- virtual ~AliFlatESDTrack();
+ ~AliFlatESDTrack();
// --------------------------------------------------------------------------------
// -- Fill / Set methods
const AliExternalTrackParam* outerITSParam
);
- AliFlatTPCCluster *GetNextTPCClusterPointer(){ return GetTPCCluster(fNTPCClusters); }
+ AliFlatTPCCluster *GetNextTPCClusterPointer(){ return &GetTPCCluster(fNTPCClusters); }
void StoreLastTPCCluster(){
++fNTPCClusters;
AliFlatTPCCluster *GetTPCClusters() {
return reinterpret_cast< AliFlatTPCCluster*>(fContent + sizeof(AliFlatExternalTrackParam)*CountBits(fTrackParamMask));
}
-
-
- AliFlatTPCCluster *GetTPCCluster(Int_t ind) {
- return reinterpret_cast< AliFlatTPCCluster*>( GetTPCClusters() ) + ind ;
- }
+ AliFlatTPCCluster &GetTPCCluster(Int_t ind) {
+ return GetTPCClusters()[ind];
+ }
Int_t GetNumberOfITSClusters() {
return fNITSClusters;
}
- AliFlatTPCCluster *GetITSClusters() {
- return reinterpret_cast< AliFlatTPCCluster*>(fContent + sizeof(AliFlatExternalTrackParam)*CountBits(fTrackParamMask));
- }
-
// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
- AliFlatESDTrack *GetNextTrack()
-{
-
- return reinterpret_cast<AliFlatESDTrack*> (fContent + fSize);
-}
+ AliFlatESDTrack *GetNextTrack() {return reinterpret_cast<AliFlatESDTrack*>(fContent+fSize);}
// --------------------------------------------------------------------------------
// -- 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;}
-
-
- void Reinitialize();
-
+
private:
AliFlatESDTrack(const AliFlatESDTrack&);
- AliFlatESDTrack& operator=(const AliFlatESDTrack&);
- AliFlatESDTrack(AliFlatESDSpecialConstructorFlag){}
+ AliFlatESDTrack& operator=(const AliFlatESDTrack&);
Int_t FillExternalTrackParam(const AliExternalTrackParam* param, UShort_t flag);
Byte_t fContent[1]; // Variale size object, which contains all data
};
-
#endif
#include "AliFlatESDV0.h"
+
* Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli */
/**
- * >> Flat structure representing a ESD vertex <<
+ * >> Flat structure representing a ESD v0 vertex <<
*/
#include "Rtypes.h"
-#include "AliFlatESDMisc.h"
class AliFlatESDV0
{
public:
- AliFlatESDV0();
- virtual ~AliFlatESDV0() {}
- void Reinitialize(){
- new (this) AliFlatESDV0(AliFlatESDReinitialize);
- }
+
+ AliFlatESDV0(): fNegTrackID(-1), fPosTrackID(-1) {}
+ ~AliFlatESDV0(){}
+
+ static size_t GetSize(){ return sizeof(AliFlatESDV0); }
+
+ void SetNegTrackID( Int_t id ){ fNegTrackID = id; }
+ void SetPosTrackID( Int_t id ){ fPosTrackID = id; }
+
+ Int_t GetNegTrackID() const { return fNegTrackID; }
+ Int_t GetPosTrackID() const { return fPosTrackID; }
+
+ private:
+
+ AliFlatESDV0(const AliFlatESDV0&);
+ AliFlatESDV0& operator=(const AliFlatESDV0&);
+
Int_t fNegTrackID;
Int_t fPosTrackID;
- private:
- AliFlatESDV0(AliFlatESDSpecialConstructorFlag){}
};
-//typedef struct AliFlatESDV0 AliFlatESDV0;
#endif
#include "AliFlatESDVertex.h"
-
-void AliFlatESDVertex::Set(const AliESDVertex &v )
-{
- fPosition[0] = v.GetX();
- fPosition[1] = v.GetY();
- fPosition[2] = v.GetZ();
- Double_t c[6];
- v.GetCovarianceMatrix( c );
- for( int i=0; i<6; i++) fCov[i] = c[i];
- fNContributors = v.GetNContributors();
- fChi2 = v.GetChi2();
-}
#include "Rtypes.h"
#include "AliESDVertex.h"
-#include "AliFlatESDMisc.h"
-class AliFlatESDVertex
-//class AliFlatESDVertex
+struct AliFlatESDVertex
{
- public:
+
Double32_t fPosition[3]; // vertex position
Double32_t fCov[6]; // vertex covariance matrix
Int_t fNContributors; // # of tracklets/tracks used for the estimate
Char_t fBCID; // BC ID assigned to vertex
*/
- virtual ~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;
}
void Set(const AliESDVertex &v );
-
- void Reinitialize(){
- new (this) AliFlatESDVertex(AliFlatESDReinitialize);
- }
-
+
Double32_t GetX() const { return fPosition[0]; }
Double32_t GetY() const { return fPosition[1]; }
Double32_t GetZ() const { return fPosition[2]; }
Double_t GetWDist(const AliESDVertex* v) const;
*/
- private:
-
- AliFlatESDVertex(AliFlatESDSpecialConstructorFlag){}
+
+
};
+inline void AliFlatESDVertex::Set(const AliESDVertex &v )
+{
+ fPosition[0] = v.GetX();
+ fPosition[1] = v.GetY();
+ fPosition[2] = v.GetZ();
+ Double_t c[6];
+ v.GetCovarianceMatrix( c );
+ for( int i=0; i<6; i++) fCov[i] = c[i];
+ fNContributors = v.GetNContributors();
+ fChi2 = v.GetChi2();
+}
+
+typedef struct AliFlatESDVertex AliFlatESDVertex;
+
#endif
*/
#include "Rtypes.h"
-#include "AliFlatESDMisc.h"
-
-class AliFlatExternalTrackParam
+struct AliFlatExternalTrackParam
{
- public:
- AliFlatExternalTrackParam() {}
- virtual ~AliFlatExternalTrackParam() {}
Float_t fAlpha; // azimuthal angle of reference frame
Float_t fX; // x: radial distance
Float_t fY; // local Y-coordinate of a track (cm)
void SetTgl(Float_t tgl) {fTgl = tgl;}
void SetSigned1Pt(Float_t signed1Pt) {fSigned1Pt = signed1Pt;}
void SetCovEntry(Int_t idx, Float_t cov) {(idx >= 0 && idx < 15) ? fC[idx] = cov : 0.;}
-
- void Reinitialize(){
- new (this) AliFlatExternalTrackParam(AliFlatESDReinitialize);
- }
Float_t GetAlpha() const {return fAlpha;}
Float_t GetX() const {return fX;}
Float_t GetSigned1Pt() const {return fSigned1Pt;}
Float_t* GetCov() const {return const_cast<Float_t*>(fC);}
Float_t GetCovEntry(Int_t idx) const {return (idx >= 0 && idx < 15) ? fC[idx] : 0.;}
-
- private:
- AliFlatExternalTrackParam(AliFlatESDSpecialConstructorFlag){}
};
-//typedef struct AliFlatExternalTrackParam AliFlatExternalTrackParam;
+typedef struct AliFlatExternalTrackParam AliFlatExternalTrackParam;
#endif
class AliFlatTPCCluster: public AliVVcluster
{
public:
+
+ AliFlatTPCCluster() : fX(0.), fY(0.), fZ(0.), fPadRow(0), fSigmaY2(0.), fSigmaZ2(0.), fCharge(0), fQMax(0) {}
+ ~AliFlatTPCCluster() {}
+
void SetX(Float_t x) {fX = x;}
void SetY(Float_t y) {fY = y;}
void SetZ(Float_t z) {fZ = z;}
void SetQMax(UShort_t qmax) {fQMax = qmax;}
void Reinitialize(){
- new (this) AliFlatTPCCluster(AliFlatESDReinitialize);
+ new (this) AliFlatTPCCluster(AliFlatESDReinitialize);
}
Float_t GetX() const {return fX;}
UShort_t GetCharge() const {return fCharge;}
UShort_t GetQMax() const {return fQMax;}
- AliFlatTPCCluster()
- : fX(0.), fY(0.), fZ(0.), fPadRow(0), fSigmaY2(0.), fSigmaZ2(0.), fCharge(0), fQMax(0) {}
static Bool_t SortClusters(const AliFlatTPCCluster &first, const AliFlatTPCCluster &second){
// Method to sort two clusters according to pad row
}
private:
- AliFlatTPCCluster(AliFlatESDSpecialConstructorFlag){}
- virtual ~AliFlatTPCCluster() {}
+
+ AliFlatTPCCluster(AliFlatESDSpecialConstructorFlag f): AliVVcluster(f),fX(fX),fY(fY),fZ(fZ),fPadRow(fPadRow),fSigmaY2(fSigmaY2),fSigmaZ2(fSigmaZ2),fCharge(fCharge),fQMax(fQMax){}
+
Float_t fX; // X coordinate in local coordinates
Float_t fY; // Y coordinate in local coordinates
Float_t fZ; // Z coordinate in local coordinates
UInt_t fCharge; // total charge of cluster
UInt_t fQMax; // QMax of cluster
-
-
};
#endif
#include "AliHLTTPCClusterMCData.h"
#include "AliHLTTPCTransform.h"
-#include "AliSysInfo.h"
-
/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTGlobalFlatEsdConverterComponent)
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
-
}
AliHLTGlobalFlatEsdConverterComponent::~AliHLTGlobalFlatEsdConverterComponent()
AliHLTComponentTriggerData& /*trigData*/,
AliHLTUInt8_t* outputPtr,
AliHLTUInt32_t& size,
- AliHLTComponentBlockDataList& outputBlocks)
+ AliHLTComponentBlockDataList& outputBlocks )
{
-
// see header file for class documentation
-
-AliSysInfo::AddStamp("DoEvent.Start");
-
-
int iResult=0;
- bool benchmark = true;
+#ifdef xxx
if (!IsDataEvent()) return iResult;
fBenchmark.StartNewEvent();
fBenchmark.Start(0);
-
-
size_t maxOutputSize = size;
size = 0;
+
+ if( maxOutputSize < sizeof( AliFlatESDEvent ) ){
+ HLTWarning("Output buffer is too small.");
+ return -ENOMEM;
+ }
AliFlatESDEvent *flatEsd = reinterpret_cast<AliFlatESDEvent*>(outputPtr);
- new (flatEsd) AliFlatESDEvent; //standard ctor to initialize an empty event
+ new (flatEsd) AliFlatESDEvent;
+
+ flatEsd->SetMagneticField( fSolenoidBz );
+ flatEsd->SetRunNumber( GetRunNo() );
+ flatEsd->SetPeriodNumber( GetPeriodNumber() );
+ flatEsd->SetOrbitNumber( GetOrbitNumber() );
+ flatEsd->SetBunchCrossNumber( GetBunchCrossNumber() );
+ flatEsd->SetTimeStamp( GetTimeStamp() );
/*
- pESD->Reset();
- pESD->SetMagneticField(fSolenoidBz);
- pESD->SetRunNumber(GetRunNo());
- pESD->SetPeriodNumber(GetPeriodNumber());
- pESD->SetOrbitNumber(GetOrbitNumber());
- pESD->SetBunchCrossNumber(GetBunchCrossNumber());
- pESD->SetTimeStamp(GetTimeStamp());
-
const AliHLTCTPData* pCTPData=CTPData();
if (pCTPData) {
AliHLTUInt64_t mask=pCTPData->ActiveTriggers(trigData);
for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType| kAliHLTDataOriginTPC);
pBlock!=NULL; pBlock=GetNextInputBlock()) {
- fBenchmark.AddInput(pBlock->fSize);
+ //fBenchmark.AddInput(pBlock->fSize);
UInt_t slice = AliHLTTPCDefinitions::GetMinSliceNr(*pBlock);
UInt_t patch = AliHLTTPCDefinitions::GetMinPatchNr(*pBlock);
if( slice >= kNSlices || patch>= kNPatches ){
for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo| kAliHLTDataOriginTPC);
pBlock!=NULL; pBlock=GetNextInputBlock()) {
- fBenchmark.AddInput(pBlock->fSize);
+ //fBenchmark.AddInput(pBlock->fSize);
UInt_t slice = AliHLTTPCDefinitions::GetMinSliceNr(*pBlock);
UInt_t patch = AliHLTTPCDefinitions::GetMinPatchNr(*pBlock);
if( slice >= kNSlices || patch>= kNPatches ){
const AliESDVertex *primaryVertexSPD = dynamic_cast<const AliESDVertex*>( GetFirstInputObject( kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS ) );
const AliESDVertex *primaryVertexTracks = dynamic_cast<const AliESDVertex*>( GetFirstInputObject( kAliHLTDataTypeESDVertex|kAliHLTDataOriginOut ) );
-
// cout<<endl<<" Primary vertex Tracks: "<<primaryVertexTracks<<", SPD: "<< primaryVertexSPD <<endl<<endl;
+ cout<<endl<<" Primary vertex Tracks: "<<primaryVertexTracks<<", SPD: "<< primaryVertexSPD <<endl<<endl;
flatEsd->FillPrimaryVertices( primaryVertexSPD, primaryVertexTracks );
cP.RelateToVertex( primaryVertex, fSolenoidBz, 1000 );
}
+
AliFlatESDTrack *flatTrack = flatEsd->GetNextTrackPointer();
- new(flatTrack) AliFlatESDTrack;
- //cout<<"flatTrack: "<<flatTrack<<endl;
-
- //cout<<"GetNumberOfTPCClusters before: "<<flatTrack->GetNumberOfTPCClusters()<<endl;
UInt_t nClustersTPC = tpcTrack->GetNumberOfPoints();
UInt_t nClustersITS = itsRefit ?itsRefit->GetNumberOfPoints() :0;
flatTrack->SetNumberOfITSClusters( nClustersITS );
- //flatTrack->SetNumberOfTPCClusters(0);
-
- //cout<<"GetNumberOfTPCClusters: "<<flatTrack->GetNumberOfTPCClusters()<<endl;
if( flatEsd->GetSize() + flatTrack->EstimateSize( kTRUE, nClustersTPC ) >= maxOutputSize ){
cout<<endl<<endl<<"NOT ENOUGH MEMORY!!!!"<<endl<<endl;
continue;
}
const AliHLTTPCSpacePointData &cIn = clusterBlock->fSpacePoints[iCluster];
-
- AliFlatTPCCluster *c= flatTrack->GetTPCCluster( flatTrack->GetNumberOfTPCClusters() );;
- new (c) AliFlatTPCCluster;
- c->SetX(cIn.GetX());
- c->SetY(cIn.GetY());
- c->SetZ(cIn.GetZ());
- c->SetPadRow(cIn.GetPadRow() + AliHLTTPCTransform::GetFirstRow(iPatch));
- c->SetSigmaY2(cIn.GetSigmaY2());
- c->SetSigmaZ2(cIn.GetSigmaZ2());
- c->SetCharge(cIn.GetCharge());
- c->SetQMax(cIn.GetQMax());
+ AliFlatTPCCluster *c= flatTrack->GetNextTPCClusterPointer();
+ c->SetX( cIn.GetX() );
+ c->SetY( cIn.GetY() );
+ c->SetZ( cIn.GetZ() );
+ c->SetPadRow( cIn.GetPadRow() + AliHLTTPCTransform::GetFirstRow(iPatch) );
+ c->SetSigmaY2( cIn.GetSigmaY2() );
+ c->SetSigmaZ2( cIn.GetSigmaZ2() );
+ c->SetCharge( cIn.GetCharge() );
+ c->SetQMax( cIn.GetQMax() );
flatTrack->StoreLastTPCCluster();
}
}
- // cout<<"number of tpc clusters: "<<flatTrack->GetNumberOfTPCClusters()<<endl;
- //cout<<"number of its clusters: "<<flatTrack->GetNumberOfITSClusters()<<endl;
flatEsd->StoreLastTrack();
-
+
if (fVerbosity>0) tpcTrack->Print();
}
}
// Fill v0's
- int nV0s =0;
{
+ int nV0s =0;
const AliHLTComponentBlockData* pP = GetFirstInputBlock(kAliHLTDataTypeGlobalVertexer|kAliHLTDataOriginOut);
if (pP && pP->fSize && pP->fPtr) {
- fBenchmark.AddInput(pP->fSize);
const AliHLTGlobalVertexerComponent::AliHLTGlobalVertexerData *data = reinterpret_cast<AliHLTGlobalVertexerComponent::AliHLTGlobalVertexerData*>(pP->fPtr);
const int* v0s = data->fTrackIndices + data->fNPrimTracks;
nV0s = data->fNV0s;
flatEsd->StoreLastV0();
}
} else {
- HLTWarning(" No V0 data block");
+ HLTWarning("xxx No V0 data block");
}
+ cout<<"\nxxxx Found "<<nV0s<<" V0's\n"<<endl;
}
// Get ITS SPD vertex
for( const AliHLTComponentBlockData *i= GetFirstInputBlock(kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS); i!=NULL; i=GetNextInputBlock() ){
fBenchmark.AddInput(i->fSize);
}
- // Get Track vertex
- for( const AliHLTComponentBlockData *i= GetFirstInputBlock(kAliHLTDataTypeESDVertex|kAliHLTDataOriginOut); i!=NULL; i=GetNextInputBlock() ){
- fBenchmark.AddInput(i->fSize);
- }
-
-
/*
for ( const TObject *iter = GetFirstInputObject(kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS); iter != NULL; iter = GetNextInputObject() ) {
size += outBlock.fSize;
}
-
+ cout<<"iResut = "<<iResult<<endl;
fBenchmark.Stop(0);
HLTWarning( fBenchmark.GetStatistics() );
-
-
-
- if(benchmark){
-
- Double_t statistics[10];
- TString names[10];
- fBenchmark.GetStatisticsData(statistics, names);
- // statistics[5] = tracksTPC.size();
- // statistics[7] = nV0s;
-
- // FillBenchmarkHistos( statistics, names);
- fBenchmark.Reset();
-
- AliSysInfo::AddStamp("DoEvent.Stop", (int)(statistics[1]), (int)(statistics[2]) );
-
- }
+#endif
return iResult;
-
-
-
-
}
-
AliHLTComponentTriggerData& trigData,
AliHLTUInt8_t* outputPtr,
AliHLTUInt32_t& size,
- AliHLTComponentBlockDataList& outputBlocks);
+ AliHLTComponentBlockDataList& outputBlocks );
using AliHLTProcessor::DoEvent;
-
+
private:
/** copy constructor prohibited */
AliHLTGlobalFlatEsdConverterComponent(const AliHLTGlobalFlatEsdConverterComponent&);
/// solenoid b field
Double_t fSolenoidBz; //! transient
AliHLTComponentBenchmark fBenchmark; // benchmark
-
+
ClassDef(AliHLTGlobalFlatEsdConverterComponent, 0)
};
#endif
//
template <typename T> void GetP(T *p) const {
p[0]=Pt(); p[1]=Phi(); p[2]=Theta();}
- using AliVVtrack::GetP;
+ //using AliVVtrack::GetP;
// template <typename T> void GetPxPyPz(T *p) const {
// p[0] = Px(); p[1] = Py(); p[2] = Pz();}
Bool_t GetPxPyPz(Double_t *p) const;
Bool_t GetXYZ(Double_t *p) const {
return GetPosition(p); }
- using AliVVtrack::GetXYZ;
+ //using AliVVtrack::GetXYZ;
Bool_t GetXYZAt(Double_t x, Double_t b, Double_t *r) const;
Bool_t GetCovarianceXYZPxPyPz(Double_t /*cv*/[21]) const {AliFatal("Not implemented"); return 0;}
Bool_t IsEMCAL() const { return fEmcal; }
ULong_t GetStatus() const { return 0; }
Bool_t GetXYZ(Double_t *v) const { v[0]=0; v[1]=0; v[2]=0; return 0; }
- using AliVVtrack::GetXYZ;
+ using AliVTrack::GetXYZ;
Double_t GetBz() const { return 0; }
void GetBxByBz(Double_t b[3]) const { b[0]=0;b[1]=0;b[2]=0; }
Bool_t GetCovarianceXYZPxPyPz(Double_t /*cv*/[21]) const { return 0; }
class AliMultiplicity;
class AliAODTracklets; // XZhang 20120615
class AliAODTrack;
-class AliESDtrack;
class AliESDPmdTrack;
class AliFlowBayesianPID;
class AliESDkink;
AliTOFPIDResponse &tofResponse = fPIDResponse->GetTOFResponse();
Float_t p = trk->P();
- if (const AliVVtrack *param = trk->GetInnerParam())
+ if (const AliExternalTrackParam *param = trk->GetInnerParam())
p = param->GetP();
Double_t expTOF = fPIDResponse->GetTOFResponse().GetExpectedSignal(trk, AliPID::kProton);
virtual UChar_t GetITSClusterMap() const;
virtual ULong_t GetStatus() const;
virtual Bool_t GetXYZ(Double_t *p) const { return XvYvZv(p); }
- using AliVVtrack::GetXYZ;
+ using AliVTrack::GetXYZ;
virtual Bool_t GetCovarianceXYZPxPyPz(Double_t cv[21]) const;
virtual Bool_t PropagateToDCA(const AliVVertex* vtx,Double_t b,Double_t maxd,Double_t dz[2],Double_t covar[3]);
//
template <typename T> void GetP(T *p) const {
p[0]=fMomentum[0]; p[1]=fMomentum[1]; p[2]=fMomentum[2];}
- using AliVVtrack::GetP;
// template <typename T> void GetPxPyPz(T *p) const {
// p[0] = Px(); p[1] = Py(); p[2] = Pz();}
fCovMatrix->GetCovMatrix(covMatrix); return kTRUE;}
Bool_t GetXYZ(Double_t *p) const {
- return GetPosition(p); }
- using AliVVtrack::GetXYZ;
+ return GetPosition(p); }
Bool_t GetXYZAt(Double_t x, Double_t b, Double_t *r) const;
Bool_t GetXYZatR(Double_t xr,Double_t bz, Double_t *xyz=0, Double_t* alpSect=0) const;
ClassImp(AliESDEvent)
-
-
// here we define the names, some classes are no TNamed, therefore the classnames
// are the Names
const char* AliESDEvent::fgkESDListName[kESDListN] = {"AliESDRun",
void SetDAQAttributes(UInt_t attributes) {fDAQAttributes = attributes;}
UInt_t GetDAQDetectorPattern() const {return fDAQDetectorPattern;}
UInt_t GetDAQAttributes() const {return fDAQAttributes;}
-
+
+ // interface to AliVVevent
+ AliESDtrack *GetVVTrack(Int_t i) const { return GetTrack(i); }
+
protected:
AliESDEvent(const AliESDEvent&);
static Bool_t ResetWithPlacementNew(TObject *pObject);
#include "TObjArray.h"
#include "TClonesArray.h"
#include "AliKalmanTrack.h"
+#include "AliVVTPCseed.h"
ClassImp(AliESDfriendTrack)
return fCalibContainer->At(index);
}
+Int_t AliESDfriendTrack::GetTPCseed( AliTPCseed &seed) const {
+ TObject* calibObject = NULL;
+ AliVVTPCseed* seedP = NULL;
+ for (Int_t idx = 0; (calibObject = GetCalibObject(idx)); ++idx) {
+ if ((seedP = dynamic_cast<AliVVTPCseed*>(calibObject))) {
+ seedP->CopyToTPCseed( seed );
+ return 0;
+ }
+ }
+ return -1;
+}
void AliESDfriendTrack::SetTPCOut(const AliExternalTrackParam ¶m) {
//
class AliKalmanTrack;
class TObjArrray;
-class AliVVtrack;
class AliTPCseed;
AliKalmanTrack *GetITStrack() {return fITStrack;}
void AddCalibObject(TObject * calibObject);
TObject * GetCalibObject(Int_t index) const;
- AliTPCseed* GetTPCseed() const {return NULL;}
+
//
// parameters backup
void SetTPCOut(const AliExternalTrackParam ¶m);
void SetSkipBit(Bool_t skip){SetBit(23,skip);}
Bool_t TestSkipBit() {return TestBit(23);}
+ // VVfriendTrack interface
+
+ Int_t GetTPCseed( AliTPCseed &) const;
+
protected:
Float_t f1P; // 1/P (1/(GeV/c))
Int_t fnMaxITScluster; // Max number of ITS clusters
if (!fIp) return 0;
return fTPCdEdxInfo->GetdEdxInfo(fIp, regionID, calibID, qID, valueID);
}
+
+AliESDtrack tmpp;
#include <TBits.h>
#include "AliExternalTrackParam.h"
#include "AliVTrack.h"
+#include "AliVVtrack.h"
#include "AliESDTOFCluster.h"
#include "AliPID.h"
#include "AliESDfriendTrack.h"
class TTreeSRedirector;
class AliESDEvent;
-class AliESDtrack : public AliExternalTrackParam {
+class AliESDtrack : public AliExternalTrackParam, public AliVVtrack {
public:
//
enum {kNITSchi2Std=3};
Double_t M() const;
Double_t E() const;
Double_t Y() const;
-
+
Bool_t GetConstrainedPxPyPz(Double_t *p) const {
if (!fCp) return kFALSE;
return fCp->GetPxPyPz(p);
static bool OnlineMode() {return fgkOnlineMode;}
static Double_t GetLengthInActiveZone(const AliExternalTrackParam *paramT, Double_t deltaY, Double_t deltaZ, Double_t bz, Double_t exbPhi =0 , TTreeSRedirector * pcstream =0 );
Double_t GetLengthInActiveZone( Int_t mode, Double_t deltaY, Double_t deltaZ, Double_t bz, Double_t exbPhi =0 , TTreeSRedirector * pcstream =0 ) const;
+
+ // extra AliVVtrack interface
+ Double_t GetPt() const { return Pt(); }
+
protected:
AliExternalTrackParam *fCp; // Track parameters constrained to the primary vertex
Double_t GetChi2V0() const {return fChi2V0;}
void GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const;
void GetNPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const;
- void GetPPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const;
- using AliVVtrack::GetXYZ;
+ void GetPPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const;
void GetXYZ(Double_t &x, Double_t &y, Double_t &z) const;
Float_t GetD(Double_t x0,Double_t y0) const;
Float_t GetD(Double_t x0,Double_t y0,Double_t z0) const;
Bool_t ConstrainToVertex(const AliVVertex* vtx, Double_t b[3]);
void GetDirection(Double_t d[3]) const;
- Bool_t GetPxPyPz(Double_t *p) const;
- using AliVVtrack::GetXYZ;
+ Bool_t GetPxPyPz(Double_t *p) const;
Bool_t GetXYZ(Double_t *p) const;
Bool_t GetCovarianceXYZPxPyPz(Double_t cv[21]) const;
Bool_t GetPxPyPzAt(Double_t x, Double_t b, Double_t p[3]) const;
//if there is no inner param this could mean we're using the AOD track,
//we still can extrapolate from the vertex - so use those params.
- const AliVVtrack* ip = track->GetInnerParam();
+ const AliExternalTrackParam* ip = track->GetInnerParam();
if (ip) track=dynamic_cast<const AliVTrack*>(ip);
Bool_t trackAtInner = track->GetXYZAt(innerRadius, fMagField, trackPositionInner);
#include <Rtypes.h>
#include <TObject.h>
#include "AliVVMisc.h"
-#include "AliVVtrack.h"
#include <float.h>
const Double_t kB2C=-0.299792458e-3;
const Double_t kAlmost0Field=1.e-13;
-class AliVParticle: public TObject, public AliVVtrack {
+class AliVParticle: public TObject {
public:
AliVParticle() { }
#include "AliVParticle.h"
#include "AliPID.h"
+#include "AliVVMisc.h"
class AliVEvent;
class AliVVertex;
class AliTPCdEdxInfo;
class AliDetectorPID;
class AliTOFHeader;
-class AliVVtrack;
+class AliExternalTrackParam;
-
class AliVTrack: public AliVParticle {
public:
virtual void GetHMPIDmip(Float_t &/*x*/, Float_t &/*y*/, Int_t &/*q*/,Int_t &/*nph*/) const {;}
virtual Bool_t GetOuterHmpPxPyPz(Double_t */*p*/) const {return kFALSE;}
-
+
+ virtual const AliExternalTrackParam * GetInnerParam() const { return NULL;}
+ virtual const AliExternalTrackParam * GetOuterParam() const { return NULL;}
+ virtual const AliExternalTrackParam * GetTPCInnerParam() const { return NULL;}
+
virtual void GetIntegratedTimes(Double_t */*times*/, Int_t nspec=AliPID::kSPECIESC) const;
virtual Double_t GetTRDmomentum(Int_t /*plane*/, Double_t */*sp*/=0x0) const {return 0.;}
virtual void GetHMPIDpid(Double_t */*p*/) const {;}
virtual ULong_t GetStatus() const = 0;
virtual Bool_t GetXYZAt(Double_t /*x*/, Double_t /*b*/, Double_t* /*r*/ ) const ;
- using AliVVtrack::GetXYZ;
virtual Bool_t GetXYZ(Double_t* /*p*/) const ;
virtual Double_t GetBz() const;
virtual void GetBxByBz(Double_t b[3]) const;
virtual Bool_t GetCovarianceXYZPxPyPz(Double_t cv[21]) const = 0;
virtual Bool_t PropagateToDCA(const AliVVertex *vtx,Double_t b,Double_t maxd,Double_t dz[2],Double_t covar[3]) = 0;
- virtual const AliVVtrack * GetOuterParam() const { return NULL; }
- virtual const AliVVtrack * GetInnerParam() const { return NULL; }
virtual Int_t GetNcls(Int_t /*idet*/) const { return 0; }
virtual Bool_t GetPxPyPz(Double_t */*p*/) const { return kFALSE; }
virtual void SetID(Short_t /*id*/) {;}
* Primary Author: Mikolaj Krzewicki, mkrzewic@cern.ch
*/
#include "Rtypes.h"
+class AliTPCseed;
+
class AliVVTPCseed {
public:
AliVVTPCseed() {}
virtual ~AliVVTPCseed() {}
+ virtual void CopyToTPCseed( AliTPCseed &) const = 0;
ClassDef(AliVVTPCseed, 1);
};
// --------------------------------------------------------------------------------
// Access methods
+
+ virtual Double_t GetMagneticField() const = 0;
+ virtual UInt_t GetPeriodNumber() const = 0;
+ virtual Int_t GetRunNumber() const = 0;
+ virtual UInt_t GetOrbitNumber() const = 0;
+ virtual UShort_t GetBunchCrossNumber() const = 0;
+ virtual UInt_t GetTimeStamp() const = 0;
+ virtual ULong64_t GetTriggerMask() const = 0;
+ virtual TString GetFiredTriggerClasses() const = 0;
+ virtual UInt_t GetEventSpecie() const = 0;
+
+ virtual Int_t GetNumberOfTracks() const = 0;
+ virtual Int_t GetNumberOfV0s() const = 0;
+ virtual Int_t GetNumberOfKinks() const = 0;
+
/*
virtual const AliVVvertex* GetPrimaryVertex() const {return NULL;}
virtual const AliVVvertex* GetPrimaryVertexSPD() const {return NULL;}
virtual const AliVVvertex* GetPrimaryVertexTracks() const {return NULL;}
virtual const AliVVvertex* GetPrimaryVertexTPC() const {return NULL;}
*/
- virtual AliVVtrack* GetTrack(Int_t /*i*/) const = 0;
+ virtual AliVVtrack* GetVVTrack(Int_t /*i*/) const = 0;
virtual AliESDkink* GetKink(Int_t /*i*/) const = 0;
//virtual AliVVtrack* GetV0(Int_t /*i*/) const = 0;
- virtual Int_t GetNumberOfTracks() const =0;
- virtual Int_t GetNumberOfV0s() const = 0;
- virtual Int_t GetNumberOfKinks() const = 0;
- virtual Int_t GetEventNumberInFile() const = 0;
- virtual Int_t GetRunNumber() const = 0;
- virtual TString GetFiredTriggerClasses() const = 0;
- virtual ULong64_t GetTriggerMask() const = 0;
- virtual Double_t GetMagneticField() const = 0;
- virtual UInt_t GetTimeStamp() const = 0;
- virtual UInt_t GetEventSpecie() const = 0;
+
+ virtual void ConnectTracks() = 0;
// ESD interfaces, not yet implemented in flat esd (may be not needed, may be need some changes)
+
+ //virtual Int_t GetEventNumberInFile() const = 0;
//virtual const AliMultiplicity* GetMultiplicity() const = 0; //by default SPDmult
//virtual TObject* FindListObject(const char* /*name*/) const = 0;
//virtual AliVVfriendEvent* FindFriend() const = 0;
- //virtual void ConnectTracks() = 0;
//virtual void ReadFromTree(TTree* /*tree*/, Option_t* /*opt*/) = 0;
//virtual TList* GetList() const = 0;
#include "Rtypes.h"
class AliTPCseed;
class AliVVtrackPointArray;
-class AliVVtrack;
//_____________________________________________________________________________
class AliVVfriendTrack {
virtual ~AliVVfriendTrack(){}
//used in calibration
- virtual AliTPCseed* GetTPCseed() const {return NULL;}
- virtual const AliVVtrackPointArray *GetTrackPointArray() const {return NULL;}
- virtual const AliVVtrack * GetITSOut() const {return NULL;}
- virtual const AliVVtrack * GetTPCOut() const {return NULL;}
- virtual const AliVVtrack * GetTRDIn() const {return NULL;}
- virtual TObject* GetCalibObject(Int_t /*index*/) const {return NULL;}
+
+ virtual Int_t GetTPCseed( AliTPCseed &) const = 0;
+ //virtual const AliVVtrackPointArray *GetTrackPointArray() const {return NULL;}
+ //virtual const AliVVtrack * GetITSOut() const {return NULL;}
+ //virtual const AliVVtrack * GetTPCOut() const {return NULL;}
+ //virtual const AliVVtrack * GetTRDIn() const {return NULL;}
+ // virtual TObject* GetCalibObject(Int_t /*index*/) const = 0;
private:
AliVVfriendTrack(const AliVVfriendTrack &);
**************************************************************************/
#include "AliVVtrack.h"
- AliFlatExternalTrackParam* AliVVtrack::GetTrackParamRefitted() { return NULL; }
- AliFlatExternalTrackParam* AliVVtrack::GetTrackParamIp() { return NULL; }
- AliFlatExternalTrackParam* AliVVtrack::GetTrackParamTPCInner() { return NULL; }
- AliFlatExternalTrackParam* AliVVtrack::GetTrackParamOp() { return NULL; }
- AliFlatExternalTrackParam* AliVVtrack::GetTrackParamCp() { return NULL; }
- AliFlatExternalTrackParam* AliVVtrack::GetTrackParamITSOut() { return NULL; }
-
- // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
- Int_t AliVVtrack::GetNumberOfTPCClusters() { return 0; }
- AliFlatTPCCluster* AliVVtrack::GetTPCClusters() { return NULL; }
- AliFlatTPCCluster* AliVVtrack::GetTPCCluster(Int_t /*ind*/) { return NULL; }
- Int_t AliVVtrack::GetNumberOfITSClusters() { return 0; }
- AliVVtrack *AliVVtrack::GetNextTrack() {return NULL; }
-
- Bool_t AliVVtrack::GetXYZ(Double_t* /*p*/) const {return kFALSE;}
- void AliVVtrack::GetXYZ(Double_t& /*x*/, Double_t& /*y*/, Double_t& /*z*/) const {}
- Bool_t AliVVtrack::GetXYZAt(Double_t /*x*/, Double_t /*y*/, Double_t* /*z*/) const {return kFALSE;}
- Double_t AliVVtrack::GetTgl() const {return 0.;}
- UShort_t AliVVtrack::GetTPCNclsF() const { return 0;}
-
- Double_t AliVVtrack::GetTOFsignalDz() const {return 0.;}
- void AliVVtrack::GetImpactParameters(Float_t& /*xy*/,Float_t& /*z*/) const {}
- //TODO:
- void AliVVtrack::GetDZ(Double_t /*x*/,Double_t /*y*/,Double_t /*z*/,Double_t /*b*/, Float_t dz[2]) const {if (dz[0]==0) return;}
-
- Float_t AliVVtrack::GetTPCClusterInfo(Int_t nNeighbours, Int_t type, Int_t row0, Int_t row1, Int_t bitType ) const {return 0.*nNeighbours*type*row0*row1*bitType;}
- UShort_t AliVVtrack::GetTPCncls(Int_t row0,Int_t row1) const {return 0*row0*row1;}
- Bool_t AliVVtrack::IsOn(Int_t /*mask*/) const {return kFALSE;}
- void AliVVtrack::GetDirection(Double_t d[3]) const {if (d[0]==0) return;}
- const Double_t *AliVVtrack::GetParameter() const {return 0;}
- void AliVVtrack::GetImpactParametersTPC(Float_t& /*xy*/,Float_t& /*z*/) const {}
- Int_t AliVVtrack::GetNumberOfClusters() const {return 0;}
- const AliVVtrack* AliVVtrack::GetTPCInnerParam() const {return NULL;}
- Double_t AliVVtrack::Pt() const {return 0.;}
- Double_t AliVVtrack::GetP() const {return 0.;}
- Double_t AliVVtrack::GetTPCmomentum() const {return 0.;}
- ULong_t AliVVtrack::GetStatus() const {return 0;}
- const AliVVtrack * AliVVtrack::GetOuterParam() const { return NULL;}
- const AliVVtrack * AliVVtrack::GetInnerParam() const { return NULL;}
- Int_t AliVVtrack::GetKinkIndex(Int_t /*i*/) const { return 0;}
- Double_t AliVVtrack::Eta() const {return 0.;}
- Double_t AliVVtrack::GetY() const {return 0.;}
-
- Double_t AliVVtrack::GetX() const {return 0.;}
- Double_t AliVVtrack::GetZ() const {return 0.;}
- Int_t AliVVtrack::GetNcls(Int_t /*idet*/) const {return 0;}
- void AliVVtrack::GetIntegratedTimes(Double_t* /*times*/, Int_t nspec) const {if (nspec<0) return;}
- Double_t AliVVtrack::GetSigned1Pt() const {return 0.;}
- Double_t AliVVtrack::GetLinearD(Double_t /*xv*/, Double_t /*yv*/) const {return 0.;}
- const AliVVtrack *AliVVtrack::GetConstrainedParam() const {return NULL;}
- Double_t AliVVtrack::GetAlpha() const {return 0.;}
- Char_t AliVVtrack::GetITSclusters(Int_t* /*idx*/) const {return 0;}
- Double_t AliVVtrack::GetSign() const {return 0.;}
- UShort_t AliVVtrack::GetTPCNcls() const { return 0;}
- Float_t AliVVtrack::GetTPCCrossedRows() const {return 0.;}
- Double_t AliVVtrack::GetTPCsignal() const {return 0.;}
- Double_t AliVVtrack::GetTOFsignal() const {return 0.;}
- UChar_t AliVVtrack::GetTRDclusters(Int_t* /*idx*/) const {return 0;}
-
- //AliTPCtrack
- Int_t AliVVtrack::GetNFoundable() const {return 0;}
- Double_t AliVVtrack::GetdEdx() const {return 0.;}
* See implementation file for documentation
*/
-#include "AliPID.h"
+#include "Rtypes.h"
-class AliFlatTPCCluster;
-class AliFlatExternalTrackParam;
+class AliExternalTrackParam;
class AliVVtrack {
public:
// --------------------------------------------------------------------------------
// -- Getter methods
- virtual AliFlatExternalTrackParam* GetTrackParamRefitted() ;
- virtual AliFlatExternalTrackParam* GetTrackParamIp() ;
- virtual AliFlatExternalTrackParam* GetTrackParamTPCInner() ;
- virtual AliFlatExternalTrackParam* GetTrackParamOp() ;
- virtual AliFlatExternalTrackParam* GetTrackParamCp() ;
- virtual AliFlatExternalTrackParam* GetTrackParamITSOut() ;
-
+ /*
+ virtual Int_t GetTrackParamRefitted( AliExternalTrackParam & ) const = 0 ;
+ virtual Int_t GetTrackParamIp( AliExternalTrackParam & ) const = 0 ;
+ virtual Int_t GetTrackParamTPCInner( AliExternalTrackParam & ) const = 0 ;
+ virtual Int_t GetTrackParamOp( AliExternalTrackParam & ) const = 0 ;
+ virtual Int_t GetTrackParamCp( AliExternalTrackParam & ) const = 0 ;
+ virtual Int_t GetTrackParamITSOut( AliExternalTrackParam & ) const = 0 ;
+ */
// -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
- virtual Int_t GetNumberOfTPCClusters() ;
- virtual AliFlatTPCCluster* GetTPCClusters() ;
- virtual AliFlatTPCCluster* GetTPCCluster(Int_t /*ind*/) ;
- virtual Int_t GetNumberOfITSClusters() ;
- virtual AliVVtrack *GetNextTrack() ;
-
- virtual Bool_t GetXYZ(Double_t* p) const ;
- virtual Bool_t GetXYZAt(Double_t x, Double_t y, Double_t* z) const ;
-
- //AliESDv0
- virtual void GetXYZ(Double_t& x, Double_t& y, Double_t& z) const ;
-
- virtual Double_t GetTgl() const ;
- virtual UShort_t GetTPCNclsF() const ;
-
- virtual Double_t GetTOFsignalDz() const ;
- virtual void GetImpactParameters(Float_t& /*xy*/,Float_t& /*z*/) const ;
- //TODO:
- virtual void GetDZ(Double_t /*x*/,Double_t /*y*/,Double_t /*z*/,Double_t /*b*/, Float_t dz[2]) const ;
-
- virtual Float_t GetTPCClusterInfo(Int_t nNeighbours=3, Int_t type=0, Int_t row0=0, Int_t row1=159, Int_t bitType=0 ) const ;
- virtual UShort_t GetTPCncls(Int_t row0=0,Int_t row1=159) const ;
- virtual Bool_t IsOn(Int_t /*mask*/) const ;
- virtual void GetDirection(Double_t d[3]) const ;
- virtual const Double_t *GetParameter() const ;
- virtual void GetImpactParametersTPC(Float_t& /*xy*/,Float_t& /*z*/) const ;
- virtual Int_t GetNumberOfClusters() const ;
- virtual const AliVVtrack* GetTPCInnerParam() const ;
- virtual Double_t Pt() const ;
- virtual Double_t GetP() const ;
- virtual Double_t GetTPCmomentum() const ;
- virtual ULong_t GetStatus() const ;
- virtual const AliVVtrack * GetOuterParam() const ;
- virtual const AliVVtrack * GetInnerParam() const ;
- virtual Int_t GetKinkIndex(Int_t /*i*/) const ;
- virtual Double_t Eta() const ;
- virtual Double_t GetY() const ;
-
- virtual Double_t GetX() const ;
- virtual Double_t GetZ() const ;
- virtual Int_t GetNcls(Int_t /*idet*/) const ;
- virtual void GetIntegratedTimes(Double_t* /*times*/, Int_t nspec=AliPID::kSPECIES) const ;
- virtual Double_t GetSigned1Pt() const ;
- virtual Double_t GetLinearD(Double_t /*xv*/, Double_t /*yv*/) const ;
- virtual const AliVVtrack *GetConstrainedParam() const ;
- virtual Double_t GetAlpha() const ;
- virtual Char_t GetITSclusters(Int_t* /*idx*/) const ;
- virtual Double_t GetSign() const ;
- virtual UShort_t GetTPCNcls() const ;
- virtual Float_t GetTPCCrossedRows() const ;
- virtual Double_t GetTPCsignal() const ;
- virtual Double_t GetTOFsignal() const ;
- virtual UChar_t GetTRDclusters(Int_t* /*idx*/) const ;
-
- //AliTPCtrack
- virtual Int_t GetNFoundable() const ;
- virtual Double_t GetdEdx() const ;
+ virtual UShort_t GetTPCNcls() const {return 0;}//= 0;
+ virtual Double_t GetPt() const {return 0;}//= 0;
+
+
+ // may be for the future
+
+ // virtual Float_t GetTPCClusterInfo(Int_t nNeighbours=3, Int_t type=0, Int_t row0=0, Int_t row1=159, Int_t bitType=0 ) const ;
+ // virtual UShort_t GetTPCncls(Int_t row0=0,Int_t row1=159) const ;
+ // virtual Bool_t IsOn(Int_t /*mask*/) const ;
+ // virtual void GetImpactParametersTPC(Float_t& /*xy*/,Float_t& /*z*/) const ;
+ // virtual ULong_t GetStatus() const ;
+ // virtual Int_t GetKinkIndex(Int_t /*i*/) const ;
+ // virtual Int_t GetNcls(Int_t /*idet*/) const ;
+ // virtual void GetIntegratedTimes(Double_t* /*times*/, Int_t nspec=AliPID::kSPECIES) const ;
+ // virtual Char_t GetITSclusters(Int_t* /*idx*/) const ;
+ // virtual Float_t GetTPCCrossedRows() const ;
+ // virtual Double_t GetTPCsignal() const ;
+ // virtual Double_t GetTOFsignal() const ;
+ // virtual UChar_t GetTRDclusters(Int_t* /*idx*/) const ;
ClassDef(AliVVtrack, 1) // base class for track data
// Track loop to fill a pT spectrum
for (Int_t iTracks = 0; iTracks < fESD->GetNumberOfTracks(); iTracks++) {
- AliVVtrack* track = fESD->GetTrack(iTracks);
+ AliVVtrack* track = fESD->GetVVTrack(iTracks);
if (!track) {
Printf("ERROR: Could not receive track %d", iTracks);
continue;
}
- Printf("track %d has pt = %f", iTracks, track->Pt());
- fHistPt->Fill(track->Pt());
+ Printf("track %d has pt = %f", iTracks, track->GetPt());
+ fHistPt->Fill(track->GetPt());
} //track loop
if (!friendTrack) {
Printf("ERROR: Could not receive track %d", iFriend);
continue;
- }
- TObject* calibObject;
- AliTPCseed* seed = NULL;
- //AliTPCseed* seed = friendTrack->GetTPCseed();
- //if (seed){
- for (Int_t idx = 0; (calibObject = friendTrack->GetCalibObject(idx)); ++idx) {
- Printf(" |Cal %d = %p", idx, calibObject);
- if ((seed = dynamic_cast<AliTPCseed*>(calibObject))) {
- //Printf("Found TPC seed %p", seed);
- for (Int_t irow = 0; irow < 160; irow++){
- AliTPCclusterMI* cluMI = seed->GetClusterPointer(irow);
- if (cluMI){
- Printf("Found cluster at row %d", irow);
- Float_t q = cluMI->GetQ();
- Printf("Q = %f", q);
- fHistQ->Fill(q);
- }
- else {
- Printf("Row %d does not contain clusters", irow);
- }
+ }
+
+ AliTPCseed seed;
+ Int_t err = friendTrack->GetTPCseed( seed );
+ if( err==0 ){
+ Printf("Found TPC seed" );
+ for (Int_t irow = 0; irow < 160; irow++){
+ AliTPCclusterMI* cluMI = seed.GetClusterPointer(irow);
+ if (cluMI){
+ Printf("Found cluster at row %d", irow);
+ Float_t q = cluMI->GetQ();
+ Printf("Q = %f", q);
+ fHistQ->Fill(q);
}
- }
- else {
- //Printf("Schade... seed is %p", seed);
+ else {
+ Printf("Row %d does not contain clusters", irow);
+ }
}
+ }
+ else {
+ //Printf("Schade... seed is %p", seed);
}
}
}
class AliTPCCalPad;
class TClonesArray;
-class AliTPCseed : public AliTPCtrack {
+class AliTPCseed : public AliTPCtrack, public AliVVTPCseed {
public:
AliTPCseed();
virtual ~AliTPCseed();
void SetPoolID(Int_t id) {fPoolID = id;}
Int_t GetPoolID() const {return fPoolID;}
Int_t GetNumberOfClustersIndices(); // Should be in AliTPCtrack
+
+ // AliVVTPCseed interface
+
+ void CopyToTPCseed( AliTPCseed &s) const { s = *this; }
+
private:
// AliTPCseed & operator = (const AliTPCseed &)
// {::Fatal("= operator","Not Implemented\n");return *this;}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff