AliFlatESDV0.h
AliFlatESDFriend.h
AliFlatESDFriendTrack.h
+ AliFlatTPCseed.h
physics/AliHLTV0HistoComponent.h
physics/AliHLTCaloHistoComponent.h
physics/AliHLTCaloHistoProducer.h
#include "AliFlatESDFriend.h"
#include "AliFlatESDFriendTrack.h"
#include "Riostream.h"
+#include "AliESDfriend.h"
// _______________________________________________________________________________________________________
AliFlatESDFriend::AliFlatESDFriend() :
cout<<" N tracks: "<<fNTracks<<endl;
cout<<" N track entries: "<<fNTrackEntries<<endl;
}
+
+
+// _______________________________________________________________________________________________________
+Int_t AliFlatESDFriend::SetFromESDfriend( const size_t allocatedMemorySize, const AliESDfriend *esdFriend )
+{
+ // Fill flat ESD friend from ALiESDfriend
+
+ if( allocatedMemorySize < sizeof(AliFlatESDFriend ) ) return -1;
+
+ Reset();
+
+ if( !esdFriend ) return 0;
+
+ Int_t err = 0;
+ size_t freeSpace = allocatedMemorySize - GetSize();
+
+ // fill event info
+ {
+ SetSkipBit( esdFriend->TestSkipBit() );
+ for( int iSector=0; iSector<72; iSector++ ){
+ SetNclustersTPC( iSector, esdFriend->GetNclustersTPC(iSector) );
+ SetNclustersTPCused( iSector, esdFriend->GetNclustersTPCused(iSector) );
+ }
+ }
+
+ // fill track friends
+ {
+ size_t trackSize = 0;
+ int nTracks = 0;
+ int nTrackEntries = 0;
+ Long64_t *table = NULL;
+ AliFlatESDFriendTrack *flatTrack = NULL;
+ err = SetTracksStart( flatTrack, table, esdFriend->GetNumberOfTracks(), freeSpace );
+ if( err!=0 ) return err;
+ freeSpace = allocatedMemorySize - GetSize();
+
+ for (Int_t idxTrack = 0; idxTrack < esdFriend->GetNumberOfTracks(); ++idxTrack) {
+ const AliESDfriendTrack *esdTrack = esdFriend->GetTrack(idxTrack);
+ table[idxTrack] = -1;
+ if (esdTrack) {
+ table[idxTrack] = trackSize;
+ if( freeSpace<flatTrack->EstimateSize() ) return -1;
+ new (flatTrack) AliFlatESDFriendTrack;
+ //flatTrack->SetFromESDTrack( esdTrack );
+ trackSize += flatTrack->GetSize();
+ freeSpace -= flatTrack->GetSize();
+ nTrackEntries++;
+ flatTrack = flatTrack->GetNextTrackNonConst();
+ }
+ nTracks++;
+ }
+
+ SetTracksEnd( nTracks, nTrackEntries, trackSize );
+ }
+
+ return 0;
+}
+
#include "AliVfriendEvent.h"
#include "AliFlatESDFriendTrack.h"
-class AliVVVZEROfriend;
-class AliVVTZEROfriend;
+
+class AliESDfriend;
+//class AliESDVZEROfriend;
+//class AliESDTZEROfriend;
+
//_____________________________________________________________________________
class AliFlatESDFriend : public AliVfriendEvent {
public:
AliFlatESDFriend();
~AliFlatESDFriend() {}
+
+ // constructor and method for reinitialisation of virtual table
+ AliFlatESDFriend( AliVConstructorReinitialisationFlag );
+ void Reinitialize(){ new (this) AliFlatESDFriend(AliVReinitialize); }
// Implementation of virtual methods of AliVfriend
Int_t GetNumberOfTracks() const { return fNTracks; }
- Int_t GetEntriesInTracks() const { return fNTrackEntries; }
const AliVfriendTrack* GetTrack(Int_t i) const {return GetFlatTrack(i); }
-
- AliVVVZEROfriend *GetVZEROfriend(){ return NULL; }
- AliVVTZEROfriend *GetTZEROfriend(){ return NULL; }
+ Int_t GetEntriesInTracks() const { return fNTrackEntries; }
+
+ //AliESDVZEROfriend *GetVZEROfriend(){ return NULL; }
+ //AliESDTZEROfriend *GetTZEROfriend(){ return NULL; }
void Ls() const;
-
void Reset();
-
+
+ // bit manipulation for filtering
+ void SetSkipBit(Bool_t skip){ fBitFlags = skip; }
Bool_t TestSkipBit() const { return (fBitFlags!=0); }
+ //TPC cluster occupancy
Int_t GetNclustersTPC(UInt_t sector) const { return (sector<72)?fNclustersTPC[sector]:0; }
Int_t GetNclustersTPCused(UInt_t sector) const { return (sector<72)?fNclustersTPCused[sector]:0; }
- //virtual void AddTrack(const AliVfriendTrack *t) {}
- //virtual void AddTrackAt(const AliVfriendTrack* /*t*/, Int_t /*i*/) {}
- //virtual void SetVZEROfriend(AliESDVZEROfriend* /*obj*/) {}
- //virtual void SetTZEROfriend(AliESDTZEROfriend * obj) {}
- //void SetSkipBit(Bool_t skip){}
+ // -- Own methods --
- // Own methods
-
- void SetSkipBit(Bool_t skip){ fBitFlags = skip; }
+ // Set methods
+
+ Int_t SetFromESDfriend( size_t allocatedMemorySize, const AliESDfriend *esdFriend );
+
void SetNclustersTPC(UInt_t sector, Int_t occupancy ) { if (sector<72) fNclustersTPC[sector]=occupancy; }
void SetNclustersTPCused(UInt_t sector, Int_t occupancy ) {if (sector<72) fNclustersTPCused[sector]=occupancy; }
+ Int_t SetTracksStart( AliFlatESDFriendTrack* &t, Long64_t* &table, Int_t nTracks, size_t freeMem );
+ void SetTracksEnd( Int_t nTracks, Int_t nTrackEntries, size_t tracksSize );
+
+ // other methods
+
const AliFlatESDFriendTrack *GetFlatTrack( Int_t i ) const {
const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
if( i<0 || i>fNTracks || table[i]<0 ) return NULL;
ULong64_t GetSize() const { return fContent - reinterpret_cast<const Byte_t*>(this) + fContentSize; }
- void Reinitialize()
- {
- new (this) AliFlatESDFriend(AliVReinitialize);
- }
private:
AliFlatESDFriend(const AliFlatESDFriend&);
AliFlatESDFriend& operator=(const AliFlatESDFriend& );
- // special constructor, to be called by placement new,
- // when accessing information after reinterpret_cast
- // so that vtable is generated, but values are not overwritten
- AliFlatESDFriend(AliVConstructorReinitialisationFlag);
-
AliFlatESDFriendTrack *GetFlatTrackNonConst( Int_t i ){
const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
if( i<0 || i>fNTracks || table[i]<0 ) return NULL;
// Pointers to specific data in fContent
- size_t fTrackTablePointer; // position of the first track in fContent
+ size_t fTrackTablePointer; // position of the first track in fContent
size_t fTracksPointer; // position of the first track in fContent
// -- Variable Size Object
Byte_t fContent[1]; // Variale size object, which contains all data
};
+
+inline Int_t AliFlatESDFriend::SetTracksStart( AliFlatESDFriendTrack* &t, Long64_t* &table, Int_t nTracks, size_t freeMem)
+{
+ fNTracks = 0;
+ fNTrackEntries = 0;
+ if( nTracks*sizeof(Long64_t) > freeMem ) return -1;
+ fTrackTablePointer = fContentSize;
+ fContentSize += nTracks*sizeof(Long64_t);
+ fTracksPointer = fContentSize;
+ table = reinterpret_cast< Long64_t* >( fContent + fTrackTablePointer );
+ t = reinterpret_cast< AliFlatESDFriendTrack* >( fContent + fTracksPointer );
+ return 0;
+}
+
+inline void AliFlatESDFriend::SetTracksEnd( Int_t nTracks, Int_t nTrackEntries, 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;
+ fNTrackEntries = nTrackEntries;
+ fContentSize += tracksSize;
+}
+
#endif
#include "AliFlatESDFriendTrack.h"
#include "AliExternalTrackParam.h"
+#include "AliESDfriendTrack.h"
+#include "AliTPCseed.h"
#include "Riostream.h"
// _______________________________________________________________________________________________________
-AliFlatESDFriendTrack::AliFlatESDFriendTrack() :
- AliVfriendTrack()
+ AliFlatESDFriendTrack::AliFlatESDFriendTrack()
+:
+ AliVfriendTrack(),
+ fContentSize(0),
+ fTPCOutPointer(-1),
+ fITSOutPointer(-1),
+ fTRDInPointer(-1),
+ fTPCseedPointer(-1),
+ fBitFlags(0)
{
// Default constructor
+ fContent[0]=0;
}
-AliFlatESDFriendTrack::AliFlatESDFriendTrack( AliVConstructorReinitialisationFlag f ) :
-AliVfriendTrack( f )
+ AliFlatESDFriendTrack::AliFlatESDFriendTrack( AliVConstructorReinitialisationFlag f )
+:
+ AliVfriendTrack( f ),
+ fContentSize(fContentSize),
+ fTPCOutPointer(fTPCOutPointer),
+ fITSOutPointer(fITSOutPointer),
+ fTRDInPointer(fTRDInPointer),
+ fTPCseedPointer(fTPCseedPointer),
+ fBitFlags(fBitFlags)
{
// constructor for reinitialisation of vtable
}
+
+void AliFlatESDFriendTrack::Reset()
+{
+ // reset
+ fContentSize = 0;
+ fTPCOutPointer = -1;
+ fITSOutPointer = -1;
+ fTRDInPointer = -1;
+ fTPCseedPointer = -1;
+ fBitFlags = 0;
+}
+
+Int_t AliFlatESDFriendTrack::SetFromESDfriendTrack( const AliESDfriendTrack* track, size_t allocatedMemory )
+{
+ if( allocatedMemory < EstimateSize() ) return -1;
+ Reset();
+ if( !track ) return 0;
+ SetSkipBit(track->TestSkipBit() );
+ SetTrackParamTPCOut( track->GetTPCOut() );
+ SetTrackParamITSOut( track->GetITSOut() );
+ SetTrackParamTRDIn( track->GetTRDIn() );
+ const AliTPCseed* seedP = NULL;
+ {
+ TObject* calibObject = NULL;
+ for (Int_t idx = 0; (calibObject = track->GetCalibObject(idx)); ++idx) {
+ if ((seedP = dynamic_cast<const AliTPCseed*>(calibObject))) {
+ break;
+ }
+ }
+ }
+ SetTPCseed( seedP );
+ return 0;
+}
* See implementation file for documentation
*/
-/*
-Cp - Track parameters constrained to the primary vertex
-Ip - Track parameters estimated at the inner wall of TPC
-TPCInner - Track parameters estimated at the inner wall of TPC using the TPC stand-alone
-Op - Track parameters estimated at the point of maximal radial coordinate reached during the tracking
-*/
#include "Rtypes.h"
#include "AliFlatTPCCluster.h"
#include "AliVfriendTrack.h"
#include "AliVMisc.h"
+#include "AliFlatExternalTrackParam.h"
+#include "AliFlatTPCseed.h"
class AliESDtrack;
class AliESDfriendTrack;
class AliFlatESDFriendTrack :public AliVfriendTrack
{
public:
+
+ // --------------------------------------------------------------------------------
+ // -- Constructor / Destructors
AliFlatESDFriendTrack();
~AliFlatESDFriendTrack() {}
- // constructor for reinitialisation of virtual table
+
+ // constructor and method for reinitialisation of virtual table
AliFlatESDFriendTrack( AliVConstructorReinitialisationFlag );
+ void Reinitialize() { new (this) AliFlatESDFriendTrack( AliVReinitialize ); }
+
+ // -------------------- AliVfriendTrack interface ---------------------------------
- //implementation of AliVfriendTrack methods
Int_t GetTPCseed( AliTPCseed &) const {return -1;}
+
+ Int_t GetTrackParamTPCOut( AliExternalTrackParam &p ) const { return GetTrackParam( fTPCOutPointer, p ); }
+ Int_t GetTrackParamITSOut( AliExternalTrackParam &p ) const { return GetTrackParam( fITSOutPointer, p ); }
+ Int_t GetTrackParamTRDIn( AliExternalTrackParam &p ) const { return GetTrackParam( fTRDInPointer, p ); }
- //AliVVTPCseed* GetTPCseed() const {return NULL;}
- AliTPCseed* GetTPCseed() const { return NULL; }
- //AliVVTRDseed* GetTRDseed() const {return NULL;}
- const AliVVtrackPointArray *GetTrackPointArray() 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; }
+ //virtual const AliVtrackPointArray *GetTrackPointArray() const {return NULL;}
- // own methods
+
+ // bit manipulation for filtering
- void Reinitialize() { new (this) AliFlatESDFriendTrack( AliVReinitialize ); }
+ void SetSkipBit(Bool_t skip){ fBitFlags = skip; }
+ Bool_t TestSkipBit() const { return (fBitFlags!=0); }
+ // ------------------- Own methods ---------------------------------------------------------
+
+ // -- Set methods
+
+ void Reset();
+
+ Int_t SetFromESDfriendTrack( const AliESDfriendTrack* track, size_t allocatedMemory );
+
+ void SetTrackParamTPCOut( const AliExternalTrackParam *p ){ SetTrackParam( fTPCOutPointer, p ); }
+ void SetTrackParamITSOut( const AliExternalTrackParam *p ){ SetTrackParam( fITSOutPointer, p ); }
+ void SetTrackParamTRDIn ( const AliExternalTrackParam *p ){ SetTrackParam( fTRDInPointer, p ); }
+ void SetTPCseed ( const AliTPCseed *p );
+
+ // --
+
+ const AliFlatESDFriendTrack *GetNextTrack() const { return reinterpret_cast<const AliFlatESDFriendTrack*>(fContent+fContentSize); }
+ AliFlatESDFriendTrack *GetNextTrackNonConst() { return reinterpret_cast<AliFlatESDFriendTrack*>(fContent+fContentSize); }
+
+ // --------------------------------------------------------------------------------
+ // -- Size methods
+
+ static size_t EstimateSize(){
+ return sizeof(AliFlatESDFriendTrack) + 3*sizeof(AliFlatExternalTrackParam) + AliFlatTPCseed::EstimateSize();
+ }
+
+ size_t GetSize() const { return fContent - reinterpret_cast<const Byte_t*>(this) + fContentSize; }
+
private:
AliFlatESDFriendTrack(const AliFlatESDFriendTrack &);
AliFlatESDFriendTrack& operator=(const AliFlatESDFriendTrack& );
+ Int_t GetTrackParam( Long64_t ptr, AliExternalTrackParam ¶m ) const;
+ void SetTrackParam( Long64_t &ptr, const AliExternalTrackParam *p );
+
+ // --------------------------------------------------------------------------------
+
+ ULong64_t fContentSize; // Size of this object
+ Long64_t fTPCOutPointer; // pointer to TPCOut track param in fContent
+ Long64_t fITSOutPointer; // pointer to ITSOut track param in fContent
+ Long64_t fTRDInPointer; // pointer to TRDIn track param in fContent
+ Long64_t fTPCseedPointer; // pointer to TPCseed in fContent
+ Bool_t fBitFlags; // bit flags
+
+ // --------------------------------------------------------------------------------
+
+ Byte_t fContent[1]; // Variale size object, which contains all data
+
};
+inline Int_t AliFlatESDFriendTrack::GetTrackParam( Long64_t ptr, AliExternalTrackParam ¶m ) const
+{
+ if( ptr<0 ) return -1;
+ const AliFlatExternalTrackParam *fp = reinterpret_cast< const AliFlatExternalTrackParam* >( fContent + ptr );
+ fp->GetExternalTrackParam( param );
+}
+
+inline void AliFlatESDFriendTrack::SetTrackParam( Long64_t &ptr, const AliExternalTrackParam *p )
+{
+ if(!p ) return;
+ if( ptr<0 ){
+ ptr = fContentSize;
+ fContentSize += sizeof(AliFlatExternalTrackParam);
+ }
+ AliFlatExternalTrackParam *fp = reinterpret_cast< AliFlatExternalTrackParam* >( fContent + ptr );
+ fp->SetExternalTrackParam( p );
+}
+
+inline void AliFlatESDFriendTrack::SetTPCseed( const AliTPCseed *p )
+{
+ fTPCseedPointer = -1;
+ if(!p ) return;
+ fTPCseedPointer = fContentSize;
+ AliFlatTPCseed *fp = reinterpret_cast< AliFlatTPCseed* >( fContent + fTPCseedPointer );
+ fp->SetFromTPCseed( p );
+ fContentSize += fp->GetSize();
+}
#endif
#include "AliExternalTrackParam.h"
#include "Riostream.h"
-// _______________________________________________________________________________________________________
-AliFlatESDTrack::AliFlatESDTrack() :
- // Default constructor
- AliVVtrack(),
- fTrackParamMask(0),
- fNTPCClusters(0),
- fNITSClusters(0),
- fContentSize(0)
-{
-}
-AliFlatESDTrack::AliFlatESDTrack( AliVConstructorReinitialisationFlag f )
- :
- AliVVtrack( f ),
- fTrackParamMask(fTrackParamMask ),
- fNTPCClusters( fNTPCClusters ),
- fNITSClusters( fNITSClusters ),
- fContentSize( fContentSize )
-{
- // Constructor for reinitialisation of vtable
-}
+
// _______________________________________________________________________________________________________
Int_t AliFlatESDTrack::FillExternalTrackParam(const AliExternalTrackParam* param, UShort_t flag) {
// Fill external track parameters
- if (!param)
- return -1;
+ if (!param) return -1;
Printf(" DEBUG: CONTENT %d >> %p + 0x%07llx = %p", flag, fContent, fContentSize, fContent + fContentSize);
AliFlatExternalTrackParam * current = reinterpret_cast<AliFlatExternalTrackParam*> (fContent + fContentSize);
- current->SetAlpha(param->GetAlpha());
- current->SetX(param->GetX());
- current->SetY(param->GetY());
- current->SetZ(param->GetZ());
- current->SetSnp(param->GetSnp());
- current->SetTgl(param->GetTgl());
- current->SetSigned1Pt(param->GetSigned1Pt());
-
- const Double_t *cov = param->GetCovariance();
- for (Int_t idx = 0; idx <15; ++idx)
- current->fC[idx] = cov[idx];
-
+ current->SetExternalTrackParam( param );
fTrackParamMask |= flag;
fContentSize += sizeof(AliFlatExternalTrackParam);
return sizeof(AliFlatESDTrack) + 6*sizeof(AliFlatExternalTrackParam);
}
- size_t GetSize() { return fContent - reinterpret_cast<Byte_t*>(this) + fContentSize; }
+ size_t GetSize() const { return fContent - reinterpret_cast<const Byte_t*>(this) + fContentSize; }
private:
};
+// _______________________________________________________________________________________________________
+inline AliFlatESDTrack::AliFlatESDTrack() :
+ AliVVtrack(),
+ fTrackParamMask(0),
+ fNTPCClusters(0),
+ fNITSClusters(0),
+ fContentSize(0)
+{
+ // Default constructor
+}
+
+inline AliFlatESDTrack::AliFlatESDTrack( AliVConstructorReinitialisationFlag f )
+ :
+ AliVVtrack( f ),
+ fTrackParamMask(fTrackParamMask ),
+ fNTPCClusters( fNTPCClusters ),
+ fNITSClusters( fNITSClusters ),
+ fContentSize( fContentSize )
+{
+ // Constructor for reinitialisation of vtable
+}
+
inline UInt_t AliFlatESDTrack::CountBits(Byte_t field, UInt_t mask) {
// Count bits in field
UInt_t count = 0, reg = field & mask;
{
// Get external track parameters
const AliFlatExternalTrackParam *f = GetFlatParam ( flag );
- if( !f ) return -1;
- Float_t par[5] = { f->GetY(), f->GetZ(), f->GetSnp(), f->GetTgl(), f->GetSigned1Pt() };
- p.Set( f->GetX(), f->GetAlpha(), par, f->GetCov() );
+ if( !f ) return -1;
+ f->GetExternalTrackParam( p );
return 0;
}
Float_t GetPt() const {
Double_t pt1 = fabs( fSigned1Pt );
return (pt1>kAlmost0) ? 1./pt1 : kVeryBig;
- }
+ }
void GetExternalTrackParam( AliExternalTrackParam &p ) const;
+ void SetExternalTrackParam( const AliExternalTrackParam *p );
};
typedef struct AliFlatExternalTrackParam AliFlatExternalTrackParam;
+inline void AliFlatExternalTrackParam::GetExternalTrackParam( AliExternalTrackParam &p ) const
+{
+ // Get external track parameters
+ Float_t par[5] = { fY, fZ, fSnp, fTgl, fSigned1Pt };
+ p.Set( fX, fAlpha, par, fC );
+}
+
+inline void AliFlatExternalTrackParam::SetExternalTrackParam( const AliExternalTrackParam *p )
+{
+ // Set external track parameters
+ if( !p ) return;
+ fAlpha = p->GetAlpha();
+ fX = p->GetX();
+ fY = p->GetY();
+ fZ = p->GetZ();
+ fSnp = p->GetSnp();
+ fTgl = p->GetTgl();
+ fSigned1Pt = p->GetSigned1Pt();
+ for (Int_t idx = 0; idx <15; ++idx) fC[idx] = p->GetCovariance()[idx];
+}
+
#endif
--- /dev/null
+/* $Id$ */
+
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/**
+ * >> Flat structure representing a TPC seed <<
+ *
+ * To be used in the online and offline calibration schema.
+ *
+ *
+ * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli
+ *
+ **************************************************************************/
+
+#include "AliFlatTPCseed.h"
+#include "Riostream.h"
+
+AliFlatTPCseed::AliFlatTPCseed()
+ :
+ fContentSize(0)
+{
+ // constructor
+ fContent[0]=0;
+}
+
+void AliFlatTPCseed::Reset()
+{
+ // Reset
+}
+
+void AliFlatTPCseed::SetFromTPCseed( const AliTPCseed *p )
+{
+ // initialise from AliTPCseed
+
+}
--- /dev/null
+#ifndef ALIFLATTPCSEED_H
+#define ALIFLATTPCSEED_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice *
+ * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli */
+
+/*
+ * See implementation file for documentation
+ */
+
+
+#include "Rtypes.h"
+
+#include "AliFlatTPCCluster.h"
+#include "AliVfriendTrack.h"
+#include "AliVMisc.h"
+#include "AliFlatExternalTrackParam.h"
+#include "AliFlatTPCseed.h"
+
+class AliESDtrack;
+class AliESDfriendTrack;
+class AliExternalTrackParam;
+class AliTrackPointArray;
+class AliTPCseed;
+
+class AliFlatTPCseed
+{
+ public:
+
+ // --------------------------------------------------------------------------------
+ // -- Constructor / Destructors
+ AliFlatTPCseed();
+ ~AliFlatTPCseed() {}
+
+ // constructor and method for reinitialisation of virtual table
+ AliFlatTPCseed( AliVConstructorReinitialisationFlag );
+ void Reinitialize() { new (this) AliFlatTPCseed( AliVReinitialize ); }
+
+ // -- Set methods
+
+ void Reset();
+
+ void SetFromTPCseed( const AliTPCseed *p );
+
+
+ // --------------------------------------------------------------------------------
+ // -- Size methods
+
+ static size_t EstimateSize(){
+ return sizeof(AliFlatTPCseed) + 6*sizeof(AliFlatExternalTrackParam);
+ }
+
+ size_t GetSize() const { return fContent - reinterpret_cast<const Byte_t*>(this) + fContentSize; }
+
+ private:
+
+ AliFlatTPCseed(const AliFlatTPCseed &);
+ AliFlatTPCseed& operator=(const AliFlatTPCseed& );
+
+ // --------------------------------------------------------------------------------
+
+ ULong64_t fContentSize; // Size of this object
+
+ // --------------------------------------------------------------------------------
+
+ Byte_t fContent[1]; // Variale size object, which contains all data
+
+};
+
+
+#endif
void SetTZEROfriend(AliESDTZEROfriend * obj);
AliESDTZEROfriend *GetTZEROfriend(){ return fESDTZEROfriend; }
- void Ls(){
+ void Ls() const {
return fTracks.ls();
}
// bit manipulation for filtering
void SetSkipBit(Bool_t skip){SetBit(23,skip);}
- Bool_t TestSkipBit() {return TestBit(23);}
+ Bool_t TestSkipBit() const {return TestBit(23);}
// VfriendTrack interface
AliVfriendEvent() {}
virtual ~AliVfriendEvent() {}
- virtual Int_t GetNclustersTPC(UInt_t /*sector*/) const = 0;
- virtual Int_t GetNclustersTPCused(UInt_t /*sector*/) const = 0;
-
- //used in calibration
- virtual Bool_t TestSkipBit() const = 0;
virtual Int_t GetNumberOfTracks() const = 0;
virtual const AliVfriendTrack *GetTrack(Int_t /*i*/) const = 0;
+ virtual Int_t GetEntriesInTracks() const = 0;
+
+ // AliESDVZEROfriend *GetVZEROfriend();
+ // AliESDTZEROfriend *GetTZEROfriend();
+
+ virtual void Ls() const = 0;
+ virtual void Reset() = 0;
+
+ // bit manipulation for filtering
+ virtual void SetSkipBit(Bool_t skip) = 0;
+ virtual Bool_t TestSkipBit() const = 0;
+
+ //TPC cluster occupancy
+ virtual Int_t GetNclustersTPC(UInt_t /*sector*/) const = 0;
+ virtual Int_t GetNclustersTPCused(UInt_t /*sector*/) const = 0;
private:
- AliVfriendEvent(const AliVfriendEvent &);
- AliVfriendEvent& operator=(const AliVfriendEvent& esd);
-// ClassDef(AliVfriendEvent,0);
+ AliVfriendEvent(const AliVfriendEvent &);
+ AliVfriendEvent& operator=(const AliVfriendEvent& esd);
};
#endif
-
AliVfriendTrack(){}
// constructor for reinitialisation of vtable
AliVfriendTrack( AliVConstructorReinitialisationFlag ){}
-
virtual ~AliVfriendTrack(){}
//used in calibration
virtual Int_t GetTPCseed( AliTPCseed &) const = 0;
+
+ /*
+ Int_t GetTrackParamTPCOut( AliExternalTrackParam &p ) const { return GetExternalTrackParam( p, 0x0 ); }
+ Int_t GetTrackParamITSOut( AliExternalTrackParam &p ) const { return GetExternalTrackParam( p, 0x0 ); }
+ Int_t GetTrackParamTRDIn( AliExternalTrackParam &p ) const { return GetExternalTrackParam( p, 0x0 ); }
+ */
+
//virtual const AliVtrackPointArray *GetTrackPointArray() const {return NULL;}
- //virtual const AliVtrack * GetITSOut() const {return NULL;}
- //virtual const AliVtrack * GetTPCOut() const {return NULL;}
- //virtual const AliVtrack * GetTRDIn() const {return NULL;}
- // virtual TObject* GetCalibObject(Int_t /*index*/) const = 0;
+
+ // bit manipulation for filtering
+ virtual void SetSkipBit(Bool_t skip) = 0;
+ virtual Bool_t TestSkipBit() const = 0;
private:
AliVfriendTrack(const AliVfriendTrack &);
AliVfriendTrack& operator=(const AliVfriendTrack& esd);
- //ClassDef(AliVfriendTrack,0);
};
#endif
-
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff