// -- Variable Size Object
Byte_t fContent[1]; // Variale size object, which contains all data
+
+ ClassDef(AliFlatESDEvent,0)
};
// Inline implementations
// -- Variable Size Object
Byte_t fContent[1]; // Variale size object, which contains all data
+
+ ClassDef(AliFlatESDFriend,0)
};
//virtual const AliVtrackPointArray *GetTrackPointArray() const {return NULL;}
+ TObject* GetCalibObject(Int_t) const {return NULL;}
+ const AliExternalTrackParam* GetTPCOut() const {return NULL;}
+ const AliExternalTrackParam* GetITSOut() const {return NULL;}
+
// bit manipulation for filtering
Byte_t fContent[1]; // Variale size object, which contains all data
+ ClassDef(AliFlatESDFriendTrack, 0)
+
};
inline Int_t AliFlatESDFriendTrack::GetTrackParam( Long64_t ptr, AliExternalTrackParam ¶m ) const
// -- Variable Size Object
Byte_t fContent[1]; // Variale size object, which contains all data
+ ClassDef(AliFlatESDTrack,0)
+
};
// _______________________________________________________________________________________________________
const AliESDVertex *GetPrimaryVertex() const;
+ //getters for calibration
+ Int_t GetPrimaryVertex (AliESDVertex &v) const {
+ if(!GetPrimaryVertex()) return -1;
+ v=*GetPrimaryVertex();
+ return 0;
+ }
+
+ Int_t GetPrimaryVertexTPC (AliESDVertex &v) const {
+ if(!GetPrimaryVertexTPC()) return -1;
+ v=*GetPrimaryVertexTPC();
+ return 0;
+ }
+
+ Int_t GetPrimaryVertexSPD (AliESDVertex &v) const {
+ if(!GetPrimaryVertexSPD()) return -1;
+ v=*GetPrimaryVertexSPD();
+ return 0;
+ }
+
+ Int_t GetPrimaryVertexTracks (AliESDVertex &v) const {
+ if(!GetPrimaryVertexTracks()) return -1;
+ v=*GetPrimaryVertexTracks();
+ return 0;
+ }
void SetTOFHeader(const AliTOFHeader * tofEventTime);
AliESDv0 *GetV0(Int_t i) const {
return (AliESDv0*)(fV0s?fV0s->At(i):0x0);
}
+
+ Int_t GetV0(AliESDv0 &v0dum, Int_t i) const {
+ if(!GetV0(i)) return -1;
+ v0dum=*GetV0(i);
+ return 0;}
+
Int_t AddV0(const AliESDv0 *v);
AliESDcascade *GetCascade(Int_t i) const {
private:
AliESDfriendTrack &operator=(const AliESDfriendTrack & /* t */) {return *this;}
- ClassDef(AliESDfriendTrack,6) //ESD friend track
+ ClassDef(AliESDfriendTrack,7) //ESD friend track
};
#endif
class AliVZDC;
class AliVMFT; // AU
class AliESDkink;
+class AliESDv0;
+class AliESDVertex;
+class AliVTrack;
class AliVEvent : public TObject {
private:
// disable some methods from AliVEvent interface
- UInt_t GetTimeStamp() const { return 0; }
- UInt_t GetEventSpecie() const { return 0; }
ULong64_t GetTriggerMaskNext50() const { return 0; }
- AliVfriendEvent* FindFriend() const { return 0; }
-
- Int_t GetNumberOfKinks() const { return 0; }
-
- AliESDkink* GetKink(Int_t /*i*/) const { return NULL; }
public:
enum EOfflineTriggerTypes {
// Tracks
virtual AliVParticle *GetTrack(Int_t i) const = 0;
+ virtual AliVTrack *GetVTrack(Int_t /*i*/) const {return NULL;}
//virtual Int_t AddTrack(const AliVParticle *t) = 0;
virtual Int_t GetNumberOfTracks() const = 0;
virtual Int_t GetNumberOfV0s() const = 0;
const TGeoHMatrix* GetEMCALMatrix(Int_t /*i*/) const {return NULL;}
virtual AliVCaloTrigger *GetCaloTrigger(TString /*calo*/) const {return NULL;}
-
- // Primary vertex
- virtual const AliVVertex *GetPrimaryVertex() const {return 0x0;}
virtual Bool_t IsPileupFromSPD(Int_t /*minContributors*/,
Double_t /*minZdist*/,
Double_t /*nSigmaZdist*/,
virtual AliVTrdTrack* GetTrdTrack(Int_t /* iTrack */) const { return 0x0; }
virtual Int_t GetNumberOfESDTracks() const { return 0; }
+ virtual Int_t GetEventNumberInFile() const {return 0;}
+
+ //used in calibration:
+ virtual Int_t GetV0(AliESDv0&, Int_t /*iv0*/) const {return 0;}
+ virtual UInt_t GetTimeStamp() const { return 0; }
+ virtual AliVfriendEvent* FindFriend() const { return 0; }
+ virtual UInt_t GetEventSpecie() const { return 0; }
+ virtual AliESDkink* GetKink(Int_t /*i*/) const { return NULL; }
+ virtual Int_t GetNumberOfKinks() const { return 0; }
+
+ // Primary vertex
+ virtual const AliVVertex *GetPrimaryVertex() const {return 0x0;}
+ //virtual const AliVVertex *GetPrimaryVertexSPD() const {return 0x0;}
+ //virtual const AliVVertex *GetPrimaryVertexTPC() const {return 0x0;}
+ //virtual const AliVVertex *GetPrimaryVertexTracks() const {return 0x0;}
+
+ virtual Int_t GetPrimaryVertex( AliESDVertex & ) const {return 0;}
+ virtual Int_t GetPrimaryVertexTPC( AliESDVertex & ) const {return 0;}
+ virtual Int_t GetPrimaryVertexSPD( AliESDVertex & ) const {return 0;}
+ virtual Int_t GetPrimaryVertexTracks( AliESDVertex & ) const {return 0;}
virtual void ConnectTracks() {}
virtual const AliDetectorPID* GetDetectorPID() const { return 0x0; }
virtual Double_t GetTRDchi2() const { return -1;}
virtual Int_t GetNumberOfClusters() const {return 0;}
+
+ virtual Float_t GetTPCCrossedRows() const {return 0;}
+ virtual void GetImpactParameters(Float_t [], Float_t []) const {;}
+ virtual void GetImpactParameters(Float_t &/*&xy*/,Float_t &/*&z*/) const {;}
+ virtual void GetImpactParametersTPC(Float_t &/*&xy*/,Float_t &/*&z*/) const {;}
+ virtual void GetImpactParametersTPC(Float_t [] /*p[2]*/, Float_t [] /*cov[3]*/) const {;}
virtual Int_t GetEMCALcluster() const {return kEMCALNoMatch;}
virtual void SetEMCALcluster(Int_t) {;}
virtual const AliExternalTrackParam * GetInnerParam() const { return NULL;}
virtual const AliExternalTrackParam * GetOuterParam() const { return NULL;}
virtual const AliExternalTrackParam * GetTPCInnerParam() const { return NULL;}
+ virtual const AliExternalTrackParam * GetConstrainedParam() 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 Int_t GetTrackParamCp ( AliExternalTrackParam& ) const {return 0;}
virtual Int_t GetTrackParamITSOut ( AliExternalTrackParam& ) const {return 0;}
+ virtual Int_t GetKinkIndex(Int_t /*i*/) const { return 0;}
+ virtual Double_t GetSigned1Pt() const { return 0;}
+ virtual Bool_t IsOn(Int_t /*mask*/) const {return 0;}
+ virtual Double_t GetX() const {return 0;}
+ virtual Double_t GetY() const {return 0;}
+ virtual Double_t GetZ() const {return 0;}
+ virtual const Double_t *GetParameter() const {return 0;}
+ virtual Double_t GetAlpha() const {return 0;}
+ virtual UShort_t GetTPCncls(Int_t /*row0*/=0, Int_t /*row1*/=159) const {return 0;}
+ virtual Double_t GetTOFsignalDz() const {return 0;}
+ virtual Double_t GetP() const {return 0;}
+ virtual void GetDirection(Double_t []) const {;}
+ virtual Double_t GetLinearD(Double_t /*xv*/, Double_t /*yv*/) const {return 0;}
+ virtual void GetDZ(Double_t /*x*/,Double_t /*y*/,Double_t /*z*/,Double_t /*b*/,Float_t [] /*dz[2]*/) const {;}
+ virtual Double_t GetTgl() const {return 0;}
+ virtual Char_t GetITSclusters(Int_t */**idx*/) const {return 0;}
+ virtual UChar_t GetTRDclusters(Int_t */**idx*/) const {return 0;}
+
+
ClassDef(AliVTrack,1) // base class for tracks
};
#include "Rtypes.h"
class AliTPCseed;
class AliVVtrackPointArray;
+class AliExternalTrackParam;
+class AliTrackPointArray;
//_____________________________________________________________________________
class AliVfriendTrack {
//used in calibration
virtual Int_t GetTPCseed( AliTPCseed &) const = 0;
+ virtual TObject* GetCalibObject(Int_t /*index*/) const = 0;
+
+ virtual const AliExternalTrackParam* GetTPCOut() const = 0;
+ virtual const AliExternalTrackParam * GetITSOut() const = 0;
/*
Int_t GetTrackParamTPCOut( 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 AliTrackPointArray *GetTrackPointArray() const {return NULL ;}
// bit manipulation for filtering
virtual void SetSkipBit(Bool_t skip) = 0;
#include "AliESDfriendTrack.h"
#include "AliTPCseed.h"
#include "AliESDInputHandler.h"
+
+#include "AliVEvent.h"
+#include "AliVfriendEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendTrack.h"
+#include "AliVEventHandler.h"
+
#include "AliAnalysisManager.h"
#include "TFile.h"
#include "TSystem.h"
AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib()
:AliAnalysisTask(),
fCalibJobs(0),
- fESD(0),
- fESDfriend(0),
+ fEvent(0),
+ fEventFriend(0),
fDebugOutputPath("")
{
//
AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib(const char *name)
:AliAnalysisTask(name,""),
fCalibJobs(0),
- fESD(0),
- fESDfriend(0),
+ fEvent(0),
+ fEventFriend(0),
fDebugOutputPath("")
{
//
//
// Exec function
// Loop over tracks and call Process function
- if (!fESD) {
- //Printf("ERROR: fESD not available");
+ //Printf("AliTPCAnalysisTaskcalib::Exec()...");
+
+ if (!fEvent) {
+ Printf("ERROR AliTPCAnalysisTaskcalib::Exec(): fEvent not available");
return;
}
- fESDfriend=static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));
+ fEventFriend=fEvent->FindFriend();
//fESDfriend=fESD->FindFriend();
- Int_t n=fESD->GetNumberOfTracks();
- Process(fESD);
- if (!fESDfriend) {
- //Printf("ERROR: fESDfriend not available");
+ Int_t n=fEvent->GetNumberOfTracks();
+ Process(fEvent);
+ if (!fEventFriend) {
+ //Printf("ERROR AliTPCAnalysisTaskcalib::Exec(): fEventFriend not available");
return;
}
- if (fESDfriend->TestSkipBit()) return;
+ if (fEventFriend->TestSkipBit()) return;
//
- Int_t run = fESD->GetRunNumber();
+ Int_t run = fEvent->GetRunNumber();
for (Int_t i=0;i<n;++i) {
- AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(i);
- AliESDtrack *track=fESD->GetTrack(i);
+ const AliVfriendTrack *friendTrack=fEventFriend->GetTrack(i);
+ AliVTrack *track=fEvent->GetVTrack(i);
TObject *calibObject=0;
AliTPCseed *seed=0;
if (!friendTrack) continue;
//Printf("ERROR: Could not read chain from input slot 0");
}
else {
- AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
+ //AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
+ AliVEventHandler *esdH = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
if (!esdH) {
- //Printf("ERROR: Could not get ESDInputHandler");
+ Printf("ERROR: Could not get ESDInputHandler");
}
else {
- fESD = esdH->GetEvent();
+ fEvent = esdH->GetEvent();
//Printf("*** CONNECTED NEW EVENT ****");
}
}
}
-void AliTPCAnalysisTaskcalib::Process(AliESDEvent *event) {
+void AliTPCAnalysisTaskcalib::Process(AliVEvent *event) {
//
// Process ESD event
//
+ //Printf("AliTPCAnalysisTaskcalib::Process(event)...");
AliTPCcalibBase *job=0;
Int_t njobs = fCalibJobs->GetEntriesFast();
for (Int_t i=0;i<njobs;i++){
//
// Process TPC track
//
+ //Printf("AliTPCAnalysisTaskcalib::Process(TPC track)...");
AliTPCcalibBase *job=0;
Int_t njobs = fCalibJobs->GetEntriesFast();
for (Int_t i=0;i<njobs;i++){
}
}
-void AliTPCAnalysisTaskcalib::Process(AliESDtrack *track, Int_t run) {
+void AliTPCAnalysisTaskcalib::Process(AliVTrack *track, Int_t run) {
//
// Process ESD track
//
+ //Printf("AliTPCAnalysisTaskcalib::Process(ESD track)...");
AliTPCcalibBase *job=0;
Int_t njobs = fCalibJobs->GetEntriesFast();
for (Int_t i=0;i<njobs;i++){
#include "AliAnalysisTask.h"
#include "TObjArray.h"
#include "AliTPCcalibBase.h"
-class AliESDEvent;
-class AliESDtrack;
-class AliESDfriend;
+//class AliESDEvent;
+//class AliESDtrack;
+//class AliESDfriend;
+class AliVEvent;
+class AliVTrack;
+class AliVfriendEvent;
+
class AliTPCseed;
class AliTPCAnalysisTaskcalib:public AliAnalysisTask {
virtual void FinishTaskOutput();
void SetDebugOuputhPath(const char * name){fDebugOutputPath=name;}
protected:
- virtual void Process(AliESDEvent *event);
+ virtual void Process(AliVEvent *event);
virtual void Process(AliTPCseed *track);
- virtual void Process(AliESDtrack *track, Int_t run);
+ virtual void Process(AliVTrack *track, Int_t run);
virtual Long64_t Merge(TCollection *li);
virtual void Analyze();
void RegisterDebugOutput();
private:
TObjArray *fCalibJobs; // array of calibration objects - WE ARE NOT OWNER?
- AliESDEvent *fESD; //! current esd
- AliESDfriend *fESDfriend; //! current esd friend
+ AliVEvent *fEvent; //! current event
+ AliVfriendEvent *fEventFriend; //! current event friend
TString fDebugOutputPath; // debug output path
AliTPCAnalysisTaskcalib(const AliTPCAnalysisTaskcalib&);
AliTPCAnalysisTaskcalib& operator=(const AliTPCAnalysisTaskcalib&);
#include "AliTrackPointArray.h"
#include "AliExternalTrackParam.h"
-#include "AliESDEvent.h"
-#include "AliESDfriend.h"
+//#include "AliESDEvent.h"
+//#include "AliESDfriend.h"
#include "AliESDtrack.h"
+#include "AliVEvent.h"
+#include "AliVfriendEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendTrack.h"
+#include "AliESDVertex.h"
+
#include "AliTPCTracklet.h"
#include "TH1D.h"
#include "TH2F.h"
}
-void AliTPCcalibAlign::Process(AliESDEvent *event) {
+void AliTPCcalibAlign::Process(AliVEvent *event) {
//
// Process pairs of cosmic tracks
//
ExportTrackPoints(event); // export track points for external calibration
const Int_t kMaxTracks =6;
const Int_t kminCl = 40;
- AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!eESDfriend) return;
- if (eESDfriend->TestSkipBit()) return;
+ //AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ AliVfriendEvent *friendEvent=event->FindFriend();
+ if (!friendEvent) return;
+ if (friendEvent->TestSkipBit()) return;
Int_t ntracks=event->GetNumberOfTracks();
Float_t dca0[2];
Float_t dca1[2];
// process seeds
//
for (Int_t i0=0;i0<ntracks;++i0) {
- AliESDtrack *track0 = event->GetTrack(i0);
- AliESDfriendTrack *friendTrack = 0;
+ AliVTrack *track0 = event->GetVTrack(i0);
+ //AliESDfriendTrack *friendTrack = 0;
TObject *calibObject=0;
AliTPCseed *seed0 = 0;
//
- friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(i0);;
+ //friendTrack = (AliESDfriendTrack *)friendEvent->GetTrack(i0);;
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i0);;
if (!friendTrack) continue;
for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
if ((seed0=dynamic_cast<AliTPCseed*>(calibObject))) break;
}
if (!seed0) continue;
fCurrentTrack=track0;
- fCurrentFriendTrack=friendTrack;
+ fCurrentFriendTrack=const_cast<AliVfriendTrack*>(friendTrack);
fCurrentSeed=seed0;
- fCurrentEvent=event;
+ fCurrentEvent= event;
Double_t scalept= TMath::Min(1./TMath::Abs(track0->GetParameter()[4]),2.);
Bool_t isSelected = (TMath::Exp(2*scalept)>kptDownscale*gRandom->Rndm());
if (isSelected) ProcessSeed(seed0);
//
//select pairs - for alignment
for (Int_t i0=0;i0<ntracks;++i0) {
- AliESDtrack *track0 = event->GetTrack(i0);
+ AliVTrack *track0 = event->GetVTrack(i0);
// if (track0->GetTPCNcls()<kminCl) continue;
track0->GetImpactParameters(dca0[0],dca0[1]);
// if (TMath::Abs(dca0[0])>30) continue;
//
for (Int_t i1=0;i1<ntracks;++i1) {
if (i0==i1) continue;
- AliESDtrack *track1 = event->GetTrack(i1);
+ AliVTrack *track1 = event->GetVTrack(i1);
// if (track1->GetTPCNcls()<kminCl) continue;
track1->GetImpactParameters(dca1[0],dca1[1]);
// fast cuts on dca and theta
// if (TMath::Abs(dca1[1]-dca0[1])>15) continue;
if (TMath::Abs(track0->GetParameter()[3]+track1->GetParameter()[3])>0.1) continue;
//
- AliESDfriendTrack *friendTrack = 0;
+ //AliESDfriendTrack *friendTrack = 0; ///!!! then it was used twice, cannot be const pointer
TObject *calibObject=0;
AliTPCseed *seed0 = 0,*seed1=0;
//
- friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(i0);;
- if (!friendTrack) continue;
- for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
+ const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(i0);;
+ if (!friendTrack0) continue;
+ for (Int_t l=0;(calibObject=friendTrack0->GetCalibObject(l));++l) {
if ((seed0=dynamic_cast<AliTPCseed*>(calibObject))) break;
}
- friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(i1);;
- if (!friendTrack) continue;
- for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
+ const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(i1);;
+ if (!friendTrack1) continue;
+ for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
if ((seed1=dynamic_cast<AliTPCseed*>(calibObject))) break;
}
if (!seed0) continue;
}
}
-void AliTPCcalibAlign::ExportTrackPoints(AliESDEvent *event){
+void AliTPCcalibAlign::ExportTrackPoints(AliVEvent *event){
//
// Export track points for alignment - calibration
// export space points for pairs of tracks if possible
//
- AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!eESDfriend) return;
+ //AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ AliVfriendEvent *friendEvent=event->FindFriend();
+
+ if (!friendEvent) return;
Int_t ntracks=event->GetNumberOfTracks();
Int_t kMaxTracks=4; // maximal number of tracks for cosmic pairs
Int_t kMinVertexTracks=5; // maximal number of tracks for vertex mesurement
const Double_t kDist1Pt = 0.1;
const Double_t kMaxD0 =3; // max distance to the primary vertex
const Double_t kMaxD1 =5; // max distance to the primary vertex
- const AliESDVertex *tpcVertex = 0;
+ AliESDVertex *tpcVertex;
+ AliESDVertex tpcVtx;
// get the primary vertex TPC
if (ntracks>kMinVertexTracks) {
- tpcVertex = event->GetPrimaryVertexSPD();
+ event->GetPrimaryVertexSPD(tpcVtx);
+ tpcVertex=&tpcVtx;
+ //event->GetPrimaryVertexSPD(tpcVertex);
if (tpcVertex->GetNContributors()<kMinVertexTracks) tpcVertex=0;
}
//
Int_t index0=0,index1=0;
//
for (Int_t i0=0;i0<ntracks;++i0) {
- AliESDtrack *track0 = event->GetTrack(i0);
+ AliVTrack *track0 = event->GetVTrack(i0);
if (!track0) continue;
- if ((track0->GetStatus() & AliESDtrack::kTPCrefit)==0) continue;
+ if ((track0->GetStatus() & AliVTrack::kTPCrefit)==0) continue;
if (track0->GetOuterParam()==0) continue;
if (track0->GetInnerParam()==0) continue;
if (TMath::Abs(track0->GetInnerParam()->GetSigned1Pt()-track0->GetOuterParam()->GetSigned1Pt())>kDist1Pt) continue;
if (TMath::Abs(track0->GetInnerParam()->GetSigned1Pt())>kDist1Pt) continue;
if (TMath::Abs(track0->GetInnerParam()->GetTgl()-track0->GetOuterParam()->GetTgl())>kDistThS) continue;
- AliESDtrack *track1P = 0;
+ AliVTrack *track1P = 0;
if (track0->GetTPCNcls()<kminCl) continue;
track0->GetImpactParameters(dca0[0],dca0[1]);
index0=i0;
//
if (ntracks<kMaxTracks) for (Int_t i1=i0+1;i1<ntracks;++i1) {
if (i0==i1) continue;
- AliESDtrack *track1 = event->GetTrack(i1);
+ AliVTrack *track1 = event->GetVTrack(i1);
if (!track1) continue;
- if ((track1->GetStatus() & AliESDtrack::kTPCrefit)==0) continue;
+ if ((track1->GetStatus() & AliVTrack::kTPCrefit)==0) continue;
if (track1->GetOuterParam()==0) continue;
if (track1->GetInnerParam()==0) continue;
if (track1->GetTPCNcls()<kminCl) continue;
track1P = track1;
index1=i1;
}
- AliESDfriendTrack *friendTrack = 0;
+ //AliESDfriendTrack *friendTrack = 0;
TObject *calibObject=0;
AliTPCseed *seed0 = 0,*seed1=0;
//
- friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(index0);;
+ //friendTrack = (AliESDfriendTrack *)friendEvent->GetTrack(index0);;
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(index0);;
if (!friendTrack) continue;
for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
if ((seed0=dynamic_cast<AliTPCseed*>(calibObject))) break;
}
if (index1>0){
- friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(index1);;
- if (!friendTrack) continue;
- for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
+ const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(index1);;
+ if (!friendTrack1) continue;
+ for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
if ((seed1=dynamic_cast<AliTPCseed*>(calibObject))) break;
}
}
Bool_t isVertex=(tpcVertex)? kTRUE:kFALSE;
Double_t tof0=track0->GetTOFsignal();
Double_t tof1=(track1P) ? track1P->GetTOFsignal(): 0;
- static AliExternalTrackParam dummy;
- AliExternalTrackParam *p0In = &dummy;
- AliExternalTrackParam *p1In = &dummy;
- AliExternalTrackParam *p0Out = &dummy;
- AliExternalTrackParam *p1Out = &dummy;
+ static AliExternalTrackParam param;
+ AliExternalTrackParam *p0In = ¶m;
+ AliExternalTrackParam *p1In = ¶m;
+ AliExternalTrackParam *p0Out = ¶m;
+ AliExternalTrackParam *p1Out = ¶m;
AliESDVertex vdummy;
AliESDVertex *pvertex= (tpcVertex)? (AliESDVertex *)tpcVertex: &vdummy;
if (track0) {
- p0In= new AliExternalTrackParam(*track0);
+ //p0In= new AliExternalTrackParam(*track0);
+ p0In->CopyFromVTrack(track0);
p0Out=new AliExternalTrackParam(*(track0->GetOuterParam()));
}
if (track1P) {
- p1In= new AliExternalTrackParam(*track1P);
+ //p1In= new AliExternalTrackParam(*track1P);
+ p1In->CopyFromVTrack(track1P);
+
p1Out=new AliExternalTrackParam(*(track1P->GetOuterParam()));
}
Double_t alpha =2.*TMath::Pi()*(isec%18+0.5)/18.;
Double_t scos=TMath::Cos(alpha);
Double_t ssin=TMath::Sin(alpha);
- const AliESDVertex* vertex = fCurrentEvent->GetPrimaryVertexTracks();
+ AliESDVertex vtx;
+ fCurrentEvent->GetPrimaryVertexTracks(vtx);
+ const AliESDVertex* vertex=&vtx;
+
vertex->GetXYZ(vPosG.GetMatrixArray());
fCurrentTrack->GetImpactParameters(vImpact[0],vImpact[1]); // track impact parameters
//
class AliExternalTrackParam;
class AliTPCPointCorrection;
class AliTPCseed;
+class AliVEvent;
class AliTPCcalibAlign:public AliTPCcalibBase {
public:
AliTPCcalibAlign(const AliTPCcalibAlign &align);
//
virtual ~AliTPCcalibAlign();
- void Process(AliESDEvent *event);
+ void Process(AliVEvent *event);
virtual void ProcessSeed(AliTPCseed *track);
virtual void Process(AliTPCseed */*track*/){ return ;}
virtual void Analyze();
virtual void Terminate();
virtual Long64_t Merge(TCollection* const list);
- void ExportTrackPoints(AliESDEvent *event);
+ void ExportTrackPoints(AliVEvent *event);
//
//
void MakeReportDy(TFile *output);
// Bool_t GetTransformationCovar6(Int_t s1,Int_t s2,TMatrixD &a, Bool_t norm=kFALSE);
void Add(AliTPCcalibAlign * align);
const Int_t *GetPoints() const {return fPoints;}
- void Process(AliESDtrack *const track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+ //void Process(AliESDtrack *const track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliVTrack *const track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
TLinearFitter* GetOrMakeFitter12(Int_t s1,Int_t s2);
TLinearFitter* GetOrMakeFitter9(Int_t s1,Int_t s2);
TLinearFitter* GetOrMakeFitter6(Int_t s1,Int_t s2);
#include "AliLog.h"
#include "AliESDEvent.h"
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendTrack.h"
+
ClassImp(AliTPCcalibBase)
}
-void AliTPCcalibBase::UpdateEventInfo(AliESDEvent * event){
+void AliTPCcalibBase::UpdateEventInfo(AliVEvent * event){
//
//
//
}
-Bool_t AliTPCcalibBase::HasLaser(AliESDEvent *event){
+Bool_t AliTPCcalibBase::HasLaser(AliVEvent *event){
//
//
//
#include "TNamed.h"
#include "TObjString.h"
class AliTPCseed;
-class AliESDEvent;
-class AliESDtrack;
-class AliESDfriendTrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
+//class AliESDfriendTrack;
+class AliVfriendTrack;
class TCollection;
class TTreeSRedirector;
class TGraph;
AliTPCcalibBase(const AliTPCcalibBase&calib);
AliTPCcalibBase &operator=(const AliTPCcalibBase&calib);
virtual ~AliTPCcalibBase();
- virtual void Process(AliESDEvent *event){ fCurrentEvent = event; return;}
- virtual void Process(AliTPCseed *track){fCurrentSeed = track; return;}
- virtual void Process(AliESDtrack *track, Int_t /*runNo=-1*/){fCurrentTrack=track; return;}
+ virtual void Process(AliVEvent *event){
+ //Printf("AliTPCCalibBase::Process(ESD event)...");
+ fCurrentEvent = event; return;}
+ virtual void Process(AliTPCseed *track){
+ //Printf("AliTPCCalibBase::Process(TPC track)...");
+ fCurrentSeed = track; return;}
+ virtual void Process(AliVTrack *track, Int_t /*runNo=-1*/){
+ //Printf("AliTPCCalibBase::Process(ESD track)...");
+ fCurrentTrack=track; return;}
virtual Long64_t Merge(TCollection */*li*/){return 0;}
virtual void Analyze(){return;}
virtual void Terminate();
- virtual void UpdateEventInfo(AliESDEvent * event);
+ virtual void UpdateEventInfo(AliVEvent * event);
virtual Bool_t AcceptTrigger();
virtual void SetTriggerMask(Int_t accept, Int_t reject, Bool_t rejectLaser){fTriggerMaskAccept=accept;fTriggerMaskReject=reject; fRejectLaser = rejectLaser;}
Int_t GetStreamLevel() const {return fStreamLevel;}
Int_t GetDebugLevel() const {return fDebugLevel;}
virtual void RegisterDebugOutput(const char *path);
- static Bool_t HasLaser(AliESDEvent *event);
+ static Bool_t HasLaser(AliVEvent *event);
static TGraphErrors * FitSlices(THnSparse *h, Int_t axisDim1, Int_t axisDim2, Int_t minEntries, Int_t nmaxBin, Float_t fracLow=0.1, Float_t fracUp=0.9, Bool_t useMedian=kFALSE, TTreeSRedirector *cstream=0, Int_t ival=1);
static void BinLogX(THnSparse *h, Int_t axisDim);
static void BinLogX(TH1 *h);
Bool_t fHasLaser; //flag the laser is overlayed with given event
Bool_t fRejectLaser; //flag- reject laser
TObjString fTriggerClass; // trigger class
- AliESDEvent *fCurrentEvent; //! current event
- AliESDtrack *fCurrentTrack; //! current esd track
- AliESDfriendTrack *fCurrentFriendTrack; //! current friend track
+ AliVEvent *fCurrentEvent; //! current event
+ AliVTrack *fCurrentTrack; //! current esd track
+ AliVfriendTrack *fCurrentFriendTrack; //! current friend track
AliTPCseed *fCurrentSeed; //! current seed
private:
Int_t fDebugLevel; // debug level
#include "TTreeStream.h"
#include "AliLog.h"
#include "TTimeStamp.h"
-#include "AliESDEvent.h"
-#include "AliESDfriend.h"
-#include "AliESDtrack.h"
+//#include "AliESDEvent.h"
+//#include "AliESDfriend.h"
+//#include "AliESDtrack.h"
+
+#include "AliVEvent.h"
+#include "AliVfriendEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendTrack.h"
+
#include "AliTracker.h"
#include "AliTPCClusterParam.h"
#include "AliTPCParam.h"
}
-void AliTPCcalibCalib::Process(AliESDEvent *event){
+void AliTPCcalibCalib::Process(AliVEvent *event){
//
//
//
if (!event) {
return;
}
- AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!ESDfriend) {
+ //AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ AliVfriendEvent *friendEvent=event->FindFriend();
+ if (!friendEvent) {
return;
}
- if (ESDfriend->TestSkipBit()) return;
+ if (friendEvent->TestSkipBit()) return;
if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
- Int_t ntracks=ESDfriend->GetNumberOfTracks();
+ Int_t ntracks=friendEvent->GetNumberOfTracks();
//AliTPCcalibDB::Instance()->SetExBField(fMagF);
//
//
for (Int_t i=0;i<ntracks;++i) {
- AliESDtrack *track = event->GetTrack(i);
- AliESDfriendTrack *friendTrack = (AliESDfriendTrack*) ESDfriend->GetTrack(i);
+ AliVTrack *track = event->GetVTrack(i);
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
if (!friendTrack) continue;
//track->SetFriendTrack(friendTrack);
- fCurrentFriendTrack=friendTrack;
+ fCurrentFriendTrack=(AliVfriendTrack*)(friendTrack);
const AliExternalTrackParam * trackIn = track->GetInnerParam();
const AliExternalTrackParam * trackOut = track->GetOuterParam();
- AliExternalTrackParam * tpcOut = (AliExternalTrackParam *)friendTrack->GetTPCOut();
+ AliExternalTrackParam * tpcOut = (AliExternalTrackParam *)(friendTrack->GetTPCOut());
if (!trackIn) continue;
if (!trackOut) continue;
if (!tpcOut) continue;
return;
}
-Bool_t AliTPCcalibCalib::RefitTrack(AliESDtrack * track, AliTPCseed *seed, Float_t magesd){
+Bool_t AliTPCcalibCalib::RefitTrack(AliVTrack *track, AliTPCseed *seed, Float_t magesd){
//
// Refit track
// if magesd==0 forget the curvature
static Int_t streamCounter=0;
streamCounter++;
- AliESDfriendTrack *friendTrack = fCurrentFriendTrack;
+ AliVfriendTrack *friendTrack = fCurrentFriendTrack;
AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
AliTPCParam *param = AliTPCcalibDB::Instance()->GetParameters();
#include "AliTPCcalibBase.h"
class AliTPCseed;
-class AliESDEvent;
-class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
class TCollection;
class TTreeSRedirector;
class AliExternalTrackParam;
AliTPCcalibCalib(const AliTPCcalibCalib&calib);
AliTPCcalibCalib &operator=(const AliTPCcalibCalib&calib);
virtual ~AliTPCcalibCalib();
- virtual void Process(AliESDEvent *event);
+ virtual void Process(AliVEvent *event);
virtual void Analyze(){return;}
- Bool_t RefitTrack(AliESDtrack * track, AliTPCseed *seed, Float_t magesd);
+ Bool_t RefitTrack(AliVTrack * track, AliTPCseed *seed, Float_t magesd);
Bool_t RejectCluster(AliTPCclusterMI* cl, AliExternalTrackParam * param);
- void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+ //void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
void Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
void SetApplyExBCorrection(Int_t flag){fApplyExBCorrection=flag;}
#include "AliTPCseed.h"
#include "AliESDVertex.h"
#include "AliESDEvent.h"
+#include "AliESDtrack.h"
#include "AliESDfriend.h"
#include "AliESDInputHandler.h"
#include "AliAnalysisManager.h"
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
+
#include "AliTracker.h"
#include "AliMagF.h"
#include "AliTPCCalROC.h"
-void AliTPCcalibCosmic::Process(AliESDEvent *event) {
+void AliTPCcalibCosmic::Process(AliVEvent *event) {
//
// Process of the ESD event - fill calibration components
//
if (!event) {
- Printf("ERROR: ESD not available");
+ Printf("ERROR: event not available");
return;
}
}
-void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
+void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
//
// Find cosmic pairs
//
// Track1 is choosen in lower TPC part
//
if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ AliVfriendEvent *friendEvent=event->FindFriend();
Int_t ntracks=event->GetNumberOfTracks();
TObjArray tpcSeeds(ntracks);
if (ntracks==0) return;
//track loop
//
for (Int_t i=0;i<ntracks;++i) {
- AliESDtrack *track = event->GetTrack(i);
+ AliVTrack *track = event->GetVTrack(i);
fClusters->Fill(track->GetTPCNcls());
const AliExternalTrackParam * trackIn = track->GetInnerParam();
if (ntracks>4 && TMath::Abs(trackIn->GetTgl())<0.0015) continue; // filter laser
- AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
if (!friendTrack) continue;
TObject *calibObject;
AliTPCseed *seed = 0;
// Find pairs
//
for (Int_t i=0;i<ntracks;++i) {
- AliESDtrack *track0 = event->GetTrack(i);
+ AliVTrack *track0 = event->GetVTrack(i);
// track0 - choosen upper part
if (!track0) continue;
if (!track0->GetOuterParam()) continue;
track0->GetDirection(dir0);
for (Int_t j=0;j<ntracks;++j) {
if (i==j) continue;
- AliESDtrack *track1 = event->GetTrack(j);
+ AliVTrack *track1 = event->GetVTrack(j);
//track 1 lower part
if (!track1) continue;
if (!track1->GetOuterParam()) continue;
//
//
Float_t dmax = TMath::Max(TMath::Abs(d0),TMath::Abs(d1));
- AliExternalTrackParam param0(*track0);
- AliExternalTrackParam param1(*track1);
+ AliExternalTrackParam param0;
+ param0.CopyFromVTrack(track0);
+
+ AliExternalTrackParam param1;
+ param1.CopyFromVTrack(track1);
//
// Propagate using Magnetic field and correct fo material budget
//
-void AliTPCcalibCosmic::FillAcordeHist(AliESDtrack *upperTrack) {
+void AliTPCcalibCosmic::FillAcordeHist(AliVTrack *upperTrack) {
// Pt cut to select straight tracks which can be easily propagated to ACORDE which is outside the magnetic field
if (upperTrack->Pt() < 10 || upperTrack->GetTPCNcls() < 80) return;
-void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
+void AliTPCcalibCosmic::FindCosmicPairs(const AliVEvent *event) {
//
// find cosmic pairs trigger by random trigger
//
//
- AliESDVertex *vertexSPD = (AliESDVertex *)event->GetPrimaryVertexSPD();
- AliESDVertex *vertexTPC = (AliESDVertex *)event->GetPrimaryVertexTPC();
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ AliESDVertex vtxSPD;
+ event->GetPrimaryVertexSPD(vtxSPD);
+ AliESDVertex *vertexSPD=&vtxSPD;
+
+ AliESDVertex vtxTPC;
+ event->GetPrimaryVertexTPC(vtxTPC);
+ AliESDVertex *vertexTPC=&vtxTPC;
+
+ AliVfriendEvent *friendEvent=event->FindFriend();
const Double_t kMinPt=1;
const Double_t kMinPtMax=0.8;
const Double_t kMinNcl=50;
for (Int_t itrack0=0;itrack0<ntracks;itrack0++) {
- AliESDtrack *track0 = event->GetTrack(itrack0);
+ AliVTrack *track0 = event->GetVTrack(itrack0);
if (!track0) continue;
- if (!track0->IsOn(AliESDtrack::kTPCrefit)) continue;
+ if (!track0->IsOn(AliVTrack::kTPCrefit)) continue;
if (TMath::Abs(AliTracker::GetBz())>1&&track0->Pt()<kMinPt) continue;
if (track0->GetTPCncls()<kMinNcl) continue;
//if (TMath::Abs(dcaTPC[1])<kMaxDelta[0]*2) continue;
// const AliExternalTrackParam * trackIn0 = track0->GetInnerParam();
for (Int_t itrack1=itrack0+1;itrack1<ntracks;itrack1++) {
- AliESDtrack *track1 = event->GetTrack(itrack1);
+ AliVTrack *track1 = event->GetVTrack(itrack1);
if (!track1) continue;
- if (!track1->IsOn(AliESDtrack::kTPCrefit)) continue;
+ if (!track1->IsOn(AliVTrack::kTPCrefit)) continue;
if (track1->GetKinkIndex(0)>0) continue;
if (TMath::Abs(AliTracker::GetBz())>1&&track1->Pt()<kMinPt) continue;
if (track1->GetTPCncls()<kMinNcl) continue;
if (!isPair) continue;
TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
Int_t eventNumber = event->GetEventNumberInFile();
- Bool_t hasFriend=(esdFriend) ? (esdFriend->GetTrack(itrack0)!=0):0;
+ Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(itrack0)!=0):0;
Bool_t hasITS=(track0->GetNcls(0)+track1->GetNcls(0)>4);
printf("DUMPHPTCosmic:%s|%f|%d|%d|%d\n",filename.Data(),(TMath::Min(track0->Pt(),track1->Pt())), eventNumber,hasFriend,hasITS);
Int_t ntracksSPD = vertexSPD->GetNContributors();
Int_t ntracksTPC = vertexTPC->GetNContributors();
//
- AliESDfriendTrack *friendTrack0 = esdFriend->GetTrack(itrack0);
+ const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(itrack0);
if (!friendTrack0) continue;
- AliESDfriendTrack *friendTrack1 = esdFriend->GetTrack(itrack1);
+ const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(itrack1);
if (!friendTrack1) continue;
TObject *calibObject;
AliTPCseed *seed0 = 0;
for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
if ((seed1=dynamic_cast<AliTPCseed*>(calibObject))) break;
}
+
//
if (pcstream){
(*pcstream)<<"pairs"<<
"vTPC.="<<vertexTPC<< //primary vertex -TPC
"t0.="<<track0<< //track0
"t1.="<<track1<< //track1
- "ft0.="<<friendTrack0<< //track0
- "ft1.="<<friendTrack1<< //track1
+ //"ft0.="<<dummyfriendTrack0<< //track0
+ //"ft1.="<<dummyfriendTrack1<< //track1
"s0.="<<seed0<< //track0
"s1.="<<seed1<< //track1
"\n";
}
+
+ //**********************TEMPORARY!!*******************************************
+ // more investigation is needed with Tree ///!!!
+ //all dummy stuff here is just for code to compile and work with ESD
+
+ AliESDfriendTrack *dummyfriendTrack0 = (AliESDfriendTrack*)friendTrack0;
+ AliESDfriendTrack *dummyfriendTrack1 = (AliESDfriendTrack*)friendTrack1;
+
+ AliESDtrack *dummytrack0 = (AliESDtrack*)track0;
+ AliESDtrack *dummytrack1 = (AliESDtrack*)track1;
+
+ if ((pcstream)&&(dummyfriendTrack0)){
+ (*pcstream)<<"ft0.="<<dummyfriendTrack0<<"\n";
+ }
+ if ((pcstream)&&(dummyfriendTrack1)){
+ (*pcstream)<<"ft1.="<<dummyfriendTrack1<<"\n";
+ }
+
if (!fCosmicTree) {
fCosmicTree = new TTree("pairs","pairs");
fCosmicTree->SetDirectory(0);
if (fCosmicTree->GetEntries()==0){
//
fCosmicTree->SetDirectory(0);
- fCosmicTree->Branch("t0.",&track0);
- fCosmicTree->Branch("t1.",&track1);
- fCosmicTree->Branch("ft0.",&friendTrack0);
- fCosmicTree->Branch("ft1.",&friendTrack1);
+ fCosmicTree->Branch("t0.",&dummytrack0);
+ fCosmicTree->Branch("t1.",&dummytrack1);
+ fCosmicTree->Branch("ft0.",&dummyfriendTrack0);
+ fCosmicTree->Branch("ft1.",&dummyfriendTrack1);
}else{
- fCosmicTree->SetBranchAddress("t0.",&track0);
- fCosmicTree->SetBranchAddress("t1.",&track1);
- fCosmicTree->SetBranchAddress("ft0.",&friendTrack0);
- fCosmicTree->SetBranchAddress("ft1.",&friendTrack1);
+ fCosmicTree->SetBranchAddress("t0.",&dummytrack0);
+ fCosmicTree->SetBranchAddress("t1.",&dummytrack1);
+ fCosmicTree->SetBranchAddress("ft0.",&dummyfriendTrack0);
+ fCosmicTree->SetBranchAddress("ft1.",&dummyfriendTrack1);
}
fCosmicTree->Fill();
}
//
return;
//if (TMath::Abs(fMagF)<0.1) return; // work around - otherwise crashes
- AliESDtrack *track0=new AliESDtrack;
+ AliESDtrack *track0=new AliESDtrack; ///!!!
AliESDtrack *track1=new AliESDtrack;
AliESDfriendTrack *ftrack0=new AliESDfriendTrack;
AliESDfriendTrack *ftrack1=new AliESDfriendTrack;
class TH2F;
class TH1F;
class TList;
-class AliESDEvent;
-class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
class THnSparse;
class AliTPCcalibCosmic:public AliTPCcalibBase {
AliTPCcalibCosmic(const Text_t *name, const Text_t *title);
virtual ~AliTPCcalibCosmic();
- virtual void Process(AliESDEvent *event);
+ virtual void Process(AliVEvent *event);
virtual Long64_t Merge(TCollection *const li);
void Add(const AliTPCcalibCosmic* cosmic);
//
//
void Init();
- void FindPairs(const AliESDEvent *event);
- void FindCosmicPairs(const AliESDEvent * event);
+ void FindPairs(const AliVEvent *event);
+ void FindCosmicPairs(const AliVEvent * event);
Bool_t IsPair(AliExternalTrackParam *tr0, AliExternalTrackParam *tr1) const;
static void CalculateBetheParams(TH2F *hist, Double_t * initialParam);
static void BinLogX(TH1 *const h); // method for correct histogram binning
static void BinLogX(THnSparse *const h, Int_t axisDim); // method for correct histogram binning
- void Process(AliESDtrack *const track, Int_t runNo=-1) {AliTPCcalibBase::Process(track,runNo);};
+ //void Process(AliESDtrack *const track, Int_t runNo=-1) {AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliVTrack *const track, Int_t runNo=-1) {AliTPCcalibBase::Process(track,runNo);}
void Process(AliTPCseed *const track) {return AliTPCcalibBase::Process(track);}
virtual void Terminate();
static Double_t GetDeltaTime(Double_t rmin0, Double_t rmax0, Double_t rmin1, Double_t rmax1, Double_t tmin0, Double_t tmax0, Double_t tmin1, Double_t tmax1, Double_t dcaR, TVectorD& vectorDT);
static void AddTree(TTree* treeOutput, TTree * treeInput);
private:
- void FillAcordeHist(AliESDtrack *upperTrack);
+ void FillAcordeHist(AliVTrack *upperTrack);
#include "AliTPCClusterParam.h"
#include "AliTPCseed.h"
#include "AliESDVertex.h"
-#include "AliESDEvent.h"
-#include "AliESDfriend.h"
+//#include "AliESDEvent.h"
+//#include "AliESDfriend.h"
+#include "AliESDfriendTrack.h"
#include "AliESDInputHandler.h"
#include "AliAnalysisManager.h"
#include "AliTPCParam.h"
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
+
#include "AliComplexCluster.h"
#include "AliTPCclusterMI.h"
-void AliTPCcalibGainMult::Process(AliESDEvent *event) {
+void AliTPCcalibGainMult::Process(AliVEvent *event) {
//
// Main function of the class
// 1. Select Identified particles - for identified particles the flag in the PID matrix is stored
//const Double_t kMaxDCAR=10; // maximal DCA R of the track
//const Double_t kMaxDCAZ=5; // maximal DCA Z of the track
// const Double_t kMIPPt=0.525; // MIP pt
+
+ //Printf("AliTPCcalibGainMult::Process()...");
+
+ //AliESDEvent *event=(AliESDEvent*)event;
if (!event) {
- Printf("ERROR: ESD not available");
+ Printf("ERROR AliTPCcalibGainMult::Process(): event not available");
return;
}
- fCurrentEvent=event ;
+ fCurrentEvent=event;
fMagF = event->GetMagneticField();
Int_t ntracks=event->GetNumberOfTracks();
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!esdFriend) {
- //Printf("ERROR: esdFriend not available");
+ //AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindFriend());
+ AliVfriendEvent *friendEvent=event->FindFriend();
+ if (!friendEvent) {
+ Printf("ERROR: esdFriend not available");
delete fPIDMatrix;
return;
}
- if (!(esdFriend->TestSkipBit())) fPIDMatrix= new TMatrixD(ntracks,5);
+ if (!(friendEvent->TestSkipBit())) fPIDMatrix= new TMatrixD(ntracks,5);
fHistNTracks->Fill(ntracks);
// ProcessCosmic(event); // usually not enogh statistic
- if (esdFriend->TestSkipBit()) {
+ if (friendEvent->TestSkipBit()) {
return;
}
//
//
for (Int_t i=0;i<ntracks;++i) {
//
- AliESDtrack *track = event->GetTrack(i);
+ //AliESDtrack *track = (AliESDtrack*)(event->GetTrack(i));
+ AliVTrack *track = event->GetVTrack(i);
if (!track) continue;
//
AliExternalTrackParam * trackIn = (AliExternalTrackParam *)track->GetInnerParam();
if (TMath::Abs(trackIn->Eta()) > fCutEtaWindow) continue;
UInt_t status = track->GetStatus();
- if ((status&AliESDtrack::kTPCrefit)==0) continue;
- if ((status&AliESDtrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
+ //if ((status&AliESDtrack::kTPCrefit)==0) continue;
+ //if ((status&AliESDtrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
+
+ if ((status&AliVTrack::kTPCrefit)==0) continue;
+ if ((status&AliVTrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
+
Float_t dca[2], cov[3];
track->GetImpactParameters(dca,cov);
Float_t primVtxDCA = TMath::Sqrt(dca[0]*dca[0]);
if (TMath::Abs(dca[0]) > fCutMaxDcaXY || TMath::Abs(dca[0]) < 0.0000001) continue; // cut in xy
- if (((status&AliESDtrack::kITSrefit) == 1 && TMath::Abs(dca[1]) > 3.) || TMath::Abs(dca[1]) > fCutMaxDcaZ ) continue;
+ //if (((status&AliESDtrack::kITSrefit) == 1 && TMath::Abs(dca[1]) > 3.) || TMath::Abs(dca[1]) > fCutMaxDcaZ ) continue;
+ if (((status&AliVTrack::kITSrefit) == 1 && TMath::Abs(dca[1]) > 3.) || TMath::Abs(dca[1]) > fCutMaxDcaZ ) continue;
+
//
//
// fill Alexander QA histogram
if (primVtxDCA < 3 && track->GetNcls(0) > 3 && track->GetKinkIndex(0) == 0 && ncls > 100) fHistQA->Fill(meanP, track->GetTPCsignal(), 5);
// Get seeds
- AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+ //AliESDfriendTrack *friendTrack = friendEvent->GetTrack(i);
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
if (!friendTrack) continue;
TObject *calibObject;
AliTPCseed *seed = 0;
}
-void AliTPCcalibGainMult::DumpTrack(AliESDtrack * track, AliESDfriendTrack *ftrack, AliTPCseed * seed, Int_t index){
+void AliTPCcalibGainMult::DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack, AliTPCseed * seed, Int_t index){
//
// dump interesting tracks
// 1. track at MIP region
static Double_t radius1= roc->GetPadRowRadiiUp(30);
static Double_t radius2= roc->GetPadRowRadiiUp(roc->GetNRows(36)-15);
- AliESDVertex *vertex= (AliESDVertex *)fCurrentEvent->GetPrimaryVertex();
+ AliESDVertex vtx;
+ fCurrentEvent->GetPrimaryVertex(vtx);
+ AliESDVertex *vertex=&vtx;
//
// Estimate current MIP position -
//
-void AliTPCcalibGainMult::ProcessV0s(AliESDEvent * event){
+void AliTPCcalibGainMult::ProcessV0s(AliVEvent *event){
//
// Select the K0s and gamma - and sign daughter products
//
TTreeSRedirector * pcstream = GetDebugStreamer();
AliKFParticle::SetField(event->GetMagneticField());
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!esdFriend) {
- //Printf("ERROR: esdFriend not available");
+ //AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindFriend());
+ AliVfriendEvent *friendEvent=event->FindFriend();
+ if (!friendEvent) {
+ //Printf("ERROR: friendEvent not available");
return;
}
- if (esdFriend->TestSkipBit()) return;
+ if (friendEvent->TestSkipBit()) return;
//
//
static const TDatabasePDG *pdg = TDatabasePDG::Instance();
const Double_t kMaxREl=70;
//
Int_t nv0 = event->GetNumberOfV0s();
- AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+
+
+ //AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+ AliESDVertex vtx;
+ event->GetPrimaryVertex(vtx);
+ AliESDVertex *vertex=&vtx;
+
AliKFVertex kfvertex=*vertex;
+
+
//
for (Int_t iv0=0;iv0<nv0;iv0++){
- AliESDv0 *v0 = event->GetV0(iv0);
+ //AliESDv0 *v0 = event->GetV0(iv0);
+ AliESDv0 v0dummy;
+ event->GetV0(v0dummy, iv0);
+ AliESDv0 *v0 = &v0dummy;
+
if (!v0) continue;
if (v0->GetOnFlyStatus()<0.5) continue;
if (v0->GetPindex()<0) continue;
//
Int_t pindex = (v0->GetParamP()->GetSign()>0) ? v0->GetPindex() : v0->GetNindex();
Int_t nindex = (v0->GetParamP()->GetSign()>0) ? v0->GetNindex() : v0->GetPindex();
- AliESDtrack * trackP = event->GetTrack(pindex);
- AliESDtrack * trackN = event->GetTrack(nindex);
+ //AliESDtrack * trackP = (AliESDtrack*)event->GetTrack(pindex);
+ //AliESDtrack * trackN = (AliESDtrack*)event->GetTrack(nindex);
+ AliVTrack * trackP = event->GetVTrack(pindex);
+ AliVTrack * trackN = event->GetVTrack(nindex);
if (!trackN) continue;
if (!trackP) continue;
Int_t nclP= (Int_t)trackP->GetTPCClusterInfo(2,1);
if (TMath::Abs(eta)>1) continue;
//
//
- AliESDfriendTrack *friendTrackP = esdFriend->GetTrack(pindex);
- AliESDfriendTrack *friendTrackN = esdFriend->GetTrack(nindex);
+ //AliESDfriendTrack *friendTrackP = friendEvent->GetTrack(pindex);
+ //AliESDfriendTrack *friendTrackN = friendEvent->GetTrack(nindex);
+ const AliVfriendTrack *friendTrackP = friendEvent->GetTrack(pindex);
+ const AliVfriendTrack *friendTrackN = friendEvent->GetTrack(nindex);
if (!friendTrackP) continue;
if (!friendTrackN) continue;
TObject *calibObject;
-void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
+void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *event) {
//
// Find cosmic pairs trigger by random trigger
//
AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
AliTPCParam *param = AliTPCcalibDB::Instance()->GetParameters();
- AliESDVertex *vertexSPD = (AliESDVertex *)event->GetPrimaryVertexSPD();
- AliESDVertex *vertexTPC = (AliESDVertex *)event->GetPrimaryVertexTPC();
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ AliESDVertex vtxSPD;
+ event->GetPrimaryVertexSPD(vtxSPD);
+ AliESDVertex *vertexSPD=&vtxSPD;
+
+ AliESDVertex vtxTPC;
+ event->GetPrimaryVertexTPC(vtxTPC);
+ AliESDVertex *vertexTPC=&vtxTPC;
+
+ //AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ AliVfriendEvent *friendEvent=event->FindFriend();
const Double_t kMinPt=4;
const Double_t kMinPtMax=0.8;
const Double_t kMinNcl=159*0.5;
for (Int_t itrack0=0;itrack0<ntracks;itrack0++) {
- AliESDtrack *track0 = event->GetTrack(itrack0);
+ AliVTrack *track0 = event->GetVTrack(itrack0);
if (!track0) continue;
- if (!track0->IsOn(AliESDtrack::kTPCrefit)) continue;
+ if (!track0->IsOn(AliVTrack::kTPCrefit)) continue;
if (TMath::Abs(AliTracker::GetBz())>1&&track0->Pt()<kMinPt) continue;
if (track0->GetTPCncls()<kMinNcl) continue;
//rm primaries
//
for (Int_t itrack1=itrack0+1;itrack1<ntracks;itrack1++) {
- AliESDtrack *track1 = event->GetTrack(itrack1);
+ AliVTrack *track1 = event->GetVTrack(itrack1);
if (!track1) continue;
- if (!track1->IsOn(AliESDtrack::kTPCrefit)) continue;
+ if (!track1->IsOn(AliVTrack::kTPCrefit)) continue;
if (track1->GetKinkIndex(0)>0) continue;
if (TMath::Abs(AliTracker::GetBz())>1&&track1->Pt()<kMinPt) continue;
if (track1->GetTPCncls()<kMinNcl) continue;
if (!isPair) continue;
TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
Int_t eventNumber = event->GetEventNumberInFile();
- Bool_t hasFriend=(esdFriend) ? (esdFriend->GetTrack(itrack0)!=0):0;
+ Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(itrack0)!=0):0;
Bool_t hasITS=(track0->GetNcls(0)+track1->GetNcls(0)>4);
AliInfo(Form("DUMPHPTCosmic:%s|%f|%d|%d|%d\n",filename.Data(),(TMath::Min(track0->Pt(),track1->Pt())), eventNumber,hasFriend,hasITS));
//
"\n";
}
//
- AliESDfriendTrack *friendTrack0 = esdFriend->GetTrack(itrack0);
+ const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(itrack0);
if (!friendTrack0) continue;
- AliESDfriendTrack *friendTrack1 = esdFriend->GetTrack(itrack1);
+ const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(itrack1);
if (!friendTrack1) continue;
TObject *calibObject;
AliTPCseed *seed0 = 0;
"vTPC.="<<vertexTPC<< //primary vertex -TPC
"t0.="<<track0<< //track0
"t1.="<<track1<< //track1
- "ft0.="<<friendTrack0<< //track0
- "ft1.="<<friendTrack1<< //track1
+ //"ft0.="<<friendTrack0<< //track0
+ //"ft1.="<<friendTrack1<< //track1
"s0.="<<seed0<< //track0
"s1.="<<seed1<< //track1
"\n";
}
+
+ if ((pcstream)&&((AliESDfriendTrack*)friendTrack0)){
+ (*pcstream)<<"ft0.="<<((AliESDfriendTrack*)friendTrack0)<<"\n";
+ }
+ if ((pcstream)&&((AliESDfriendTrack*)friendTrack1)){
+ (*pcstream)<<"ft1.="<<((AliESDfriendTrack*)friendTrack1)<<"\n";
+ }
+
+
if (!seed0) continue;
if (!seed1) continue;
Int_t nclA0=0, nclC0=0; // number of clusters
-void AliTPCcalibGainMult::ProcessKinks(const AliESDEvent * event){
+void AliTPCcalibGainMult::ProcessKinks(const AliVEvent *event){
//
//
//
AliKFParticle::SetField(event->GetMagneticField());
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!esdFriend) {
+ AliVfriendEvent *friendEvent=event->FindFriend();
+ if (!friendEvent) {
//Printf("ERROR: esdFriend not available");
return;
}
const Int_t kMinNcl=110;
//
Int_t nkinks = event->GetNumberOfKinks();
- AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+ //AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+ AliESDVertex vtx;
+ event->GetPrimaryVertex(vtx);
+ AliESDVertex *vertex=&vtx;
+
AliKFVertex kfvertex=*vertex;
TTreeSRedirector * pcstream = GetDebugStreamer();
//
AliKFParticle *v0KF = new AliKFParticle(kfpm,kfpd);
v0KF->SetVtxGuess(kink->GetPosition()[0],kink->GetPosition()[1],kink->GetPosition()[2]);
Double_t chi2 = v0KF->GetChi2();
- AliESDtrack * trackM = event->GetTrack(kink->GetIndex(0));
- AliESDtrack * trackD = event->GetTrack(kink->GetIndex(1));
+ AliVTrack * trackM = event->GetVTrack(kink->GetIndex(0));
+ AliVTrack * trackD = event->GetVTrack(kink->GetIndex(1));
if (!trackM) continue;
if (!trackD) continue;
Int_t nclM= (Int_t)trackM->GetTPCClusterInfo(2,1);
if (TMath::Abs(eta)>1) continue;
//
//
- AliESDfriendTrack *friendTrackM = esdFriend->GetTrack(kink->GetIndex(0));
- AliESDfriendTrack *friendTrackD = esdFriend->GetTrack(kink->GetIndex(1));
+ const AliVfriendTrack *friendTrackM = friendEvent->GetTrack(kink->GetIndex(0));
+ const AliVfriendTrack *friendTrackD = friendEvent->GetTrack(kink->GetIndex(1));
if (!friendTrackM) continue;
if (!friendTrackD) continue;
TObject *calibObject;
}
}
-void AliTPCcalibGainMult::DumpHPT(const AliESDEvent * event){
+void AliTPCcalibGainMult::DumpHPT(const AliVEvent *event){
//
// Function to select the HPT tracks and events
// It is used to select event with HPT - list used later for the raw data downloading
TTreeSRedirector * pcstream = GetDebugStreamer();
AliKFParticle::SetField(event->GetMagneticField());
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!esdFriend) {
+ AliVfriendEvent *friendEvent=event->FindFriend();
+ if (!friendEvent) {
//Printf("ERROR: esdFriend not available");
return;
}
- if (esdFriend->TestSkipBit()) return;
+ if (friendEvent->TestSkipBit()) return;
Int_t ntracks=event->GetNumberOfTracks();
//
for (Int_t i=0;i<ntracks;++i) {
//
- AliESDtrack *track = event->GetTrack(i);
+ AliVTrack *track = event->GetVTrack(i);
if (!track) continue;
if (track->Pt()<4) continue;
UInt_t status = track->GetStatus();
//
AliExternalTrackParam * trackIn = (AliExternalTrackParam *)track->GetInnerParam();
if (!trackIn) continue;
- if ((status&AliESDtrack::kTPCrefit)==0) continue;
- if ((status&AliESDtrack::kITSrefit)==0) continue;
- AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+ if ((status&AliVTrack::kTPCrefit)==0) continue;
+ if ((status&AliVTrack::kITSrefit)==0) continue;
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
if (!friendTrack) continue;
AliExternalTrackParam * itsOut = (AliExternalTrackParam *)(friendTrack->GetITSOut());
if (!itsOut) continue;
tpcInnerC->Rotate(track->GetAlpha());
tpcInnerC->PropagateTo(track->GetX(),event->GetMagneticField());
Double_t dz[2],cov[3];
- AliESDVertex *vtx= (AliESDVertex *)event->GetPrimaryVertex();
+ AliESDVertex dummyvtx;
+ event->GetPrimaryVertex(dummyvtx);
+ AliESDVertex *vtx=&dummyvtx;
+
if (!tpcInnerC->PropagateToDCA(vtx, event->GetMagneticField(), 3, dz, cov)) continue;
Double_t covar[6]; vtx->GetCovMatrix(covar);
-void AliTPCcalibGainMult::ProcessTOF(const AliESDEvent * event){
+void AliTPCcalibGainMult::ProcessTOF(const AliVEvent *event){
//
// 1. Loop over tracks
// 2. Fit T0
const Double_t kMaxD=20;
const Double_t kRMS0=200;
const Double_t kMaxDCAZ=10;
- AliESDVertex *vtx= (AliESDVertex *)event->GetPrimaryVertex();
+ AliESDVertex dummyvtx;
+ event->GetPrimaryVertex(dummyvtx);
+ AliESDVertex *vtx=&dummyvtx;
//
TTreeSRedirector * pcstream = GetDebugStreamer();
AliKFParticle::SetField(event->GetMagneticField());
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!esdFriend) {
+ AliVfriendEvent *friendEvent=event->FindFriend();
+ if (!friendEvent) {
//Printf("ERROR: esdFriend not available");
return;
}
counter=0;
for (Int_t i=0;i<ntracks;++i) {
//
- AliESDtrack *track = event->GetTrack(i);
+ AliVTrack *track = event->GetVTrack(i);
if (!track) continue;
- if (!track->IsOn(AliESDtrack::kTIME)) continue;
+ if (!track->IsOn(AliVTrack::kTIME)) continue;
if (TMath::Abs(track->GetZ())>kMaxDCAZ) continue; // remove overlaped events
if (TMath::Abs(track->GetTOFsignalDz())>kMaxD) continue;
Double_t times[1000];
//
for (Int_t i=0;i<ntracks;++i) {
//
- AliESDtrack *track = event->GetTrack(i);
+ AliVTrack *track = event->GetVTrack(i);
if (!track) continue;
- if (!track->IsOn(AliESDtrack::kTIME)) continue;
+ if (!track->IsOn(AliVTrack::kTIME)) continue;
if (TMath::Abs(track->GetZ())>kMaxDCAZ) continue; //remove overlapped events
if (TMath::Abs(track->GetTOFsignalDz())>kMaxD) continue;
Double_t times[1000];
#include "TVectorD.h"
class TH1F;
class TList;
-class AliESDEvent;
-class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
+class AliVfriendTrack;
class AliTPCseed;
#include "TTreeStream.h"
void SetBBParam(TVectorD * param) {fBBParam=param;}
// virtual void Terminate();
//
- virtual void Process(AliESDEvent *event);
- virtual void ProcessV0s(AliESDEvent *event);
- virtual void ProcessCosmic(const AliESDEvent *event);
- virtual void ProcessKinks(const AliESDEvent *event);
- virtual void ProcessTOF(const AliESDEvent *event);
- virtual void DumpHPT(const AliESDEvent *event);
+ //virtual void Process(AliESDEvent *event);
+ virtual void Process(AliVEvent *event);
+
+ //virtual void ProcessV0s(AliESDEvent *event);
+ //virtual void ProcessCosmic(const AliESDEvent *event);
+ //virtual void ProcessKinks(const AliESDEvent *event);
+ //virtual void ProcessTOF(const AliESDEvent *event);
+ //virtual void DumpHPT(const AliESDEvent *event);
+
+ virtual void ProcessV0s(AliVEvent *event);
+ virtual void ProcessCosmic(const AliVEvent *event);
+ virtual void ProcessKinks(const AliVEvent *event);
+ virtual void ProcessTOF(const AliVEvent *event);
+ virtual void DumpHPT(const AliVEvent *event);
+
virtual Long64_t Merge(TCollection *li);
virtual void Analyze();
- void DumpTrack(AliESDtrack * track, AliESDfriendTrack *ftrack, AliTPCseed * seed, Int_t index);
+ void DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack, AliTPCseed * seed, Int_t index);
//
TH1F * GetHistNTracks() const {return fHistNTracks;};
TH1F * GetHistClusterShape() const {return fHistClusterShape;};
void SetAlephParameters(Float_t * parameters){for(Int_t j=0;j<5;j++) fAlephParameters[j] = parameters[j];};
//
//
- void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+ //void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
void Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
//
void MakeLookup(THnSparse * hist, Char_t * outputFile);
#include "TLinearFitter.h"
#include "AliTPCcalibLaser.h"
#include "AliExternalTrackParam.h"
-#include "AliESDEvent.h"
-#include "AliESDfriend.h"
-#include "AliESDtrack.h"
+//#include "AliESDEvent.h"
+//#include "AliESDfriend.h"
+//#include "AliESDtrack.h"
+
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
+
#include "AliTPCTracklet.h"
#include "TH1D.h"
#include "TH1F.h"
AliTPCcalibLaser::AliTPCcalibLaser():
AliTPCcalibBase(),
- fESD(0),
- fESDfriend(0),
+ fEvent(0),
+ fEventFriend(0),
fNtracks(0),
fTracksMirror(336),
- fTracksEsd(336),
+ fTracks(336),
fTracksEsdParam(336),
fTracksTPC(336),
fFullCalib(kTRUE),
AliTPCcalibLaser::AliTPCcalibLaser(const Text_t *name, const Text_t *title, Bool_t full):
AliTPCcalibBase(),
- fESD(0),
- fESDfriend(0),
+ fEvent(0),
+ fEventFriend(0),
fNtracks(0),
fTracksMirror(336),
- fTracksEsd(336),
+ fTracks(336),
fTracksEsdParam(336),
fTracksTPC(336),
fFullCalib(full),
AliTPCcalibLaser::AliTPCcalibLaser(const AliTPCcalibLaser& calibLaser):
AliTPCcalibBase(calibLaser),
- fESD(0),
- fESDfriend(0),
+ fEvent(0),
+ fEventFriend(0),
fNtracks(0),
fTracksMirror(336),
- fTracksEsd(336),
+ fTracks(336),
fTracksEsdParam(336),
fTracksTPC(336),
fFullCalib(calibLaser.fFullCalib),
-void AliTPCcalibLaser::Process(AliESDEvent * event) {
+void AliTPCcalibLaser::Process(AliVEvent *event) {
//
//
// Loop over tracks and call Process function
const Int_t kMinTracks=20;
const Int_t kMinClusters=40;
- fESD = event;
- if (!fESD) {
+ fEvent = event;
+ if (!fEvent) {
+ Printf("****ERROR AliTPCcalibLaser::Process(): Event not available!!********");
return;
}
- fESDfriend=static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));
- if (!fESDfriend) {
+ fEventFriend=fEvent->FindFriend();
+ if (!fEventFriend) {
return;
}
- if (fESDfriend->TestSkipBit()) return;
- if (fESD->GetNumberOfTracks()<kMinTracks) return; //not enough tracks
+ if (fEventFriend->TestSkipBit()) return;
+ if (fEvent->GetNumberOfTracks()<kMinTracks) return; //not enough tracks
AliDebug(4,Form("Event number in current file: %d",event->GetEventNumberInFile()));
//
// find CE background if present
//
if (AliTPCLaserTrack::GetTracks()==0) AliTPCLaserTrack::LoadTracks();
TH1D hisCE("hhisCE","hhisCE",100,-100,100);
- for (Int_t i=0;i<fESD->GetNumberOfTracks();++i) {
- AliESDtrack *track=fESD->GetTrack(i);
+ for (Int_t i=0;i<fEvent->GetNumberOfTracks();++i) {
+ AliVTrack *track=fEvent->GetVTrack(i);
if (!track) continue;
hisCE.Fill(track->GetZ());
hisCE.Fill(track->GetZ()+2);
fTracksTPC.Clear();
- fTracksEsd.Clear();
+ fTracks.Clear();
fTracksEsdParam.Delete();
for (Int_t id=0; id<336;id++) {
fCounter[id]=0;
fClusterSatur[id]=0;
}
//
- Int_t n=fESD->GetNumberOfTracks();
+ Int_t n=fEvent->GetNumberOfTracks();
Int_t counter=0;
for (Int_t i=0;i<n;++i) {
- AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(i);
+ const AliVfriendTrack *friendTrack=fEventFriend->GetTrack(i);
if (!friendTrack) continue;
- AliESDtrack *track=fESD->GetTrack(i);
+ AliVTrack *track= fEvent->GetVTrack(i);
if (!track) continue;
Double_t binC = hisCE.GetBinContent(hisCE.FindBin(track->GetZ()));
if (binC>336) continue; //remove CE background
AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
- AliESDtrack *track = (AliESDtrack*)fTracksEsd.At(id);
+ AliVTrack *track = (AliVTrack*)fTracks.At(id);
if (!param) return;
if (!ltrp) return;
if (!track) return;
if (!AcceptLaser(id)) continue;
if ( fClusterSatur[id]>kSaturCut) continue;
if ( fClusterCounter[id]<kMinClusters) continue;
- AliESDtrack *track = (AliESDtrack*)fTracksEsd.At(id);
+ AliVTrack *track = (AliVTrack*)fTracks.At(id);
if (track->GetTPCsignal()<kMinSignal) continue;
AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
if (!AcceptLaser(id)) continue;
if ( fClusterSatur[id]>kSaturCut) continue;
if ( fClusterCounter[id]<kMinClusters) continue;
- AliESDtrack *track = (AliESDtrack*)fTracksEsd.At(id);
+ AliVTrack *track = (AliVTrack*)fTracks.At(id);
if (track->GetTPCsignal()<kMinSignal) continue;
AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
return kTRUE;
}
-Int_t AliTPCcalibLaser::FindMirror(AliESDtrack *track, AliTPCseed *seed){
+Int_t AliTPCcalibLaser::FindMirror(AliVTrack *track, AliTPCseed *seed){
//
// Find corresponding mirror
// add the corresponding tracks
if (accept){
fClusterCounter[id]=countercl;
fTracksEsdParam.AddAt(param.Clone(),id);
- fTracksEsd.AddAt(track,id);
+ fTracks.AddAt(track,id);
fTracksTPC.AddAt(seed,id);
}
return id;
//
// Dump Laser info to the tree
//
- AliESDtrack *track = (AliESDtrack*)fTracksEsd.At(id);
+ AliVTrack *track = (AliVTrack*)fTracks.At(id);
AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
//
if (fStreamLevel>0){
TTreeSRedirector *cstream = GetDebugStreamer();
- Int_t time = fESD->GetTimeStamp();
+ Int_t time = fEvent->GetTimeStamp();
Bool_t accept = AcceptLaser(id);
if (cstream){
(*cstream)<<"Track"<<
class AliExternalTrackParam;
-class AliESDtrack;
-class AliESDEvent;
-class AliESDfriend;
+//class AliESDtrack;
+//class AliESDEvent;
+//class AliESDfriend;
+class AliVEvent;
+class AliVTrack;
+class AliVfriendEvent;
class TGraphErrors;
class TTree;
class TH2F;
AliTPCcalibLaser(const AliTPCcalibLaser& laser);
AliTPCcalibLaser & operator=(const AliTPCcalibLaser& calibLaser);
virtual ~AliTPCcalibLaser();
- virtual void Process(AliESDEvent *event);
+ virtual void Process(AliVEvent *event);
Int_t GetNtracks(){return fNtracks;}
virtual void Analyze();
static void DumpLaser(const char *finput, Int_t run);
void MakeDistHisto(Int_t id);
void AddCut(Double_t xcut, Double_t ycut, Double_t ncl){fEdgeXcuts[fNcuts]=xcut; fEdgeYcuts[fNcuts]=ycut; fNClCuts[fNcuts]=ncl; fNcuts++;}
- Int_t FindMirror(AliESDtrack *track, AliTPCseed *seed);
+ Int_t FindMirror(AliVTrack *track, AliTPCseed *seed);
Bool_t AcceptLaser(Int_t id);
Float_t GetDistance(AliExternalTrackParam *track, AliTPCLaserTrack *ltrp);
void MakeFitHistos();
void UpdateFitHistos();
void MergeFitHistos(AliTPCcalibLaser * add);
- void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+ //void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
void Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
//
void SetBeamParameters(TVectorD& meanOffset, TVectorD& meanSlope,
{fUseFixedDriftV = 1; fFixedFitAside0=aside0; fFixedFitAside1=aside1;
fFixedFitCside0=cside0; fFixedFitCside1=cside1;}
- AliESDEvent * fESD; //! ESD event - not OWNER
- AliESDfriend * fESDfriend; //! ESD event - not OWNER
+ AliVEvent * fEvent; //! ESD event - not OWNER
+ AliVfriendEvent * fEventFriend; //! ESD event - not OWNER
Int_t fNtracks; //! counter of associated laser tracks
//
TObjArray fTracksMirror; //! tracks with mirror information
- TObjArray fTracksEsd; //! tracks with reconstructed information -
+ TObjArray fTracks; //! tracks with reconstructed information -
// not owner ESD
TObjArray fTracksEsdParam; //! tracks with reconstructed information -
// is owner ESD at mirror
#include "AliDCSSensor.h"
#include "AliDCSSensorArray.h"
-#include "AliESDEvent.h"
+//#include "AliESDEvent.h"
#include "AliESDInputHandler.h"
#include "AliESDVertex.h"
-#include "AliESDfriend.h"
+//#include "AliESDfriend.h"
+
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
+
#include "AliLog.h"
#include "AliRelAlignerKalman.h"
#include "AliTPCCalROC.h"
-void AliTPCcalibTime::Process(AliESDEvent *event){
+void AliTPCcalibTime::Process(AliVEvent *event){
//
// main function to make calibration
//
- if(!event) return;
- if (event->GetNumberOfTracks()<2) return;
- AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!ESDfriend) {
+
+ //Printf("*******************AliTPCcalibTime::Process()*******************");
+ if(!event) {
+ Printf("ERROR AliTPCcalibTime::Process(): NO EVENT AVAILABLE!");
+ return;
+ }
+ if (event->GetNumberOfTracks()<2) {
+ //Printf("ACHTUNG AliTPCcalibTime::Process(): not enough tracks!");
+ return;
+ }
+ //AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ AliVfriendEvent *friendEvent=event->FindFriend();
+ if (!friendEvent) {
+ Printf("ERROR AliTPCcalibTime::Process(): NO FRIEND AVAILABLE!");
return;
}
- if (ESDfriend->TestSkipBit()) return;
+ if (friendEvent->TestSkipBit()) return;
ResetCurrent();
+
+ //AliESDEvent *ev=(AliESDEvent*)event;
//if(IsLaser (event))
ProcessLaser (event);
//if(IsCosmics(event))
ProcessBeam (event);
}
-void AliTPCcalibTime::ProcessLaser(AliESDEvent *event){
+void AliTPCcalibTime::ProcessLaser(AliVEvent *event){
//
// Fit drift velocity using laser
//
}
}
-void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
+void AliTPCcalibTime::ProcessCosmic(const AliVEvent *const event){
//
// process Cosmic event - track matching A side C side
//
if (!event) {
- Printf("ERROR: ESD not available");
+ Printf("ERROR: event not available");
return;
}
if (event->GetTimeStamp() == 0 ) {
if (ntracks > fCutTracks) return;
if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
- AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
-
+ //AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
+ AliVfriendEvent *friendEvent=event->FindFriend();
TObjArray tpcSeeds(ntracks);
Double_t vtxx[3]={0,0,0};
Double_t svtxx[3]={0.000001,0.000001,100.};
for (Int_t i=0;i<ntracks;++i) {
clusterSideA[i]=0;
clusterSideC[i]=0;
- AliESDtrack *track = event->GetTrack(i);
+ AliVTrack *track = event->GetVTrack(i);
const AliExternalTrackParam * trackIn = track->GetInnerParam();
const AliExternalTrackParam * trackOut = track->GetOuterParam();
if (!trackIn) continue;
if (!trackOut) continue;
- AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
if (!friendTrack) continue;
if (friendTrack) ProcessSame(track,friendTrack,event);
- if (friendTrack) ProcessAlignITS(track,friendTrack,event,esdFriend);
+ if (friendTrack) ProcessAlignITS(track,friendTrack,event,friendEvent);
if (friendTrack) ProcessAlignTRD(track,friendTrack);
if (friendTrack) ProcessAlignTOF(track,friendTrack);
TObject *calibObject;
//
for (Int_t i=0;i<ntracks;++i) {
- AliESDtrack *track0 = event->GetTrack(i);
+ AliVTrack *track0 = event->GetVTrack(i);
// track0 - choosen upper part
if (!track0) continue;
if (!track0->GetOuterParam()) continue;
track0->GetDirection(d1);
for (Int_t j=0;j<ntracks;++j) {
if (i==j) continue;
- AliESDtrack *track1 = event->GetTrack(j);
+ AliVTrack *track1 = event->GetVTrack(j);
//track 1 lower part
if (!track1) continue;
if (!track1->GetOuterParam()) continue;
//
//
Float_t dmax = TMath::Max(TMath::Abs(dist0),TMath::Abs(dist1));
- AliExternalTrackParam param0(*track0);
- AliExternalTrackParam param1(*track1);
+ AliExternalTrackParam param0;
+ param0.CopyFromVTrack(track0);
+ AliExternalTrackParam param1;
+ param1.CopyFromVTrack(track1);
//
// Propagate using Magnetic field and correct fo material budget
//
if (GetDebugLevel()>20) printf("Trigger: %s\n",event->GetFiredTriggerClasses().Data());
}
-void AliTPCcalibTime::ProcessBeam(const AliESDEvent *const event){
+void AliTPCcalibTime::ProcessBeam(const AliVEvent *const event){
//
// Process beam data - calculates vartex
// from A side and C side
if (ntracks==0) return;
if (ntracks > fCutTracks) return;
//
- AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
+ //AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
+ AliVfriendEvent *friendEvent=event->FindFriend();
//
// Divide tracks to A and C side tracks - using the cluster indexes
TObjArray tracksA(ntracks);
TObjArray tracksC(ntracks);
//
- AliESDVertex *vertexSPD = (AliESDVertex *)event->GetPrimaryVertexSPD();
- AliESDVertex *vertex = (AliESDVertex *)event->GetPrimaryVertex();
- AliESDVertex *vertexTracks = (AliESDVertex *)event->GetPrimaryVertexTracks();
+ //AliESDVertex *vertexSPD = (AliESDVertex *)event->GetPrimaryVertexSPD();
+ //AliESDVertex *vertex = (AliESDVertex *)event->GetPrimaryVertex();
+ //AliESDVertex *vertexTracks = (AliESDVertex *)event->GetPrimaryVertexTracks();
+
+ AliESDVertex vtxSPD;
+ event->GetPrimaryVertexSPD(vtxSPD);
+ AliESDVertex *vertexSPD=&vtxSPD;
+
+ AliESDVertex vtx;
+ event->GetPrimaryVertex(vtx);
+ AliESDVertex *vertex=&vtx;
+
+ AliESDVertex vtxTracks;
+ event->GetPrimaryVertexTracks(vtxTracks);
+ AliESDVertex *vertexTracks=&vtxTracks;
+
+
Double_t vertexZA[10000], vertexZC[10000];
//
Int_t ntracksA= 0;
Int_t ntracksC= 0;
//
for (Int_t itrack=0;itrack<ntracks;itrack++) {
- AliESDtrack *track = event->GetTrack(itrack);
- AliESDfriendTrack *friendTrack = esdFriend->GetTrack(itrack);
+ AliVTrack *track = event->GetVTrack(itrack);
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(itrack);
if (!friendTrack) continue;
if (TMath::Abs(track->GetTgl())>kMaxTgl) continue;
if (TMath::Abs(track->Pt())<kMinPt) continue;
return kTRUE;
}
-Bool_t AliTPCcalibTime::IsCross(const AliESDtrack *const tr0, const AliESDtrack *const tr1){
+Bool_t AliTPCcalibTime::IsCross(const AliVTrack *const tr0, const AliVTrack *const tr1){
//
// check if the cosmic pair of tracks crossed A/C side
//
return result;
}
-Bool_t AliTPCcalibTime::IsSame(const AliESDtrack *const tr0, const AliESDtrack *const tr1){
+Bool_t AliTPCcalibTime::IsSame(const AliVTrack *const tr0, const AliVTrack *const tr1){
//
// track crossing the CE
// 0. minimal number of clusters
}
-void AliTPCcalibTime::ProcessSame(const AliESDtrack *const track, AliESDfriendTrack *const friendTrack, const AliESDEvent *const event){
+void AliTPCcalibTime::ProcessSame(const AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event){
//
// Process TPC tracks crossing CE
//
}
-void AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack, const AliESDEvent *const event, AliESDfriend *const esdFriend){
+void AliTPCcalibTime::ProcessAlignITS(AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event, AliVfriendEvent *const friendEvent){
//
// Process track - Update TPC-ITS alignment
// Updates:
//
Int_t dummycl[1000];
if (track->GetTPCNcls()<kMinTPC) return; // minimal amount of clusters cut
- if (!track->IsOn(AliESDtrack::kTPCrefit)) return;
+ if (!track->IsOn(AliVTrack::kTPCrefit)) return;
if (!track->GetInnerParam()) return;
if (!track->GetOuterParam()) return;
if (track->GetInnerParam()->Pt()<kMinPt) return;
AliTracker::PropagateTrackToBxByBz(&pITS2,pTPC.GetX(),0.1,0.1,kFALSE);
}
- AliESDfriendTrack *itsfriendTrack=0;
+ //AliESDfriendTrack *itsfriendTrack=0;
//
// try to find standalone ITS track corresponing to the TPC if possible
//
Bool_t hasAlone=kFALSE;
Int_t ntracks=event->GetNumberOfTracks();
for (Int_t i=0; i<ntracks; i++){
- AliESDtrack * trackITS = event->GetTrack(i);
+ AliVTrack * trackITS = event->GetVTrack(i);
if (!trackITS) continue;
if (trackITS->GetITSclusters(dummycl)<kMinITS) continue; // minimal amount of clusters
- itsfriendTrack = esdFriend->GetTrack(i);
+ const AliVfriendTrack *itsfriendTrack = friendEvent->GetTrack(i);
if (!itsfriendTrack) continue;
if (!itsfriendTrack->GetITSOut()) continue;
-void AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack){
+void AliTPCcalibTime::ProcessAlignTRD(AliVTrack *const track, const AliVfriendTrack *const friendTrack){
//
// Process track - Update TPC-TRD alignment
// Updates:
if (track->GetTPCNcls()<kMinTPC) return; // minimal amount of clusters cut
// if (!friendTrack->GetTRDIn()) return;
// if (!track->IsOn(AliESDtrack::kTRDrefit)) return;
- if (!track->IsOn(AliESDtrack::kTRDout)) return;
+ if (!track->IsOn(AliVTrack::kTRDout)) return;
if (!track->GetInnerParam()) return;
if (!friendTrack->GetTPCOut()) return;
// exclude crossing track
AliTracker::PropagateTrackToBxByBz(&pTPC,kRefX,0.1,0.1,kFALSE);
AliExternalTrackParam *pTRDtrack = 0;
TObject *calibObject=0;
- for (Int_t l=0;(calibObject=((AliESDfriendTrack*)friendTrack)->GetCalibObject(l));++l) {
+ for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
if ((dynamic_cast< AliTPCseed*>(calibObject))) continue;
if ((pTRDtrack=dynamic_cast< AliExternalTrackParam*>(calibObject))) break;
}
}
-void AliTPCcalibTime::ProcessAlignTOF(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack){
+void AliTPCcalibTime::ProcessAlignTOF(AliVTrack *const track, const AliVfriendTrack *const friendTrack){
//
//
// Process track - Update TPC-TOF alignment
}
-void AliTPCcalibTime::FillResHistoTPC(const AliESDtrack * pTrack){
+void AliTPCcalibTime::FillResHistoTPC(const AliVTrack *pTrack){
//
// fill residual histograms pTPC - vertex
// Histogram is filled only for primary tracks
class TH2F;
class TH1D;
class TList;
-class AliESDEvent;
-class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
+class AliExternalTrackParam;
class AliTPCcalibLaser;
class TGraphErrors;
class AliSplineFit;
-class AliESDfriendTrack;
+//class AliESDfriendTrack;
+class AliVfriendTrack;
+class AliVfriendEvent;
class AliTPCcalibTime:public AliTPCcalibBase {
public:
AliTPCcalibTime(const Text_t *name, const Text_t *title, UInt_t StartTime, UInt_t EndTime, Int_t deltaIntegrationTimeVdrift, Int_t memoryMode=2);
virtual ~AliTPCcalibTime();
- virtual void Process(AliESDEvent *event);
+ virtual void Process(AliVEvent *event);
virtual Long64_t Merge(TCollection *const li);
virtual void Analyze();
//static Bool_t IsLaser (const AliESDEvent *const event) const;
//static Bool_t IsCosmics (const AliESDEvent *const event) const;
//static Bool_t IsBeam (const AliESDEvent *const event) const;
- void ProcessLaser (AliESDEvent *event);
- void ProcessCosmic(const AliESDEvent *const event);
- void ProcessBeam (const AliESDEvent *const event);
+ //void ProcessLaser (AliESDEvent *event);
+ //void ProcessCosmic(const AliESDEvent *const event);
+ //void ProcessBeam (const AliESDEvent *const event);
+ void ProcessLaser (AliVEvent *event);
+ void ProcessCosmic(const AliVEvent *const event);
+ void ProcessBeam (const AliVEvent *const event);
+
Bool_t IsPair(const AliExternalTrackParam *tr0, const AliExternalTrackParam *tr1);
- Bool_t IsCross(const AliESDtrack *const tr0, const AliESDtrack *const tr1);
- Bool_t IsSame (const AliESDtrack *const tr0, const AliESDtrack *const tr1);
- void ProcessSame(const AliESDtrack *const track, AliESDfriendTrack *const friendTrack, const AliESDEvent *const event);
- void ProcessAlignITS(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack, const AliESDEvent *const event, AliESDfriend *const ESDfriend);
- void ProcessAlignTRD(AliESDtrack* const track, const AliESDfriendTrack *const friendTrack);
- void ProcessAlignTOF(AliESDtrack* const track, const AliESDfriendTrack *const friendTrack);
+ Bool_t IsCross(const AliVTrack *const tr0, const AliVTrack *const tr1);
+ Bool_t IsSame (const AliVTrack *const tr0, const AliVTrack *const tr1);
+ void ProcessSame(const AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event);
+ void ProcessAlignITS(AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event, AliVfriendEvent *const friendEvent);
+ void ProcessAlignTRD(AliVTrack* const track, const AliVfriendTrack *const friendTrack);
+ void ProcessAlignTOF(AliVTrack* const track, const AliVfriendTrack *const friendTrack);
THnSparse* GetHistVdriftLaserA(Int_t index=1) const {return fHistVdriftLaserA[index];};
THnSparse* GetHistVdriftLaserC(Int_t index=1) const {return fHistVdriftLaserC[index];};
AliSplineFit* GetFitDrift(const char* name);
// TObjArray* GetFitDrift();
TH1F* GetCosmiMatchingHisto(Int_t index=0) const {return fCosmiMatchingHisto[index];};
- void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+ //void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
void Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
TObjArray* GetAlignITSTPC() const {return fAlignITSTPC;} // alignemnt array ITS TPC match
TObjArray* GetAlignTRDTPC() const {return fAlignTRDTPC;} // alignemnt array TRD TPC match
void BookDistortionMaps(); // book histograms
void FillResHistoTPCCE(const AliExternalTrackParam * pTPCIn, const AliExternalTrackParam * pTPCOut ); // fill residual histo
void FillResHistoTPCITS(const AliExternalTrackParam * pTPCIn, const AliExternalTrackParam * pITSOut ); // fill residual histo
- void FillResHistoTPC(const AliESDtrack * pTrack);
+ void FillResHistoTPC(const AliVTrack * pTrack);
void FillResHistoTPCTRD(const AliExternalTrackParam * pTPCOut, const AliExternalTrackParam * pTRDIn );
void FillResHistoTPCTOF(const AliExternalTrackParam * pTPCOut, const AliExternalTrackParam * pTOFIn );
#include "AliTPCclusterMI.h"
#include "AliTPCseed.h"
#include "AliESDVertex.h"
-#include "AliESDEvent.h"
+//#include "AliESDEvent.h"
#include "AliESDfriend.h"
-#include "AliESDInputHandler.h"
+//#include "AliESDInputHandler.h"
#include "AliAnalysisManager.h"
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendEvent.h"
+#include "AliVfriendTrack.h"
+
#include "AliTracker.h"
#include "AliMagF.h"
#include "AliTPCCalROC.h"
}
-void AliTPCcalibTimeGain::Process(AliESDEvent *event) {
+void AliTPCcalibTimeGain::Process(AliVEvent *event) {
//
// main track loop
//
+ //Printf("AliTPCcalibTimeGain::Process(event)...");
+
if (!event) {
- Printf("ERROR: ESD not available");
+ Printf("ERROR AliTPCcalibTimeGain::Process(): event not available");
return;
}
- AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!ESDfriend) {
+
+ AliVfriendEvent *friendEvent=event->FindFriend();
+
+ if (!friendEvent) {
+ Printf("ERROR AliTPCcalibTimeGain::Process(): friendEvent not available");
return;
}
- if (ESDfriend->TestSkipBit()) return;
+ //Printf("friendEvent->TestSkipBit() = %d",friendEvent->TestSkipBit() );
+ if (friendEvent->TestSkipBit()) {
+ return;
+ }
if (fIsCosmic) { // this should be removed at some point based on trigger mask !?
ProcessCosmicEvent(event);
ProcessBeamEvent(event);
}
-
-
-
}
-void AliTPCcalibTimeGain::ProcessCosmicEvent(AliESDEvent *event) {
+void AliTPCcalibTimeGain::ProcessCosmicEvent(AliVEvent *event) {
//
// Process in case of cosmic event
//
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!esdFriend) {
- Printf("ERROR: ESDfriend not available");
+ //Printf("AliTPCcalibTimeGain::ProcessCosmicEvent(event)...");
+
+ AliVfriendEvent *friendEvent=event->FindFriend();
+ if (!friendEvent) {
+ Printf("ERROR AliTPCcalibTimeGain::ProcessCosmicEvent(): ESDfriend not available");
return;
}
//
UInt_t time = event->GetTimeStamp();
- Int_t nFriendTracks = esdFriend->GetNumberOfTracks();
+ Int_t nFriendTracks = friendEvent->GetNumberOfTracks();
Int_t runNumber = event->GetRunNumber();
//
// track loop
//
for (Int_t i=0;i<nFriendTracks;++i) {
- AliESDtrack *track = event->GetTrack(i);
+ AliVTrack *track = event->GetVTrack(i);
if (!track) continue;
- AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
- if (!friendTrack) continue;
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+ if (!friendTrack) continue;
const AliExternalTrackParam * trackIn = track->GetInnerParam();
const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
if (!trackIn) continue;
-void AliTPCcalibTimeGain::ProcessBeamEvent(AliESDEvent *event) {
+void AliTPCcalibTimeGain::ProcessBeamEvent(AliVEvent *event) {
//
// Process in case of beam event
//
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- if (!esdFriend) {
- Printf("ERROR: ESDfriend not available");
+ //Printf("AliTPCcalibTimeGain::ProcessBeamEvent(event)...");
+
+ AliVfriendEvent *friendEvent=event->FindFriend();
+ if (!friendEvent) {
+ Printf("ERROR AliTPCcalibTimeGain::ProcessBeamEvent(): ESDfriend not available");
return;
}
//
UInt_t time = event->GetTimeStamp();
- Int_t nFriendTracks = esdFriend->GetNumberOfTracks();
+ if (!time) Printf("ERROR: no time stamp available!");
+ Int_t nFriendTracks = friendEvent->GetNumberOfTracks();
Int_t runNumber = event->GetRunNumber();
//
// track loop
//
for (Int_t i=0;i<nFriendTracks;++i) { // begin track loop
- AliESDtrack *track = event->GetTrack(i);
- if (!track) continue;
- AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
- if (!friendTrack) continue;
+ AliVTrack *track = event->GetVTrack(i);
+ if (!track) {Printf("***ERROR*** : track not available"); continue;}
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+ if (!friendTrack) {
+ Printf("ERROR ProcessBeamEvent(): friendTrack is not available!");
+ continue;
+ }
const AliExternalTrackParam * trackIn = track->GetInnerParam();
const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
if (TMath::Abs(trackIn->Eta()) > fCutEtaWindow) continue;
//
UInt_t status = track->GetStatus();
- if ((status&AliESDtrack::kTPCrefit)==0) continue;
- if ((status&AliESDtrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
+ if ((status&AliVTrack::kTPCrefit)==0) continue;
+ if ((status&AliVTrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
//
Float_t dca[2], cov[3];
track->GetImpactParameters(dca,cov);
if (TMath::Abs(dca[0]) > fCutMaxDcaXY || TMath::Abs(dca[0]) < 0.0000001) continue; // cut in xy
- if (((status&AliESDtrack::kITSrefit) == 1 && TMath::Abs(dca[1]) > 3.) || TMath::Abs(dca[1]) > fCutMaxDcaZ ) continue;
+ if (((status&AliVTrack::kITSrefit) == 1 && TMath::Abs(dca[1]) > 3.) || TMath::Abs(dca[1]) > fCutMaxDcaZ ) continue;
//
Double_t eta = trackIn->Eta();
fAlephParameters[4]);
tpcSignal /= corrFactor;
}
+ //Printf("Fill DeDx histo..");
fHistDeDxTotal->Fill(meanP, tpcSignal);
//
//dE/dx, time, type (1-muon cosmic,2-pion beam data, 3&4 protons), momenta, runNumner, eta
Double_t vec[7] = {tpcSignal,static_cast<Double_t>(time),static_cast<Double_t>(particleCase),meanDrift,meanP,static_cast<Double_t>(runNumber), eta};
+ //Printf("Fill Gain histo in track loop...");
fHistGainTime->Fill(vec);
}
// V0 loop -- in beam events the cosmic part of the histogram is filled with GammaConversions
//
for(Int_t iv0 = 0; iv0 < event->GetNumberOfV0s(); iv0++) {
- AliESDv0 * v0 = event->GetV0(iv0);
+ //AliESDv0 * v0 = event->GetV0(iv0);
+ AliESDv0 v0dummy;
+ event->GetV0(v0dummy, iv0);
+ AliESDv0 *v0 = &v0dummy;
+
+ if (!v0) Printf("ERROR AliTPCcalibTimeGain::ProcessBeamEvent(): ESDv0 not available! ");
+
if (!v0->GetOnFlyStatus()) continue;
if (v0->GetEffMass(0,0) > 0.02) continue; // select low inv. mass
Double_t xyz[3];
//
for(Int_t idaughter = 0; idaughter < 2; idaughter++) { // daughter loop
Int_t index = idaughter == 0 ? v0->GetPindex() : v0->GetNindex();
- AliESDtrack * trackP = event->GetTrack(index);
- AliESDfriendTrack *friendTrackP = esdFriend->GetTrack(index);
+ AliVTrack * trackP = event->GetVTrack(index);
+ if (!trackP) Printf("***ERROR*** trackP not available!");
+ const AliVfriendTrack *friendTrackP = friendEvent->GetTrack(index);
if (!friendTrackP) continue;
const AliExternalTrackParam * trackPIn = trackP->GetInnerParam();
const AliExternalTrackParam * trackPOut = friendTrackP->GetTPCOut();
Double_t tpcSignal = GetTPCdEdx(seed);
//dE/dx, time, type (1-muon cosmic,2-pion beam data), momenta
Double_t vec[6] = {tpcSignal,static_cast<Double_t>(time),1,meanDrift,meanP,static_cast<Double_t>(runNumber)};
- fHistGainTime->Fill(vec);
+ //Printf("Fill Gain histo in v0 loop...");
+ fHistGainTime->Fill(vec);
}
}
class TH2F;
class TList;
class TGraphErrors;
-class AliESDEvent;
-class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+//class AliESDtrack;
+class AliVTrack;
class AliTPCcalibLaser;
class AliTPCseed;
AliTPCcalibTimeGain(const Text_t *name, const Text_t *title, UInt_t StartTime, UInt_t EndTime, Int_t deltaIntegrationTimeGain);
virtual ~AliTPCcalibTimeGain();
//
- virtual void Process(AliESDEvent *event);
+ //virtual void Process(AliESDEvent *event);
+ virtual void Process(AliVEvent *event);
virtual Long64_t Merge(TCollection *li);
virtual void AnalyzeRun(Int_t minEntries);
//
- void ProcessCosmicEvent(AliESDEvent *event);
- void ProcessBeamEvent(AliESDEvent *event);
+ //void ProcessCosmicEvent(AliESDEvent *event);
+ //void ProcessBeamEvent(AliESDEvent *event);
+
+ void ProcessCosmicEvent(AliVEvent *event);
+ void ProcessBeamEvent(AliVEvent *event);
//
void CalculateBetheAlephParams(TH2F *hist, Double_t * ini);
static void BinLogX(THnSparse *h, Int_t axisDim);
//
AliTPCcalibTimeGain(const AliTPCcalibTimeGain&);
AliTPCcalibTimeGain& operator=(const AliTPCcalibTimeGain&);
- void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+ void Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
void Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
ClassDef(AliTPCcalibTimeGain, 2);
#include "AliMagF.h"
#include "AliTracker.h"
#include "AliESD.h"
-#include "AliESDtrack.h"
-#include "AliESDfriend.h"
-#include "AliESDfriendTrack.h"
+//#include "AliESDtrack.h"
+//#include "AliESDfriend.h"
+//#include "AliESDfriendTrack.h"
#include "AliTPCseed.h"
#include "AliTPCclusterMI.h"
#include "AliTPCROC.h"
class TTreeSRedirector;
class AliTPCROC;
class AliTPCseed;
-class AliESDtrack;
+//class AliESDtrack;
class AliTPCclusterMI;
class AliTPCcalibTracksCuts;
class AliTPCCalPad;
class TChain;
class TTree;
class TMutex;
-class AliESDEvent;
+//class AliESDEvent;
+class AliVEvent;
+class AliVTrack;
using namespace std;
virtual ~AliTPCcalibTracks(); // destructor
virtual void Process(AliTPCseed *track); // to be called by the Selector
- void Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);};
- void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+ //void Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);}
+ void Process(AliVEvent *event) {AliTPCcalibBase::Process(event);}
+ //void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
virtual Long64_t Merge(TCollection *li);
void AddHistos(AliTPCcalibTracks* calib);
void MakeResPlotsQTree(Int_t minEntries = 100, const char* pathName = "plots");
return 0;
}
-Int_t AliTPCcalibTracksCuts::AcceptTrack(const AliESDtrack * track) const {
+Int_t AliTPCcalibTracksCuts::AcceptTrack(const AliVTrack * track) const {
//
// Function, that decides wheather a given track is accepted for
// the analysis or not.
class TChain;
class AliTPCseed;
-class AliESDtrack;
+class AliVTrack;
using namespace std;
static AliTPCcalibTracksCuts *CreateCuts(char* ctype);
Int_t AcceptTrack(const AliTPCseed * track) const;
- Int_t AcceptTrack(const AliESDtrack * track) const;
+ Int_t AcceptTrack(const AliVTrack * track) const;
void SetMinClusters(Int_t minClusters){fMinClusters = minClusters;}
void SetMinRatio(Float_t minRatio){fMinRatio = minRatio;}
TLinearFitter* GetFitter(UInt_t segment, UInt_t padType, UInt_t fitType);
- void Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);};
- void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+ //void Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);}
+ void Process(AliVEvent *event) {AliTPCcalibBase::Process(event);}
+ //void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
public:
//
#include "AliMagF.h"
#include "AliTracker.h"
-#include "AliESDEvent.h"
+//#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliESDfriend.h"
-#include "AliESDfriendTrack.h"
+#include "AliESDfriendTrack.h"
+#include "AliESDVertex.h"
+
+#include "AliVEvent.h"
+#include "AliVTrack.h"
+#include "AliVfriendTrack.h"
+#include "AliVfriendEvent.h"
+
#include "AliMathBase.h"
#include "AliTPCseed.h"
#include "AliTPCclusterMI.h"
fV0Tree(0),
fHPTTree(0),
fStack(0),
- fESD(0),
+ fEvent(0),
fPdg(0),
fParticles(0),
fV0s(0),
fV0Tree(0),
fHPTTree(0),
fStack(0),
- fESD(0),
+ fEvent(0),
fPdg(0),
fParticles(0),
fV0s(0),
-void AliTPCcalibV0::ProcessESD(AliESDEvent *esd){
+void AliTPCcalibV0::ProcessESD(AliVEvent *event){
//
//
//
- fESD = esd;
- AliKFParticle::SetField(esd->GetMagneticField());
+ fEvent = event;
+ AliKFParticle::SetField(event->GetMagneticField());
if (TMath::Abs(AliTracker::GetBz())<1) return;
- DumpToTree(esd);
- DumpToTreeHPT(esd);
+ DumpToTree(event);
+ DumpToTreeHPT(event);
}
-void AliTPCcalibV0::DumpToTreeHPT(AliESDEvent *esd){
+void AliTPCcalibV0::DumpToTreeHPT(AliVEvent *event){
//
// Dump V0s fith full firend information to the
//
if (TMath::Abs(AliTracker::GetBz())<1) return;
const Int_t kMinCluster=110;
const Float_t kMinPt =4.;
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
+ AliVfriendEvent *friendEvent=event->FindFriend();
// if (!esdFriend) {
// Printf("ERROR: esdFriend not available");
// return;
// }
//
- Int_t ntracks=esd->GetNumberOfTracks();
+ Int_t ntracks=event->GetNumberOfTracks();
for (Int_t i=0;i<ntracks;++i) {
Bool_t isOK=kFALSE;
- AliESDtrack *track = esd->GetTrack(i);
+ AliVTrack *track = event->GetVTrack(i);
if (track->GetTPCncls()<kMinCluster) continue;
if (TMath::Abs(AliTracker::GetBz())>1){ // cut on momenta if measured
if (track->Pt()>kMinPt) isOK=kTRUE;
}
if (TMath::Abs(AliTracker::GetBz())<1){ // require primary track for the B field OFF data
Bool_t isAccepted=kTRUE;
- if (!track->IsOn(AliESDtrack::kITSrefit)) isAccepted=kFALSE;
- if (!track->IsOn(AliESDtrack::kTPCrefit)) isAccepted=kFALSE;
- if (!track->IsOn(AliESDtrack::kTOFout)) isAccepted=kFALSE;
+ if (!track->IsOn(AliVTrack::kITSrefit)) isAccepted=kFALSE;
+ if (!track->IsOn(AliVTrack::kTPCrefit)) isAccepted=kFALSE;
+ if (!track->IsOn(AliVTrack::kTOFout)) isAccepted=kFALSE;
Float_t dvertex[2],cvertex[3];
track->GetImpactParametersTPC(dvertex,cvertex);
if (TMath::Abs(dvertex[0]/TMath::Sqrt(cvertex[0]+0.01))>20) isAccepted=kFALSE;
if (!isAccepted) isOK=kFALSE;
}
if ( track->GetTPCsignal()>100 && track->GetInnerParam()->Pt()>1 ){
- if (track->IsOn(AliESDtrack::kITSin)||track->IsOn(AliESDtrack::kTRDout)||track->IsOn(AliESDtrack::kTOFin))
+ if (track->IsOn(AliVTrack::kITSin)||track->IsOn(AliVTrack::kTRDout)||track->IsOn(AliVTrack::kTOFin))
isOK=kTRUE;
if (isOK){
TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
- Int_t eventNumber = esd->GetEventNumberInFile();
- Bool_t hasFriend=(esdFriend) ? (esdFriend->GetTrack(i)!=0):0;
+ Int_t eventNumber = event->GetEventNumberInFile();
+ Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(i)!=0):0;
Bool_t hasITS=(track->GetNcls(0)>2);
printf("DUMPIONTrack:%s|%f|%d|%d|%d\n",filename.Data(),track->GetInnerParam()->Pt()*track->GetTPCsignal()/50., eventNumber,hasFriend,hasITS);
}
}
if (!isOK) continue;
TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
- Int_t eventNumber = esd->GetEventNumberInFile();
- Bool_t hasFriend=(esdFriend) ? (esdFriend->GetTrack(i)!=0):0;
+ Int_t eventNumber = event->GetEventNumberInFile();
+ Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(i)!=0):0;
Bool_t hasITS=(track->GetNcls(0)>2);
printf("DUMPHPTTrack:%s|%f|%d|%d|%d\n",filename.Data(),track->Pt(), eventNumber,hasFriend,hasITS);
//
- if (!esdFriend) continue;
- AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+ if (!friendEvent) continue;
+ const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
if (!friendTrack) continue;
if (!isOK) continue;
fHPTTree = new TTree("HPT","HPT");
fHPTTree->SetDirectory(0);
}
+
+ //**********************TEMPORARY!!*******************************************
+ // more investigation is needed with Tree ///!!!
+ //all dummy stuff here is just for code to compile and work with ESD
+
+ AliESDfriendTrack *dummyfriendTrack=(AliESDfriendTrack*)friendTrack;
+ AliESDtrack *dummytrack=(AliESDtrack*)track;
+
+
if (fHPTTree->GetEntries()==0){
//
fHPTTree->SetDirectory(0);
- fHPTTree->Branch("t.",&track);
- fHPTTree->Branch("ft.",&friendTrack);
+ fHPTTree->Branch("t.",&dummytrack);
+ fHPTTree->Branch("ft.",&dummyfriendTrack);
fHPTTree->Branch("s.",&seed);
}else{
- fHPTTree->SetBranchAddress("t.",&track);
- fHPTTree->SetBranchAddress("ft.",&friendTrack);
+ fHPTTree->SetBranchAddress("t.",&dummytrack);
+ fHPTTree->SetBranchAddress("ft.",&dummyfriendTrack);
fHPTTree->SetBranchAddress("s.",&seed);
}
fHPTTree->Fill();
-void AliTPCcalibV0::DumpToTree(AliESDEvent *esd){
+void AliTPCcalibV0::DumpToTree(AliVEvent *event){
//
// Dump V0s fith full firend information to the
//
- Int_t nV0s = fESD->GetNumberOfV0s();
+ Int_t nV0s = fEvent->GetNumberOfV0s();
const Int_t kMinCluster=110;
const Double_t kDownscale=0.01;
const Float_t kMinPt =1.0;
const Float_t kMinMinPt =0.7;
- AliESDfriend *esdFriend=static_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
+ AliVfriendEvent *friendEvent=event->FindFriend();
//
for (Int_t ivertex=0; ivertex<nV0s; ivertex++){
Bool_t isOK=kFALSE;
- AliESDv0 * v0 = (AliESDv0*) esd->GetV0(ivertex);
- AliESDtrack * track0 = fESD->GetTrack(v0->GetIndex(0)); // negative track
- AliESDtrack * track1 = fESD->GetTrack(v0->GetIndex(1)); // positive track
+ AliESDv0 dummyv0;
+ event->GetV0(dummyv0,ivertex);
+ AliESDv0 *v0=&dummyv0;
+
+ AliVTrack * track0 = fEvent->GetVTrack(v0->GetIndex(0)); // negative track
+ AliVTrack * track1 = fEvent->GetVTrack(v0->GetIndex(1)); // positive track
if (track0->GetTPCNcls()<kMinCluster) continue;
if (track0->GetKinkIndex(0)>0) continue;
if (track1->GetTPCNcls()<kMinCluster) continue;
if (!isOK) continue;
//
TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
- Int_t eventNumber = esd->GetEventNumberInFile();
+ Int_t eventNumber = event->GetEventNumberInFile();
Bool_t hasITS=(track0->GetNcls(0)+ track1->GetNcls(0)>4);
- printf("DUMPHPTV0:%s|%f|%d|%d|%d\n",filename.Data(), (TMath::Min(track0->Pt(),track1->Pt())), eventNumber,(esdFriend!=0), hasITS);
+ printf("DUMPHPTV0:%s|%f|%d|%d|%d\n",filename.Data(), (TMath::Min(track0->Pt(),track1->Pt())), eventNumber,(friendEvent!=0), hasITS);
//
- if (!esdFriend) continue;
+ if (!friendEvent) continue;
//
//
- AliESDfriendTrack *ftrack0 = esdFriend->GetTrack(v0->GetIndex(0));
+ const AliVfriendTrack *ftrack0 = friendEvent->GetTrack(v0->GetIndex(0));
if (!ftrack0) continue;
- AliESDfriendTrack *ftrack1 = esdFriend->GetTrack(v0->GetIndex(1));
+ const AliVfriendTrack *ftrack1 = friendEvent->GetTrack(v0->GetIndex(1));
if (!ftrack1) continue;
//
TObject *calibObject;
fV0Tree = new TTree("V0s","V0s");
fV0Tree->SetDirectory(0);
}
+
+ //**********************TEMPORARY!!*******************************************
+ // more investigation is needed with Tree ///!!!
+ //all dummy stuff here is just for code to compile and work with ESD
+
+ AliESDfriendTrack *dummyftrack0=(AliESDfriendTrack*)ftrack0;
+ AliESDfriendTrack *dummyftrack1=(AliESDfriendTrack*)ftrack1;
+ AliESDtrack *dummytrack0=(AliESDtrack*)track0;
+ AliESDtrack *dummytrack1=(AliESDtrack*)track1;
+
if (fV0Tree->GetEntries()==0){
//
fV0Tree->SetDirectory(0);
fV0Tree->Branch("v0.",&v0);
- fV0Tree->Branch("t0.",&track0);
- fV0Tree->Branch("t1.",&track1);
- fV0Tree->Branch("ft0.",&ftrack0);
- fV0Tree->Branch("ft1.",&ftrack1);
+ fV0Tree->Branch("t0.",&dummytrack0);
+ fV0Tree->Branch("t1.",&dummytrack1);
+ fV0Tree->Branch("ft0.",&dummyftrack0);
+ fV0Tree->Branch("ft1.",&dummyftrack1);
fV0Tree->Branch("s0.",&seed0);
fV0Tree->Branch("s1.",&seed1);
}else{
fV0Tree->SetBranchAddress("v0.",&v0);
- fV0Tree->SetBranchAddress("t0.",&track0);
- fV0Tree->SetBranchAddress("t1.",&track1);
- fV0Tree->SetBranchAddress("ft0.",&ftrack0);
- fV0Tree->SetBranchAddress("ft1.",&ftrack1);
+ fV0Tree->SetBranchAddress("t0.",&dummytrack0);
+ fV0Tree->SetBranchAddress("t1.",&dummytrack1);
+ fV0Tree->SetBranchAddress("ft0.",&dummyftrack0);
+ fV0Tree->SetBranchAddress("ft1.",&dummyftrack1);
fV0Tree->SetBranchAddress("s0.",&seed0);
fV0Tree->SetBranchAddress("s1.",&seed1);
}
-void AliTPCcalibV0::FilterV0s(AliESDEvent* event){
+void AliTPCcalibV0::FilterV0s(AliVEvent *event){
//
//
TDatabasePDG pdg;
const Double_t ptCut=0.2;
const Int_t kMinNcl=110;
//
- Int_t nv0 = event->GetNumberOfV0s();
- AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+ Int_t nv0 = event->GetNumberOfV0s();
+ //AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
+ //AliKFVertex kfvertex=*vertex;
+
+ //AliESDVertex vtx;
+ //event->GetPrimaryVertex(vtx);
+ //AliESDVertex *vertex=&vtx;
+ //AliKFVertex *kfvertex=(AliKFVertex*)vertex;
+
+ AliESDVertex vtx;
+ event->GetPrimaryVertex(vtx);
+ AliESDVertex *vertex=&vtx;
AliKFVertex kfvertex=*vertex;
+
//
for (Int_t iv0=0;iv0<nv0;iv0++){
- AliESDv0 *v0 = event->GetV0(iv0);
+ AliESDv0 dummyv0;
+ event->GetV0(dummyv0,iv0);
+ AliESDv0 *v0=&dummyv0;
+
if (!v0) continue;
if (v0->GetPindex()<0) continue;
if (v0->GetNindex()<0) continue;
Double_t sign= v0->GetParamP()->GetSign()* v0->GetParamN()->GetSign();
if (sign<0&&v0->GetOnFlyStatus()>0.5&&maxPt>ptCut&&isV0){
- AliESDtrack * trackP = event->GetTrack(v0->GetPindex());
- AliESDtrack * trackN = event->GetTrack(v0->GetNindex());
+ AliVTrack * trackP = event->GetVTrack(v0->GetPindex());
+ AliVTrack * trackN = event->GetVTrack(v0->GetNindex());
if (!trackN) continue;
if (!trackP) continue;
Int_t nclP= (Int_t)trackP->GetTPCClusterInfo(2,1);
"tp.="<<trackP<<
"tm.="<<trackN<<
//
- "v.="<<vertex<<
+ //"v.="<<vertex<<
"ncls="<<ncls<<
"maxPt="<<maxPt<<
"\n";
class TTreeSRedirector;
class AliTPCROC;
class AliTPCseed;
-class AliESDtrack;
-class AliESDEvent;
+//class AliESDtrack;
+//class AliESDEvent;
+class AliVEvent;
+class AliVTrack;
class TH3F;
class TH1F;
class TH2F;
AliTPCcalibV0();
AliTPCcalibV0(const Text_t *name, const Text_t *title);
virtual ~AliTPCcalibV0();
- virtual void Process(AliESDEvent *event) {return ProcessESD(event);}
- void FilterV0s(AliESDEvent* event);
+ virtual void Process(AliVEvent *event) {return ProcessESD(event);}
+ void FilterV0s(AliVEvent* event);
Long64_t Merge(TCollection *const li);
void AddTree(TTree * treeInput);
void AddTreeHPT(TTree * treeInput);
//
//
//
- void ProcessESD(AliESDEvent *esd);
- void DumpToTree(AliESDEvent *esd);
- void DumpToTreeHPT(AliESDEvent *esd);
+ void ProcessESD(AliVEvent *event);
+ void DumpToTree(AliVEvent *event);
+ void DumpToTreeHPT(AliVEvent *event);
TTree * GetV0Tree(){return fV0Tree;}
TTree * GetHPTTree(){return fHPTTree;}
//
TTree *fHPTTree; // tree with high mometa tracks - full calib info
//
AliStack *fStack; // pointer to kinematic tree
- AliESDEvent *fESD; //! current ED to proccess - NOT OWNER
+ AliVEvent *fEvent; //! current ED to proccess - NOT OWNER
TDatabasePDG *fPdg; //! particle database
TObjArray *fParticles; // array of selected MC particles
TObjArray *fV0s; // array of V0s
TObjArray *fGammas; // gamma conversion candidates
//
- void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);};
+ //void Process(AliESDtrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
void Process(AliTPCseed *track){return AliTPCcalibBase::Process(track);}
//
ClassDef(AliTPCcalibV0,3);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff