}
//______________________________________________________________________________
-void AliAnalysisManager::InitInputData(AliVVevent* esdEvent, AliVVfriendEvent* esdFriend)
+void AliAnalysisManager::InitInputData(AliVVevent* esdEvent, AliVfriendEvent* esdFriend)
{
// Method to propagte to all the connected tasks the HLT event.
class AliAnalysisGrid;
class AliAnalysisStatistics;
class AliVVevent;
-class AliVVfriendEvent;
+class AliVfriendEvent;
class AliAnalysisManager : public TNamed {
void Lock();
void UnLock();
void Changed();
- void InitInputData(AliVVevent* esdEvent, AliVVfriendEvent* esdFriend);
+ void InitInputData(AliVVevent* esdEvent, AliVfriendEvent* esdFriend);
protected:
void CreateReadCache();
void ImportWrappers(TList *source);
}
-AliFlatESDEvent::AliFlatESDEvent( AliVVConstructorReinitialisationFlag f )
+AliFlatESDEvent::AliFlatESDEvent( AliVConstructorReinitialisationFlag f )
:
AliVVevent( f ),
fContentSize(fContentSize),
*/
#include "Rtypes.h"
-#include "AliVVMisc.h"
+#include "AliVMisc.h"
#include "AliVVevent.h"
#include "AliFlatESDTrack.h"
#include "AliFlatESDVertex.h"
~AliFlatESDEvent() {}
// constructor and method for reinitialisation of virtual table
- AliFlatESDEvent( AliVVConstructorReinitialisationFlag );
- void Reinitialize() { new (this) AliFlatESDEvent( AliVVReinitialize ); }
+ AliFlatESDEvent( AliVConstructorReinitialisationFlag );
+ void Reinitialize() { new (this) AliFlatESDEvent( AliVReinitialize ); }
// --------------------------------------------------------------------------------
// Interface to AliVVEvent
Int_t GetPrimaryVertexSPD( AliESDVertex &v ) const ;
Int_t GetPrimaryVertexTracks( AliESDVertex &v ) const ;
- AliVVfriendEvent* FindFriend() const { return fFriendEvent; }
+ AliVfriendEvent* FindFriend() const { return fFriendEvent; }
// --------------------------------------------------------------------------------
// Own methods
}
// _______________________________________________________________________________________________________
-AliFlatESDFriend::AliFlatESDFriend(AliFlatESDSpecialConstructorFlag f) :
+AliFlatESDFriend::AliFlatESDFriend(AliVConstructorReinitialisationFlag f) :
+ AliVfriendEvent(),
fContentSize(),
fBitFlags(),
fNTracks(),
// the vtable pointer for this AliFlatESDFriend object is already reset when this constructor is called
// we should only initialise vtable pointers for all contained objects
- if(f == AliFlatESDReinitialize){
+ if(f == AliVReinitialize){
for( int i=0; i<fNTracks; i++ ){
AliFlatESDFriendTrack *tr = GetFlatTrackNonConst(i);
if( tr ) tr->Reinitialize();
*/
#include "Rtypes.h"
-#include "AliFlatESDMisc.h"
-#include "AliVVfriendEvent.h"
+#include "AliVMisc.h"
+#include "AliVfriendEvent.h"
#include "AliFlatESDFriendTrack.h"
class AliVVVZEROfriend;
class AliVVTZEROfriend;
//_____________________________________________________________________________
-class AliFlatESDFriend : public AliVVfriendEvent {
+class AliFlatESDFriend : public AliVfriendEvent {
public:
AliFlatESDFriend();
~AliFlatESDFriend() {}
- // Implementation of virtual methods of AliVVfriend
+ // Implementation of virtual methods of AliVfriend
Int_t GetNumberOfTracks() const { return fNTracks; }
Int_t GetEntriesInTracks() const { return fNTrackEntries; }
- const AliVVfriendTrack* GetTrack(Int_t i) const {return GetFlatTrack(i); }
+ const AliVfriendTrack* GetTrack(Int_t i) const {return GetFlatTrack(i); }
AliVVVZEROfriend *GetVZEROfriend(){ return NULL; }
AliVVTZEROfriend *GetTZEROfriend(){ return NULL; }
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 AliVVfriendTrack *t) {}
- //virtual void AddTrackAt(const AliVVfriendTrack* /*t*/, Int_t /*i*/) {}
+ //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){}
void Reinitialize()
{
- new (this) AliFlatESDFriend(AliFlatESDReinitialize);
+ new (this) AliFlatESDFriend(AliVReinitialize);
}
private:
// 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(AliFlatESDSpecialConstructorFlag);
+ AliFlatESDFriend(AliVConstructorReinitialisationFlag);
AliFlatESDFriendTrack *GetFlatTrackNonConst( Int_t i ){
const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
// _______________________________________________________________________________________________________
AliFlatESDFriendTrack::AliFlatESDFriendTrack() :
- AliVVfriendTrack()
+ AliVfriendTrack()
{
// Default constructor
}
-AliFlatESDFriendTrack::AliFlatESDFriendTrack( AliVVConstructorReinitialisationFlag f ) :
-AliVVfriendTrack( f )
+AliFlatESDFriendTrack::AliFlatESDFriendTrack( AliVConstructorReinitialisationFlag f ) :
+AliVfriendTrack( f )
{
// constructor for reinitialisation of vtable
}
#include "Rtypes.h"
#include "AliFlatTPCCluster.h"
-#include "AliVVfriendTrack.h"
-#include "AliVVMisc.h"
+#include "AliVfriendTrack.h"
+#include "AliVMisc.h"
class AliESDtrack;
class AliESDfriendTrack;
class AliTrackPointArray;
class AliTPCseed;
-class AliFlatESDFriendTrack :public AliVVfriendTrack
+class AliFlatESDFriendTrack :public AliVfriendTrack
{
public:
AliFlatESDFriendTrack();
~AliFlatESDFriendTrack() {}
// constructor for reinitialisation of virtual table
- AliFlatESDFriendTrack( AliVVConstructorReinitialisationFlag );
+ AliFlatESDFriendTrack( AliVConstructorReinitialisationFlag );
- //implementation of AliVVfriendTrack methods
+ //implementation of AliVfriendTrack methods
Int_t GetTPCseed( AliTPCseed &) const {return -1;}
//AliVVTPCseed* GetTPCseed() const {return NULL;}
// own methods
- void Reinitialize() { new (this) AliFlatESDFriendTrack( AliVVReinitialize ); }
+ void Reinitialize() { new (this) AliFlatESDFriendTrack( AliVReinitialize ); }
private:
+++ /dev/null
-#include "AliFlatESDMisc.h"
-
+++ /dev/null
-#ifndef ALIFLATESDMISC_H
-#define ALIFLATESDMISC_H
-
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice *
- * Primary Authors : Steffen Weber */
-
-
-
-enum AliFlatESDSpecialConstructorFlag{AliFlatESDReinitialize};
-
-typedef enum AliFlatESDSpecialConstructorFlag AliFlatESDSpecialConstructorFlag;
-
-
-#endif
{
}
-AliFlatESDTrack::AliFlatESDTrack( AliVVConstructorReinitialisationFlag f )
+AliFlatESDTrack::AliFlatESDTrack( AliVConstructorReinitialisationFlag f )
:
AliVVtrack( f ),
fTrackParamMask(fTrackParamMask ),
*/
#include "Rtypes.h"
-#include "AliVVMisc.h"
+#include "AliVMisc.h"
#include "AliVVtrack.h"
#include "AliFlatExternalTrackParam.h"
~AliFlatESDTrack() {}
// constructor and method for reinitialisation of virtual table
- AliFlatESDTrack( AliVVConstructorReinitialisationFlag );
- void Reinitialize() { new (this) AliFlatESDTrack( AliVVReinitialize ); }
+ AliFlatESDTrack( AliVConstructorReinitialisationFlag );
+ void Reinitialize() { new (this) AliFlatESDTrack( AliVReinitialize ); }
// -------------------- AliVVtrack interface ---------------------------------
*/
#include "Rtypes.h"
-#include "AliVVMisc.h"
+#include "AliVMisc.h"
#include <string>
class AliFlatESDTrigger{
~AliFlatESDTrigger();
// constructor and method for reinitialisation of virtual table
- AliFlatESDTrigger( AliVVConstructorReinitialisationFlag );
+ AliFlatESDTrigger( AliVConstructorReinitialisationFlag );
void Reinitialize() const {} // no virtual table - do nothing
// --------------------------------------------------------------------------------
// Destructor
}
-inline AliFlatESDTrigger::AliFlatESDTrigger( AliVVConstructorReinitialisationFlag ) :
+inline AliFlatESDTrigger::AliFlatESDTrigger( AliVConstructorReinitialisationFlag ) :
fContentSize(fContentSize),
fTriggerIndex(fTriggerIndex)
{
*/
#include "Rtypes.h"
-#include "AliVVMisc.h"
+#include "AliVMisc.h"
class AliFlatESDV0
{
~AliFlatESDV0(){}
// constructor and method for reinitialisation of virtual table
- AliFlatESDV0( AliVVConstructorReinitialisationFlag ): fNegTrackID(fNegTrackID), fPosTrackID(fPosTrackID) {}
+ AliFlatESDV0( AliVConstructorReinitialisationFlag ): fNegTrackID(fNegTrackID), fPosTrackID(fPosTrackID) {}
void Reinitialize() const {} // no virtual table - do nothing
//--
*/
#include "Rtypes.h"
-#include "AliVVMisc.h"
+#include "AliVMisc.h"
#include "AliESDVertex.h"
struct AliFlatESDVertex
~AliFlatESDVertex() {}
// constructor and method for reinitialisation of virtual table
- AliFlatESDVertex( AliVVConstructorReinitialisationFlag );
+ AliFlatESDVertex( AliVConstructorReinitialisationFlag );
void Reinitialize() const {} // no virtual table - do nothing
//--
for( int i=0; i<6; i++) fCov[i] = -9999;
}
-inline AliFlatESDVertex::AliFlatESDVertex( AliVVConstructorReinitialisationFlag ):
+inline AliFlatESDVertex::AliFlatESDVertex( AliVConstructorReinitialisationFlag ):
fNContributors(fNContributors),
fChi2(fChi2)
{
*/
#include "Rtypes.h"
-#include "AliVVcluster.h"
-#include "AliFlatESDMisc.h"
+#include "AliVMisc.h"
-class AliFlatTPCCluster: public AliVVcluster
+class AliFlatTPCCluster
{
public:
void SetCharge(UShort_t charge) {fCharge = charge;}
void SetQMax(UShort_t qmax) {fQMax = qmax;}
- void Reinitialize(){
- new (this) AliFlatTPCCluster(AliFlatESDReinitialize);
- }
+ void Reinitialize(){} // do nothing
Float_t GetX() const {return fX;}
Float_t GetY() const {return fY;}
private:
- AliFlatTPCCluster(AliFlatESDSpecialConstructorFlag f): AliVVcluster(f),fX(fX),fY(fY),fZ(fZ),fPadRow(fPadRow),fSigmaY2(fSigmaY2),fSigmaZ2(fSigmaZ2),fCharge(fCharge),fQMax(fQMax){}
+ AliFlatTPCCluster(AliVConstructorReinitialisationFlag ): 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
set ( SRCS
STEERBase/AliVVevent.cxx
STEERBase/AliVVtrack.cxx
- STEERBase/AliVVfriendEvent.cxx
- STEERBase/AliVVfriendTrack.cxx
- STEERBase/AliVVkink.cxx
- STEERBase/AliVVcluster.cxx
- STEERBase/AliVVtrackPointArray.cxx
- STEERBase/AliVVtrackPoint.cxx
- STEERBase/AliVVTPCseed.cxx
STEERBase/AliVParticle.cxx
STEERBase/AliVTrack.cxx
STEERBase/AliEventplane.cxx
AliESDfriend::AliESDfriend(const AliESDfriend &f) :
TObject(f),
- AliVVfriendEvent(),
+ AliVfriendEvent(),
fTracks(f.fTracks),
fESDVZEROfriend(f.fESDVZEROfriend ? new AliESDVZEROfriend(*f.fESDVZEROfriend) : NULL),
fESDTZEROfriend(f.fESDTZEROfriend ? new AliESDTZEROfriend(*f.fESDTZEROfriend) : NULL),
#include <TClonesArray.h>
#include "AliESDfriendTrack.h"
-#include "AliVVfriendEvent.h"
+#include "AliVfriendEvent.h"
class AliESDVZEROfriend;
class AliESDTZEROfriend;
//_____________________________________________________________________________
-class AliESDfriend : public TObject, public AliVVfriendEvent {
+class AliESDfriend : public TObject, public AliVfriendEvent {
public:
AliESDfriend();
AliESDfriend(const AliESDfriend &);
#include "TObjArray.h"
#include "TClonesArray.h"
#include "AliKalmanTrack.h"
-#include "AliVVTPCseed.h"
+#include "AliVTPCseed.h"
ClassImp(AliESDfriendTrack)
AliESDfriendTrack::AliESDfriendTrack(const AliESDfriendTrack &t):
TObject(t),
-AliVVfriendTrack(),
+AliVfriendTrack(),
f1P(t.f1P),
fnMaxITScluster(t.fnMaxITScluster),
fnMaxTPCcluster(t.fnMaxTPCcluster),
Int_t AliESDfriendTrack::GetTPCseed( AliTPCseed &seed) const {
TObject* calibObject = NULL;
- AliVVTPCseed* seedP = NULL;
+ AliVTPCseed* seedP = NULL;
for (Int_t idx = 0; (calibObject = GetCalibObject(idx)); ++idx) {
- if ((seedP = dynamic_cast<AliVVTPCseed*>(calibObject))) {
+ if ((seedP = dynamic_cast<AliVTPCseed*>(calibObject))) {
seedP->CopyToTPCseed( seed );
return 0;
}
#include <TObject.h>
#include <TClonesArray.h>
#include <AliExternalTrackParam.h>
-#include "AliVVfriendTrack.h"
+#include "AliVfriendTrack.h"
#include "AliTrackPointArray.h"
class AliKalmanTrack;
//_____________________________________________________________________________
-class AliESDfriendTrack : public TObject, public AliVVfriendTrack {
+class AliESDfriendTrack : public TObject, public AliVfriendTrack {
public:
enum {
kMaxITScluster=12,
void SetSkipBit(Bool_t skip){SetBit(23,skip);}
Bool_t TestSkipBit() {return TestBit(23);}
- // VVfriendTrack interface
+ // VfriendTrack interface
Int_t GetTPCseed( AliTPCseed &) const;
#include <TObject.h>
#include "AliExternalTrackParam.h"
#include <TPDGCode.h>
-#include "AliVVkink.h"
class AliESDtrack;
-class AliESDkink : public TObject, public AliVVkink {
+class AliESDkink : public TObject {
public:
AliESDkink(); //constructor
AliESDkink(const AliESDkink &source); //constructor
//______________________________________________________________________________
-Bool_t AliTrackPointArray::GetPoint(AliVVtrackPoint &p, Int_t i) const
+Bool_t AliTrackPointArray::GetPoint(AliTrackPoint &p, Int_t i) const
{
// Get the point at position i
//
}
//______________________________________________________________________________
-Float_t AliTrackPoint::GetResidual(const AliVVtrackPoint &p, Bool_t weighted) const
+Float_t AliTrackPoint::GetResidual(const AliTrackPoint &p, Bool_t weighted) const
{
// This method calculates the track to space-point residuals. The track
// interpolation is also stored as AliTrackPoint. Using the option
}
//_____________________________________________________________________________
-Bool_t AliTrackPoint::GetPCA(const AliVVtrackPoint &p, AliVVtrackPoint &out) const
+Bool_t AliTrackPoint::GetPCA(const AliTrackPoint &p, AliTrackPoint &out) const
{
//
// Get the intersection point between this point and
#include <TObject.h>
#include <TMatrixDSym.h>
-#include "AliVVtrackPointArray.h"
-#include "AliVVtrackPoint.h"
#include "Rtypes.h"
class TGeoRotation;
-class AliTrackPoint : public AliVVtrackPoint, public TObject {
+class AliTrackPoint : public TObject {
public:
AliTrackPoint();
Int_t GetClusterType() const { return fClusterType;}
Bool_t IsExtra() const { return fIsExtra;}
- Float_t GetResidual(const AliVVtrackPoint &p, Bool_t weighted = kFALSE) const;
- Bool_t GetPCA(const AliVVtrackPoint &p, AliVVtrackPoint &out) const;
+ Float_t GetResidual(const AliTrackPoint &p, Bool_t weighted = kFALSE) const;
+ Bool_t GetPCA(const AliTrackPoint &p, AliTrackPoint &out) const;
Float_t GetAngle() const;
Bool_t GetRotMatrix(TGeoRotation& rot) const;
// cvetan.cheshkov@cern.ch 3/11/2005 //
//////////////////////////////////////////////////////////////////////////////
-class AliTrackPointArray : public TObject, public AliVVtrackPointArray {
+class AliTrackPointArray : public TObject {
public:
Int_t GetNPoints() const { return fNPoints; }
Int_t GetCovSize() const { return fSize; }
- Bool_t GetPoint(AliVVtrackPoint &p, Int_t i) const;
+ Bool_t GetPoint(AliTrackPoint &p, Int_t i) const;
// Getters for fast access to the coordinate arrays
const Float_t* GetX() const { return &fX[0]; }
const Float_t* GetY() const { return &fY[0]; }
}
//______________________________________________________________________________
-Bool_t AliHLTTestInputHandler::InitTaskInputData(AliVVevent* esdEvent, AliVVfriendEvent* friendEvent, TObjArray* arrTasks) {
+Bool_t AliHLTTestInputHandler::InitTaskInputData(AliVVevent* esdEvent, AliVfriendEvent* friendEvent, TObjArray* arrTasks) {
// Method to propagte to all the connected tasks the HLT event.
// The method gets the list of tasks from the manager
Printf("----> AliHLTTestInputHandler::InitTaskInpuData: Setting the event...");
SetVVEvent(esdEvent);
- SetVVFriendEvent(friendEvent);
+ SetVFriendEvent(friendEvent);
// set transient pointer to event inside tracks
fEvent->ConnectTracks();
Printf("----> AliHLTTestInputHandler::InitTaskInpuData: ...Event set");
class TObjArray;
class AliVVevent;
-class AliVVfriendevent;
+class AliVfriendevent;
class AliHLTTestInputHandler : public AliVEventHandler {
virtual Bool_t TerminateIO() {return kTRUE;}
// Especially needed for HLT
- Bool_t InitTaskInputData(AliVVevent* /*esdEvent*/, AliVVfriendEvent* /*friendEvent*/, TObjArray* /*arrTasks*/);
+ Bool_t InitTaskInputData(AliVVevent* /*esdEvent*/, AliVfriendEvent* /*friendEvent*/, TObjArray* /*arrTasks*/);
AliVEvent* GetEvent() const {return NULL;}
AliVVevent* GetVVEvent() const {return fEvent;}
void SetVVEvent(AliVVevent *event) {fEvent = event;}
- AliVVfriendEvent* GetVVFriendEvent() const {return fFriendEvent;}
- void SetVVFriendEvent(AliVVfriendEvent *friendEvent) {fFriendEvent = friendEvent;}
+ AliVfriendEvent* GetVFriendEvent() const {return fFriendEvent;}
+ void SetVFriendEvent(AliVfriendEvent *friendEvent) {fFriendEvent = friendEvent;}
private:
AliHLTTestInputHandler(const AliVEventHandler& handler);
AliHLTTestInputHandler& operator=(const AliVEventHandler& handler);
AliVVevent *fEvent; //! Pointer to the event
- AliVVfriendEvent *fFriendEvent; //! Pointer to the friend event
+ AliVfriendEvent *fFriendEvent; //! Pointer to the friend event
ClassDef(AliHLTTestInputHandler, 1);
};
#include "TMath.h"
#include "AliVTrack.h"
-#include "AliVVMisc.h"
+#include "AliVMisc.h"
const Double_t kVeryBig=1./kAlmost0;
const Double_t kMostProbablePt=0.35;
AliExternalTrackParam(Double_t xyz[3],Double_t pxpypz[3],
Double_t cv[21],Short_t sign);
// constructor for reinitialisation of vtable
- AliExternalTrackParam( AliVVConstructorReinitialisationFlag f) :AliVTrack(f), fX(), fAlpha(){}
- void Reinitialize() { new (this) AliExternalTrackParam( AliVVReinitialize ); }
+ AliExternalTrackParam( AliVConstructorReinitialisationFlag f) :AliVTrack(f), fX(), fAlpha(){}
+ void Reinitialize() { new (this) AliExternalTrackParam( AliVReinitialize ); }
virtual ~AliExternalTrackParam(){}
void CopyFromVTrack(const AliVTrack *vTrack);
UInt_t GetTimeStamp() const { return 0; }
UInt_t GetEventSpecie() const { return 0; }
ULong64_t GetTriggerMaskNext50() const { return 0; }
- AliVVfriendEvent* FindFriend() const { return 0; }
+ AliVfriendEvent* FindFriend() const { return 0; }
Int_t GetNumberOfKinks() const { return 0; }
class TObjArray;
class AliVVevent;
class AliVEvent;
-class AliVVfriendEvent;
+class AliVfriendEvent;
class AliVEventHandler : public TNamed {
virtual TList *GetUserInfo() const {return 0x0;};
// HLT
- virtual Bool_t InitTaskInputData(AliVVevent* /*event*/, AliVVfriendEvent* /*esdFriend*/, TObjArray* /*arrTasks*/) {return kTRUE;};
+ virtual Bool_t InitTaskInputData(AliVVevent* /*event*/, AliVfriendEvent* /*esdFriend*/, TObjArray* /*arrTasks*/) {return kTRUE;};
virtual AliVEvent* GetEvent() const {return 0x0;};
virtual AliVVevent* GetVVEvent() const {return 0x0;};
- virtual AliVVfriendEvent* GetVVFriendEvent() const {return 0x0;};
+ virtual AliVfriendEvent* GetVFriendEvent() const {return 0x0;};
private :
ClassDef(AliVEventHandler, 1);
-#ifndef ALIVVMISC_H
-#define ALIVVMISC_H
+#ifndef ALIVMISC_H
+#define ALIVMISC_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice *
-enum AliVVConstructorReinitialisationFlag{AliVVReinitialize};
+enum AliVConstructorReinitialisationFlag{AliVReinitialize};
-typedef enum AliVVConstructorReinitialisationFlag AliVVConstructorReinitialisationFlag;
+typedef enum AliVConstructorReinitialisationFlag AliVConstructorReinitialisationFlag;
#endif
#include <Rtypes.h>
#include <TObject.h>
-#include "AliVVMisc.h"
+#include "AliVMisc.h"
#include <float.h>
AliVParticle& operator=(const AliVParticle& vPart);
// constructor for reinitialisation of vtable
- AliVParticle( AliVVConstructorReinitialisationFlag ) :TObject(*this){}
+ AliVParticle( AliVConstructorReinitialisationFlag ) :TObject(){}
// kinematics
virtual Double_t Px() const = 0;
-#ifndef ALIVVTPCSEED_H
-#define ALIVVTPCSEED_H
+#ifndef ALIVTPCSEED_H
+#define ALIVTPCSEED_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice *
#include "Rtypes.h"
class AliTPCseed;
-class AliVVTPCseed {
+class AliVTPCseed {
public:
- AliVVTPCseed() {}
- virtual ~AliVVTPCseed() {}
+ AliVTPCseed() {}
+ virtual ~AliVTPCseed() {}
virtual void CopyToTPCseed( AliTPCseed &) const = 0;
- //ClassDef(AliVVTPCseed, 0);
};
#endif
#include "AliVParticle.h"
#include "AliPID.h"
-#include "AliVVMisc.h"
+#include "AliVMisc.h"
class AliVEvent;
class AliVVertex;
AliVTrack(const AliVTrack& vTrack);
AliVTrack& operator=(const AliVTrack& vTrack);
// constructor for reinitialisation of vtable
- AliVTrack( AliVVConstructorReinitialisationFlag f) :AliVParticle(f){}
+ AliVTrack( AliVConstructorReinitialisationFlag f) :AliVParticle(f){}
virtual const AliVEvent* GetEvent() const {return 0;}
virtual Int_t GetID() const = 0;
+++ /dev/null
-#include "AliVVTPCseed.h"
+++ /dev/null
-#include "AliVVTRDseed.h"
+++ /dev/null
-#ifndef ALIVVTRDSEED_H
-#define ALIVVTRDSEED_H
-
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice *
- * Primary Author: Mikolaj Krzewicki, mkrzewic@cern.ch
- */
-
-class AliVVTRDseed {
- public:
- AliVVTRDseed();
- virtual ~AliVVTRDseed();
- //ClassDef(AliVVTRDseed, 0);
-};
-
-#endif
+++ /dev/null
-#include "AliVVcluster.h"
+++ /dev/null
-#ifndef ALIVVCLUSTER_H
-#define ALIVVCLUSTER_H
-
-#include "Rtypes.h"
-
-class AliVVcluster
-{
- public:
- AliVVcluster() {}
- AliVVcluster(Bool_t) {}
- virtual ~AliVVcluster() {}
- virtual void SetX(Float_t /*x*/) {}
- virtual void SetY(Float_t /*y*/) {}
- virtual void SetZ(Float_t /*z*/) {}
- virtual void SetPadRow(Short_t /*padrow*/) {}
- virtual void SetSigmaY2(Float_t /*sigmaY2*/) {}
- virtual void SetSigmaZ2(Float_t /*sigmaZ2*/) {}
- virtual void SetCharge(UShort_t /*charge*/) {}
- virtual void SetQMax(UShort_t /*qmax*/) {}
-
- virtual Float_t GetX() const {return 0.;}
- virtual Float_t GetY() const {return 0.;}
- virtual Float_t GetZ() const {return 0.;}
- virtual UShort_t GetPadRow() const {return 0;}
- virtual Float_t GetSigmaY2() const {return 0.;}
- virtual Float_t GetSigmaZ2() const {return 0.;}
- virtual UShort_t GetCharge() const {return 0;}
- virtual UShort_t GetQMax() const {return 0;}
-};
-#endif
*/
#include "Rtypes.h"
#include "TString.h"
-#include "AliVVMisc.h"
+#include "AliVMisc.h"
class TList;
//class AliVVvertex;
class AliVVtrack;
class AliMultiplicity;
-class AliVVfriendEvent;
+class AliVfriendEvent;
class AliESDkink;
class TTree;
AliVVevent() {}
// constructor and method for reinitialisation of virtual table
- AliVVevent( AliVVConstructorReinitialisationFlag ){}
+ AliVVevent( AliVConstructorReinitialisationFlag ){}
protected:
virtual AliESDkink* GetKink(Int_t /*i*/) const = 0;
//virtual AliVVtrack* GetV0(Int_t /*i*/) const = 0;
- virtual AliVVfriendEvent* FindFriend() const = 0;
+ virtual AliVfriendEvent* FindFriend() const = 0;
// some ESD interfaces, not yet implemented in flat esd (may be not needed, may be need some changes)
+++ /dev/null
-#include "AliVVfriendEvent.h"
+++ /dev/null
-#include "AliVVfriendTrack.h"
+++ /dev/null
-#ifndef ALIVVFRIENDTRACK_H
-#define ALIVVFRIENDTRACK_H
-
-//_____________________________________________________________________________
-#include "AliVVMisc.h"
-
-#include "Rtypes.h"
-class AliTPCseed;
-class AliVVtrackPointArray;
-
-//_____________________________________________________________________________
-class AliVVfriendTrack {
-public:
-
- AliVVfriendTrack(){}
- // constructor for reinitialisation of vtable
- AliVVfriendTrack( AliVVConstructorReinitialisationFlag ){}
-
- virtual ~AliVVfriendTrack(){}
-
- //used in calibration
-
- 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 &);
- AliVVfriendTrack& operator=(const AliVVfriendTrack& esd);
-
- //ClassDef(AliVVfriendTrack,0);
-};
-
-#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. *
- **************************************************************************/
-
-#include "AliVVkink.h"
-
-
+++ /dev/null
-#ifndef ALIVVkink_H
-#define ALIVVkink_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 */
-
-/**
- * >> interface class <<
- */
-
-class AliVVkink
-{
- public:
- virtual ~AliVVkink() {}
-
- // ClassDef(AliVVkink, 0) // base class for kink data
-
-};
-
-#endif
*/
#include "Rtypes.h"
-#include "AliVVMisc.h"
+#include "AliVMisc.h"
class AliExternalTrackParam;
class AliVVtrack {
virtual ~AliVVtrack() {}
// constructor and method for reinitialisation of virtual table
- AliVVtrack( AliVVConstructorReinitialisationFlag ) {}
- void Reinitialize() { new (this) AliVVtrack( AliVVReinitialize ); }
+ AliVVtrack( AliVConstructorReinitialisationFlag ) {}
+ void Reinitialize() { new (this) AliVVtrack( AliVReinitialize ); }
// --------------------------------------------------------------------------------
+++ /dev/null
-#include "AliVVtrackPoint.h"
-
+++ /dev/null
-#ifndef ALIVVTRACKPOINT_H
-#define ALIVVTRACKPOINT_H
-
-#include "Rtypes.h"
-class TGeoRotation;
-class AliTrackPoint;
-
-
-class AliVVtrackPoint {
- public:
- AliVVtrackPoint() {}
- virtual ~AliVVtrackPoint() {}
-
-
- virtual void SetXYZ(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/, const Float_t *cov = 0) {if (cov) return;}
- virtual void SetXYZ(const Float_t* /*xyz*/, const Float_t *cov = 0) {if (cov) return;}
- virtual void SetCov(const Float_t* /*cov*/) {}
- virtual void SetVolumeID(UShort_t /*volid*/) {}
- virtual void SetCharge(Float_t /*charge*/) {}
- virtual void SetDriftTime(Float_t /*time*/) {}
- virtual void SetChargeRatio(Float_t /*ratio*/) {}
- virtual void SetClusterType(Int_t /*clutype*/) {}
- virtual void SetExtra(Bool_t flag=kTRUE) {if (flag) return;}
-
- virtual Float_t GetX() const { return 0.; }
- virtual Float_t GetY() const { return 0.; }
- virtual Float_t GetZ() const { return 0.; }
- virtual void GetXYZ(Float_t* /*xyz*/, Float_t* cov = 0) const {if (cov) return;}
- virtual const Float_t* GetCov() const { return NULL; }
- virtual UShort_t GetVolumeID() const { return 0; }
- virtual Float_t GetCharge() const { return 0.; }
- virtual Float_t GetDriftTime() const { return 0.;}
- virtual Float_t GetChargeRatio() const { return 0.;}
- virtual Int_t GetClusterType() const { return 0;}
- virtual Bool_t IsExtra() const { return kFALSE;}
-
- virtual Float_t GetResidual(const AliVVtrackPoint& /*p*/, Bool_t weighted = kFALSE) const {if (weighted) return 0.; else return 0.;}
- virtual Bool_t GetPCA(const AliVVtrackPoint& /*p*/, AliVVtrackPoint& /*out*/) const {return kFALSE;}
-
- virtual Float_t GetAngle() const {return 0.;}
- virtual Bool_t GetRotMatrix(TGeoRotation& /*rot*/) const {return kFALSE;}
- //virtual void SetAlignCovMatrix(const TMatrixDSym& /*alignparmtrx*/) {}
-
- //virtual AliTrackPoint& Rotate(Float_t /*alpha*/) const {return *this;}
- //virtual AliTrackPoint& MasterToLocal() const {return *this;}
-
- virtual void Print(Option_t*) const {}
-
- //ClassDef(AliVVtrackPoint, 0);
-};
-
-#endif
+++ /dev/null
-#include "AliVVtrackPointArray.h"
-
+++ /dev/null
-#ifndef ALIVVTRACKPOINTARRAY_H
-#define ALIVVTRACKPOINTARRAY_H
-
-#include "Rtypes.h"
-
-#include "AliVVtrackPoint.h"
-
-class AliVVtrackPointArray {
- public:
- AliVVtrackPointArray() {}
- virtual ~AliVVtrackPointArray() {}
- virtual Int_t GetNPoints() const {return 0;}
- virtual Bool_t GetPoint(AliVVtrackPoint& /*p*/, Int_t /*i*/) const =0 ;
-
- //ClassDef(AliVVtrackPointArray, 0);
-};
-
-#endif
-#ifndef ALIVVFRIENDEVENT_H
-#define ALIVVFRIENDEVENT_H
+#ifndef ALIVFRIENDEVENT_H
+#define ALIVFRIENDEVENT_H
#include "Rtypes.h"
-class AliVVfriendTrack;
+class AliVfriendTrack;
//_____________________________________________________________________________
-class AliVVfriendEvent {
+class AliVfriendEvent {
public:
- AliVVfriendEvent() {}
- virtual ~AliVVfriendEvent() {}
+ 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 AliVVfriendTrack *GetTrack(Int_t /*i*/) const = 0;
+ virtual const AliVfriendTrack *GetTrack(Int_t /*i*/) const = 0;
private:
- AliVVfriendEvent(const AliVVfriendEvent &);
- AliVVfriendEvent& operator=(const AliVVfriendEvent& esd);
+ AliVfriendEvent(const AliVfriendEvent &);
+ AliVfriendEvent& operator=(const AliVfriendEvent& esd);
-// ClassDef(AliVVfriendEvent,0);
+// ClassDef(AliVfriendEvent,0);
};
#endif
--- /dev/null
+#ifndef ALIVFRIENDTRACK_H
+#define ALIVFRIENDTRACK_H
+
+//_____________________________________________________________________________
+#include "AliVMisc.h"
+
+#include "Rtypes.h"
+class AliTPCseed;
+class AliVVtrackPointArray;
+
+//_____________________________________________________________________________
+class AliVfriendTrack {
+public:
+
+ AliVfriendTrack(){}
+ // constructor for reinitialisation of vtable
+ AliVfriendTrack( AliVConstructorReinitialisationFlag ){}
+
+ virtual ~AliVfriendTrack(){}
+
+ //used in calibration
+
+ virtual Int_t GetTPCseed( AliTPCseed &) const = 0;
+ //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;
+
+private:
+ AliVfriendTrack(const AliVfriendTrack &);
+ AliVfriendTrack& operator=(const AliVfriendTrack& esd);
+
+ //ClassDef(AliVfriendTrack,0);
+};
+
+#endif
+
+
#pragma link C++ class AliVVevent+;
#pragma link C++ class AliVVtrack+;
-#pragma link C++ class AliVVfriendEvent+;
-#pragma link C++ class AliVVfriendTrack+;
-#pragma link C++ class AliVVkink+;
-#pragma link C++ class AliVVcluster+;
-#pragma link C++ class AliVVtrackPointArray+;
-#pragma link C++ class AliVVtrackPoint+;
-#pragma link C++ class AliVVTPCseed+;
#endif
#include "AliVEventHandler.h"
#include "AliTPCseed.h"
#include "AliTPCclusterMI.h"
-#include "AliVVfriendEvent.h"
-#include "AliVVfriendTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
#include "AliAnalysisTaskPt.h"
//fESD = dynamic_cast<AliESDEvent*>(esdH->GetEvent());
fESD = esdH->GetVVEvent();
if (fUseFriends){
- fESDfriend = esdH->GetVVFriendEvent();
+ fESDfriend = esdH->GetVFriendEvent();
}
}
if (!fESD) {
// Friend Track loop
for (Int_t iFriend = 0; iFriend < nESDfriendtracks; iFriend++) {
//Printf("Getting friend %d", iFriend);
- const AliVVfriendTrack* friendTrack = fESDfriend->GetTrack(iFriend);
+ const AliVfriendTrack* friendTrack = fESDfriend->GetTrack(iFriend);
if (!friendTrack) {
Printf("ERROR: Could not receive track %d", iFriend);
continue;
class TH1F;
class AliESDEvent;
-class AliVVfriendEvent;
+class AliVfriendEvent;
class AliVVevent;
class AliESDtrackCuts;
class TList;
private:
AliVVevent* fESD; // ESD object
- AliVVfriendEvent* fESDfriend; // ESD friend object
+ AliVfriendEvent* fESDfriend; // ESD friend object
TH1F* fHistPt; // Pt spectrum
AliESDtrackCuts* fCuts; // cuts
Int_t fEv;
#include "AliTPCtrack.h"
#include "AliComplexCluster.h"
#include "AliPID.h"
-#include "AliVVTPCseed.h"
+#include "AliVTPCseed.h"
class TFile;
class AliTPCParam;
class AliTPCCalPad;
class TClonesArray;
-class AliTPCseed : public AliTPCtrack, public AliVVTPCseed {
+class AliTPCseed : public AliTPCtrack, public AliVTPCseed {
public:
AliTPCseed();
virtual ~AliTPCseed();
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff