#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),
- fEvent(0),
- fEventFriend(0),
+ fESD(0),
+ fESDfriend(0),
fDebugOutputPath("")
{
//
AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib(const char *name)
:AliAnalysisTask(name,""),
fCalibJobs(0),
- fEvent(0),
- fEventFriend(0),
+ fESD(0),
+ fESDfriend(0),
fDebugOutputPath("")
{
//
//
// Exec function
// Loop over tracks and call Process function
- //Printf("AliTPCAnalysisTaskcalib::Exec()...");
-
- if (!fEvent) {
- Printf("ERROR AliTPCAnalysisTaskcalib::Exec(): fEvent not available");
+ if (!fESD) {
+ //Printf("ERROR: fESD not available");
return;
}
- fEventFriend=fEvent->FindFriend();
- //fESDfriend=fESD->FindFriend();
- Int_t n=fEvent->GetNumberOfTracks();
- Process(fEvent);
- if (!fEventFriend) {
- //Printf("ERROR AliTPCAnalysisTaskcalib::Exec(): fEventFriend not available");
+ fESDfriend=static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));
+ Int_t n=fESD->GetNumberOfTracks();
+ Process(fESD);
+ if (!fESDfriend) {
+ //Printf("ERROR: fESDfriend not available");
return;
}
- if (fEventFriend->TestSkipBit()) return;
+ if (fESDfriend->TestSkipBit()) return;
//
- Int_t run = fEvent->GetRunNumber();
+ Int_t run = fESD->GetRunNumber();
for (Int_t i=0;i<n;++i) {
- const AliVfriendTrack *friendTrack=fEventFriend->GetTrack(i);
- AliVTrack *track=fEvent->GetVTrack(i);
+ AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(i);
+ AliESDtrack *track=fESD->GetTrack(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());
- AliVEventHandler *esdH = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
+ AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
if (!esdH) {
- Printf("ERROR: Could not get ESDInputHandler");
+ //Printf("ERROR: Could not get ESDInputHandler");
}
else {
- fEvent = esdH->GetEvent();
+ fESD = esdH->GetEvent();
//Printf("*** CONNECTED NEW EVENT ****");
}
}
}
-void AliTPCAnalysisTaskcalib::Process(AliVEvent *event) {
+void AliTPCAnalysisTaskcalib::Process(AliESDEvent *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(AliVTrack *track, Int_t run) {
+void AliTPCAnalysisTaskcalib::Process(AliESDtrack *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 AliVEvent;
-class AliVTrack;
-class AliVfriendEvent;
-
+class AliESDEvent;
+class AliESDtrack;
+class AliESDfriend;
class AliTPCseed;
class AliTPCAnalysisTaskcalib:public AliAnalysisTask {
virtual void FinishTaskOutput();
void SetDebugOuputhPath(const char * name){fDebugOutputPath=name;}
protected:
- virtual void Process(AliVEvent *event);
+ virtual void Process(AliESDEvent *event);
virtual void Process(AliTPCseed *track);
- virtual void Process(AliVTrack *track, Int_t run);
+ virtual void Process(AliESDtrack *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?
- AliVEvent *fEvent; //! current event
- AliVfriendEvent *fEventFriend; //! current event friend
+ AliESDEvent *fESD; //! current esd
+ AliESDfriend *fESDfriend; //! current esd 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(AliVEvent *event) {
+void AliTPCcalibAlign::Process(AliESDEvent *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"));
- AliVfriendEvent *friendEvent=event->FindFriend();
- if (!friendEvent) return;
- if (friendEvent->TestSkipBit()) return;
+ AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!eESDfriend) return;
+ if (eESDfriend->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) {
- AliVTrack *track0 = event->GetVTrack(i0);
- if(!track0) continue;
- //AliESDfriendTrack *friendTrack = 0;
+ AliESDtrack *track0 = event->GetTrack(i0);
+ AliESDfriendTrack *friendTrack = 0;
TObject *calibObject=0;
AliTPCseed *seed0 = 0;
//
- //friendTrack = (AliESDfriendTrack *)friendEvent->GetTrack(i0);;
- const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i0);;
+ friendTrack = (AliESDfriendTrack *)eESDfriend->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=const_cast<AliVfriendTrack*>(friendTrack);
+ fCurrentFriendTrack=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) {
- AliVTrack *track0 = event->GetVTrack(i0);
- if(!track0) continue;
+ AliESDtrack *track0 = event->GetTrack(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;
- AliVTrack *track1 = event->GetVTrack(i1);
- if(!track1) continue;
+ AliESDtrack *track1 = event->GetTrack(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; ///!!! then it was used twice, cannot be const pointer
+ AliESDfriendTrack *friendTrack = 0;
TObject *calibObject=0;
AliTPCseed *seed0 = 0,*seed1=0;
//
- const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(i0);;
- if (!friendTrack0) continue;
- for (Int_t l=0;(calibObject=friendTrack0->GetCalibObject(l));++l) {
+ friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(i0);;
+ if (!friendTrack) continue;
+ for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
if ((seed0=dynamic_cast<AliTPCseed*>(calibObject))) break;
}
- const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(i1);;
- if (!friendTrack1) continue;
- for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
+ friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(i1);;
+ if (!friendTrack) continue;
+ for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
if ((seed1=dynamic_cast<AliTPCseed*>(calibObject))) break;
}
if (!seed0) continue;
}
}
-void AliTPCcalibAlign::ExportTrackPoints(AliVEvent *event){
+void AliTPCcalibAlign::ExportTrackPoints(AliESDEvent *event){
//
// Export track points for alignment - calibration
// export space points for pairs of tracks if possible
//
- //AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- AliVfriendEvent *friendEvent=event->FindFriend();
-
- if (!friendEvent) return;
+ AliESDfriend *eESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!eESDfriend) 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
- AliESDVertex *tpcVertex;
- AliESDVertex tpcVtx;
+ const AliESDVertex *tpcVertex = 0;
// get the primary vertex TPC
if (ntracks>kMinVertexTracks) {
- event->GetPrimaryVertexSPD(tpcVtx);
- tpcVertex=&tpcVtx;
- //event->GetPrimaryVertexSPD(tpcVertex);
+ tpcVertex = event->GetPrimaryVertexSPD();
if (tpcVertex->GetNContributors()<kMinVertexTracks) tpcVertex=0;
}
//
Int_t index0=0,index1=0;
//
for (Int_t i0=0;i0<ntracks;++i0) {
- AliVTrack *track0 = event->GetVTrack(i0);
+ AliESDtrack *track0 = event->GetTrack(i0);
if (!track0) continue;
- if ((track0->GetStatus() & AliVTrack::kTPCrefit)==0) continue;
-
- AliExternalTrackParam trck0Out;
- track0->GetTrackParamOp(trck0Out);
- if ( (track0->GetTrackParamOp(trck0Out)) < 0) continue;
- AliExternalTrackParam * track0Out = &trck0Out;
- if (!track0Out) continue;
-
- AliExternalTrackParam trck0In;
- track0->GetTrackParamIp(trck0In);
- if((track0->GetTrackParamIp(trck0In)) < 0) continue;
- AliExternalTrackParam * track0In = &trck0In;
- if (!track0In) continue;
-
- if (TMath::Abs(track0In->GetSigned1Pt()-track0Out->GetSigned1Pt())>kDist1Pt) continue;
- if (TMath::Abs(track0In->GetSigned1Pt())>kDist1Pt) continue;
- if (TMath::Abs(track0In->GetTgl()-track0Out->GetTgl())>kDistThS) continue;
- AliVTrack *track1P = 0;
+ if ((track0->GetStatus() & AliESDtrack::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;
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;
- AliVTrack *track1 = event->GetVTrack(i1);
+ AliESDtrack *track1 = event->GetTrack(i1);
if (!track1) continue;
- if ((track1->GetStatus() & AliVTrack::kTPCrefit)==0) continue;
-
- AliExternalTrackParam trck1Out;
- track1->GetTrackParamOp(trck1Out);
- if((track1->GetTrackParamOp(trck1Out)) < 0) continue;
- AliExternalTrackParam * track1Out = &trck1Out;
- if (!track1Out) continue;
-
- AliExternalTrackParam trck1In;
- track1->GetTrackParamIp(trck1In);
- if((track1->GetTrackParamIp(trck1In)) < 0) continue;
- AliExternalTrackParam * track1In = &trck1In;
- if (!track1In) continue;
-
+ if ((track1->GetStatus() & AliESDtrack::kTPCrefit)==0) continue;
+ if (track1->GetOuterParam()==0) continue;
+ if (track1->GetInnerParam()==0) continue;
if (track1->GetTPCNcls()<kminCl) continue;
- if (TMath::Abs(track1In->GetSigned1Pt()-track1Out->GetSigned1Pt())>kDist1Pt) continue;
- if (TMath::Abs(track1In->GetTgl()-track1Out->GetTgl())>kDistThS) continue;
- if (TMath::Abs(track1In->GetSigned1Pt())>kDist1Pt) continue;
+ if (TMath::Abs(track1->GetInnerParam()->GetSigned1Pt()-track1->GetOuterParam()->GetSigned1Pt())>kDist1Pt) continue;
+ if (TMath::Abs(track1->GetInnerParam()->GetTgl()-track1->GetOuterParam()->GetTgl())>kDistThS) continue;
+ if (TMath::Abs(track1->GetInnerParam()->GetSigned1Pt())>kDist1Pt) continue;
//track1->GetImpactParameters(dca1[0],dca1[1]);
//if (TMath::Abs(dca1[0]-dca0[0])>kDistY) continue;
//if (TMath::Abs(dca1[1]-dca0[1])>kDistZ) continue;
track1P = track1;
index1=i1;
}
- //AliESDfriendTrack *friendTrack = 0;
+ AliESDfriendTrack *friendTrack = 0;
TObject *calibObject=0;
AliTPCseed *seed0 = 0,*seed1=0;
//
- //friendTrack = (AliESDfriendTrack *)friendEvent->GetTrack(index0);;
- const AliVfriendTrack *friendTrack = friendEvent->GetTrack(index0);;
+ friendTrack = (AliESDfriendTrack *)eESDfriend->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){
- const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(index1);;
- if (!friendTrack1) continue;
- for (Int_t l=0;(calibObject=friendTrack1->GetCalibObject(l));++l) {
+ friendTrack = (AliESDfriendTrack *)eESDfriend->GetTrack(index1);;
+ if (!friendTrack) continue;
+ for (Int_t l=0;(calibObject=friendTrack->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 param;
- AliExternalTrackParam *p0In = ¶m;
- AliExternalTrackParam *p1In = ¶m;
- AliExternalTrackParam *p0Out = ¶m;
- AliExternalTrackParam *p1Out = ¶m;
+ static AliExternalTrackParam dummy;
+ AliExternalTrackParam *p0In = &dummy;
+ AliExternalTrackParam *p1In = &dummy;
+ AliExternalTrackParam *p0Out = &dummy;
+ AliExternalTrackParam *p1Out = &dummy;
AliESDVertex vdummy;
AliESDVertex *pvertex= (tpcVertex)? (AliESDVertex *)tpcVertex: &vdummy;
if (track0) {
- //p0In= new AliExternalTrackParam(*track0);
- p0In->CopyFromVTrack(track0);
-
- AliExternalTrackParam trckOut;
- track0->GetTrackParamOp(trckOut);
- AliExternalTrackParam * trackout = &trckOut;
- p0Out=new AliExternalTrackParam(*trackout);
+ p0In= new AliExternalTrackParam(*track0);
+ p0Out=new AliExternalTrackParam(*(track0->GetOuterParam()));
}
if (track1P) {
- //p1In= new AliExternalTrackParam(*track1P);
- p1In->CopyFromVTrack(track1P);
-
- AliExternalTrackParam trck1POut;
- track1P->GetTrackParamOp(trck1POut);
- AliExternalTrackParam * track1POut = &trck1POut;
- p1Out=new AliExternalTrackParam(*track1POut);
+ p1In= new AliExternalTrackParam(*track1P);
+ p1Out=new AliExternalTrackParam(*(track1P->GetOuterParam()));
}
(*cstream)<<"trackPoints"<<
// 4. Combine In and Out track - - fil cluster residuals
//
if (!fCurrentFriendTrack) return;
-
- AliExternalTrackParam trckTPCOut;
- fCurrentFriendTrack->GetTrackParamTPCOut(trckTPCOut);
- if((fCurrentFriendTrack->GetTrackParamTPCOut(trckTPCOut)) < 0) return;
- AliExternalTrackParam * trackTPCOut = &trckTPCOut;
- if (!trackTPCOut) return;
+ if (!fCurrentFriendTrack->GetTPCOut()) return;
const Double_t kPtCut=1.0; // pt
const Double_t kSnpCut=0.2; // snp cut
const Double_t kNclCut=120; //
Int_t detector=-1;
//
//
- //AliExternalTrackParam trackIn = *(fCurrentTrack->GetInnerParam());
- AliExternalTrackParam trackIn;
- fCurrentTrack->GetTrackParamIp(trackIn);
- //AliExternalTrackParam trackOut = *(fCurrentFriendTrack->GetTPCOut());
- AliExternalTrackParam trackOut;
- fCurrentFriendTrack->GetTrackParamTPCOut(trackOut);
-
+ AliExternalTrackParam trackIn = *(fCurrentTrack->GetInnerParam());
+ AliExternalTrackParam trackOut = *(fCurrentFriendTrack->GetTPCOut());
trackIn.ResetCovariance(10);
trackOut.ResetCovariance(10);
Double_t *covarIn = (Double_t*)trackIn.GetCovariance();
Double_t alpha =2.*TMath::Pi()*(isec%18+0.5)/18.;
Double_t scos=TMath::Cos(alpha);
Double_t ssin=TMath::Sin(alpha);
- AliESDVertex vtx;
- fCurrentEvent->GetPrimaryVertexTracks(vtx);
- const AliESDVertex* vertex=&vtx;
-
+ const AliESDVertex* vertex = fCurrentEvent->GetPrimaryVertexTracks();
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(AliVEvent *event);
+ void Process(AliESDEvent *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(AliVEvent *event);
+ void ExportTrackPoints(AliESDEvent *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(AliVTrack *const track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliESDtrack *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(AliVEvent * event){
+void AliTPCcalibBase::UpdateEventInfo(AliESDEvent * event){
//
//
//
}
-Bool_t AliTPCcalibBase::HasLaser(AliVEvent *event){
+Bool_t AliTPCcalibBase::HasLaser(AliESDEvent *event){
//
//
//
#include "TNamed.h"
#include "TObjString.h"
class AliTPCseed;
-//class AliESDEvent;
-class AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
-//class AliESDfriendTrack;
-class AliVfriendTrack;
+class AliESDEvent;
+class AliESDtrack;
+class AliESDfriendTrack;
class TCollection;
class TTreeSRedirector;
class TGraph;
AliTPCcalibBase(const AliTPCcalibBase&calib);
AliTPCcalibBase &operator=(const AliTPCcalibBase&calib);
virtual ~AliTPCcalibBase();
- 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 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 Long64_t Merge(TCollection */*li*/){return 0;}
virtual void Analyze(){return;}
virtual void Terminate();
- virtual void UpdateEventInfo(AliVEvent * event);
+ virtual void UpdateEventInfo(AliESDEvent * 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(AliVEvent *event);
+ static Bool_t HasLaser(AliESDEvent *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
- AliVEvent *fCurrentEvent; //! current event
- AliVTrack *fCurrentTrack; //! current esd track
- AliVfriendTrack *fCurrentFriendTrack; //! current friend track
+ AliESDEvent *fCurrentEvent; //! current event
+ AliESDtrack *fCurrentTrack; //! current esd track
+ AliESDfriendTrack *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 "AliVEvent.h"
-#include "AliVfriendEvent.h"
-#include "AliVTrack.h"
-#include "AliVfriendTrack.h"
-
+#include "AliESDEvent.h"
+#include "AliESDfriend.h"
+#include "AliESDtrack.h"
#include "AliTracker.h"
#include "AliTPCClusterParam.h"
#include "AliTPCParam.h"
}
-void AliTPCcalibCalib::Process(AliVEvent *event){
+void AliTPCcalibCalib::Process(AliESDEvent *event){
//
//
//
if (!event) {
return;
}
- //AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
- AliVfriendEvent *friendEvent=event->FindFriend();
- if (!friendEvent) {
+ AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!ESDfriend) {
return;
}
- if (friendEvent->TestSkipBit()) return;
+ if (ESDfriend->TestSkipBit()) return;
if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
- Int_t ntracks=friendEvent->GetNumberOfTracks();
+ Int_t ntracks=ESDfriend->GetNumberOfTracks();
//AliTPCcalibDB::Instance()->SetExBField(fMagF);
//
//
for (Int_t i=0;i<ntracks;++i) {
- AliVTrack *track = event->GetVTrack(i);
- if(!track) continue;
- const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+ AliESDtrack *track = event->GetTrack(i);
+ AliESDfriendTrack *friendTrack = (AliESDfriendTrack*) ESDfriend->GetTrack(i);
if (!friendTrack) continue;
//track->SetFriendTrack(friendTrack);
- fCurrentFriendTrack=const_cast<AliVfriendTrack*>(friendTrack);
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- if((track->GetTrackParamIp(trckIn)) < 0) continue;
- const AliExternalTrackParam * trackIn = &trckIn;
+ fCurrentFriendTrack=friendTrack;
+ const AliExternalTrackParam * trackIn = track->GetInnerParam();
+ const AliExternalTrackParam * trackOut = track->GetOuterParam();
+ AliExternalTrackParam * tpcOut = (AliExternalTrackParam *)friendTrack->GetTPCOut();
if (!trackIn) continue;
-
- AliExternalTrackParam trckOut;
- track->GetTrackParamOp(trckOut);
- if((track->GetTrackParamOp(trckOut)) < 0) continue;
- const AliExternalTrackParam * trackOut = &trckOut;
if (!trackOut) continue;
-
- AliExternalTrackParam prmtpcOut;
- friendTrack->GetTrackParamTPCOut(prmtpcOut);
- if((friendTrack->GetTrackParamTPCOut(prmtpcOut)) < 0) continue;
- AliExternalTrackParam * tpcOut = &prmtpcOut;
- if (!tpcOut) continue;
+ if (!tpcOut) continue;
TObject *calibObject;
AliTPCseed *seed = 0;
for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
}
if (!seed) continue;
RefitTrack(track, seed, event->GetMagneticField());
-
- AliExternalTrackParam prmOut;
- track->GetTrackParamOp(prmOut);
- AliExternalTrackParam * paramOut = &prmOut;
- (*tpcOut)=*paramOut;
+ (*tpcOut)=*(track->GetOuterParam());
}
return;
}
-Bool_t AliTPCcalibCalib::RefitTrack(AliVTrack *track, AliTPCseed *seed, Float_t magesd){
+Bool_t AliTPCcalibCalib::RefitTrack(AliESDtrack * track, AliTPCseed *seed, Float_t magesd){
//
// Refit track
// if magesd==0 forget the curvature
static Int_t streamCounter=0;
streamCounter++;
- AliVfriendTrack *friendTrack = fCurrentFriendTrack;
+ AliESDfriendTrack *friendTrack = fCurrentFriendTrack;
AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
AliTPCParam *param = AliTPCcalibDB::Instance()->GetParameters();
//
// And now do refit
//
- AliExternalTrackParam trckOld;
- track->GetTrackParamIp(trckOld);
- AliExternalTrackParam * trackInOld = &trckOld;
-
- AliExternalTrackParam trckOuter;
- track->GetTrackParamOp(trckOuter);
- AliExternalTrackParam * trackOuter = &trckOuter;
-
- AliExternalTrackParam trckOutOld;
- friendTrack->GetTrackParamTPCOut(trckOutOld);
- AliExternalTrackParam * trackOutOld = &trckOutOld;
+ AliExternalTrackParam * trackInOld = (AliExternalTrackParam*)track->GetInnerParam();
+ AliExternalTrackParam * trackOuter = (AliExternalTrackParam*)track->GetOuterParam();
+ AliExternalTrackParam * trackOutOld = (AliExternalTrackParam *)friendTrack->GetTPCOut();
Double_t mass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
+
+
AliExternalTrackParam trackIn = *trackOutOld;
trackIn.ResetCovariance(kResetCov);
trackIn.AddCovariance(covar);
#include "AliTPCcalibBase.h"
class AliTPCseed;
-//class AliESDEvent;
-class AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
+class AliESDEvent;
+class AliESDtrack;
class TCollection;
class TTreeSRedirector;
class AliExternalTrackParam;
AliTPCcalibCalib(const AliTPCcalibCalib&calib);
AliTPCcalibCalib &operator=(const AliTPCcalibCalib&calib);
virtual ~AliTPCcalibCalib();
- virtual void Process(AliVEvent *event);
+ virtual void Process(AliESDEvent *event);
virtual void Analyze(){return;}
- Bool_t RefitTrack(AliVTrack * track, AliTPCseed *seed, Float_t magesd);
+ Bool_t RefitTrack(AliESDtrack * 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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliESDtrack *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(AliVEvent *event) {
+void AliTPCcalibCosmic::Process(AliESDEvent *event) {
//
// Process of the ESD event - fill calibration components
//
if (!event) {
- Printf("ERROR: event not available");
+ Printf("ERROR: ESD not available");
return;
}
}
-void AliTPCcalibCosmic::FindPairs(const AliVEvent *event){
+void AliTPCcalibCosmic::FindPairs(const AliESDEvent *event){
//
// Find cosmic pairs
//
// Track1 is choosen in lower TPC part
//
if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
- AliVfriendEvent *friendEvent=event->FindFriend();
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
Int_t ntracks=event->GetNumberOfTracks();
TObjArray tpcSeeds(ntracks);
if (ntracks==0) return;
//track loop
//
for (Int_t i=0;i<ntracks;++i) {
- AliVTrack *track = event->GetVTrack(i);
- if(!track) continue;
+ AliESDtrack *track = event->GetTrack(i);
fClusters->Fill(track->GetTPCNcls());
const AliExternalTrackParam * trackIn = track->GetInnerParam();
if (ntracks>4 && TMath::Abs(trackIn->GetTgl())<0.0015) continue; // filter laser
- const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+ AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
if (!friendTrack) continue;
TObject *calibObject;
AliTPCseed *seed = 0;
// Find pairs
//
for (Int_t i=0;i<ntracks;++i) {
- AliVTrack *track0 = event->GetVTrack(i);
+ AliESDtrack *track0 = event->GetTrack(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;
- AliVTrack *track1 = event->GetVTrack(j);
+ AliESDtrack *track1 = event->GetTrack(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;
- param0.CopyFromVTrack(track0);
-
- AliExternalTrackParam param1;
- param1.CopyFromVTrack(track1);
+ AliExternalTrackParam param0(*track0);
+ AliExternalTrackParam param1(*track1);
//
// Propagate using Magnetic field and correct fo material budget
//
-void AliTPCcalibCosmic::FillAcordeHist(AliVTrack *upperTrack) {
+void AliTPCcalibCosmic::FillAcordeHist(AliESDtrack *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 AliVEvent *event) {
+void AliTPCcalibCosmic::FindCosmicPairs(const AliESDEvent * event) {
//
// find cosmic pairs trigger by random trigger
//
//
- AliESDVertex vtxSPD;
- event->GetPrimaryVertexSPD(vtxSPD);
- AliESDVertex *vertexSPD=&vtxSPD;
-
- AliESDVertex vtxTPC;
- event->GetPrimaryVertexTPC(vtxTPC);
- AliESDVertex *vertexTPC=&vtxTPC;
-
- AliVfriendEvent *friendEvent=event->FindFriend();
+ AliESDVertex *vertexSPD = (AliESDVertex *)event->GetPrimaryVertexSPD();
+ AliESDVertex *vertexTPC = (AliESDVertex *)event->GetPrimaryVertexTPC();
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
const Double_t kMinPt=1;
const Double_t kMinPtMax=0.8;
const Double_t kMinNcl=50;
for (Int_t itrack0=0;itrack0<ntracks;itrack0++) {
- AliVTrack *track0 = event->GetVTrack(itrack0);
+ AliESDtrack *track0 = event->GetTrack(itrack0);
if (!track0) continue;
- if (!track0->IsOn(AliVTrack::kTPCrefit)) continue;
+ if (!track0->IsOn(AliESDtrack::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++) {
- AliVTrack *track1 = event->GetVTrack(itrack1);
+ AliESDtrack *track1 = event->GetTrack(itrack1);
if (!track1) continue;
- if (!track1->IsOn(AliVTrack::kTPCrefit)) continue;
+ if (!track1->IsOn(AliESDtrack::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=(friendEvent) ? (friendEvent->GetTrack(itrack0)!=0):0;
+ Bool_t hasFriend=(esdFriend) ? (esdFriend->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();
//
- const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(itrack0);
+ AliESDfriendTrack *friendTrack0 = esdFriend->GetTrack(itrack0);
if (!friendTrack0) continue;
- const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(itrack1);
+ AliESDfriendTrack *friendTrack1 = esdFriend->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.="<<dummyfriendTrack0<< //track0
- //"ft1.="<<dummyfriendTrack1<< //track1
+ "ft0.="<<friendTrack0<< //track0
+ "ft1.="<<friendTrack1<< //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.",&dummytrack0);
- fCosmicTree->Branch("t1.",&dummytrack1);
- fCosmicTree->Branch("ft0.",&dummyfriendTrack0);
- fCosmicTree->Branch("ft1.",&dummyfriendTrack1);
+ fCosmicTree->Branch("t0.",&track0);
+ fCosmicTree->Branch("t1.",&track1);
+ fCosmicTree->Branch("ft0.",&friendTrack0);
+ fCosmicTree->Branch("ft1.",&friendTrack1);
}else{
- fCosmicTree->SetBranchAddress("t0.",&dummytrack0);
- fCosmicTree->SetBranchAddress("t1.",&dummytrack1);
- fCosmicTree->SetBranchAddress("ft0.",&dummyfriendTrack0);
- fCosmicTree->SetBranchAddress("ft1.",&dummyfriendTrack1);
+ fCosmicTree->SetBranchAddress("t0.",&track0);
+ fCosmicTree->SetBranchAddress("t1.",&track1);
+ fCosmicTree->SetBranchAddress("ft0.",&friendTrack0);
+ fCosmicTree->SetBranchAddress("ft1.",&friendTrack1);
}
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 AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
+class AliESDEvent;
+class AliESDtrack;
class THnSparse;
class AliTPCcalibCosmic:public AliTPCcalibBase {
AliTPCcalibCosmic(const Text_t *name, const Text_t *title);
virtual ~AliTPCcalibCosmic();
- virtual void Process(AliVEvent *event);
+ virtual void Process(AliESDEvent *event);
virtual Long64_t Merge(TCollection *const li);
void Add(const AliTPCcalibCosmic* cosmic);
//
//
void Init();
- void FindPairs(const AliVEvent *event);
- void FindCosmicPairs(const AliVEvent * event);
+ void FindPairs(const AliESDEvent *event);
+ void FindCosmicPairs(const AliESDEvent * 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(AliVTrack *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(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(AliVTrack *upperTrack);
+ void FillAcordeHist(AliESDtrack *upperTrack);
#include "AliTPCClusterParam.h"
#include "AliTPCseed.h"
#include "AliESDVertex.h"
-//#include "AliESDEvent.h"
-//#include "AliESDfriend.h"
-#include "AliESDfriendTrack.h"
+#include "AliESDEvent.h"
+#include "AliESDfriend.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(AliVEvent *event) {
+void AliTPCcalibGainMult::Process(AliESDEvent *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 AliTPCcalibGainMult::Process(): event not available");
+ Printf("ERROR: ESD not available");
return;
}
- fCurrentEvent=event;
+ fCurrentEvent=event ;
fMagF = event->GetMagneticField();
Int_t ntracks=event->GetNumberOfTracks();
- //AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindFriend());
- AliVfriendEvent *friendEvent=event->FindFriend();
- if (!friendEvent) {
- Printf("ERROR: esdFriend not available");
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!esdFriend) {
+ //Printf("ERROR: esdFriend not available");
delete fPIDMatrix;
return;
}
- if (!(friendEvent->TestSkipBit())) fPIDMatrix= new TMatrixD(ntracks,5);
+ if (!(esdFriend->TestSkipBit())) fPIDMatrix= new TMatrixD(ntracks,5);
fHistNTracks->Fill(ntracks);
// ProcessCosmic(event); // usually not enogh statistic
- if (friendEvent->TestSkipBit()) {
+ if (esdFriend->TestSkipBit()) {
return;
}
//
//
for (Int_t i=0;i<ntracks;++i) {
//
- //AliESDtrack *track = (AliESDtrack*)(event->GetTrack(i));
- AliVTrack *track = event->GetVTrack(i);
+ AliESDtrack *track = event->GetTrack(i);
if (!track) continue;
//
-
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- if ( (track->GetTrackParamIp(trckIn)) < 0) continue;
- AliExternalTrackParam * trackIn = &trckIn;
+ AliExternalTrackParam * trackIn = (AliExternalTrackParam *)track->GetInnerParam();
if (!trackIn) continue;
// calculate necessary track parameters
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
-
+ if ((status&AliESDtrack::kTPCrefit)==0) continue;
+ if ((status&AliESDtrack::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&AliVTrack::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;
//
//
// 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 = friendEvent->GetTrack(i);
- const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+ AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
if (!friendTrack) continue;
TObject *calibObject;
AliTPCseed *seed = 0;
//
if (seed) { // seed the container with track parameters and the clusters
//
- AliExternalTrackParam trckOut;
- friendTrack->GetTrackParamTPCOut(trckOut);
- if ( (friendTrack->GetTrackParamTPCOut(trckOut)) <0) continue;
- AliExternalTrackParam * trackOut = &trckOut; // tack at the outer radius of TPC
+ const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut(); // tack at the outer radius of TPC
+ if (!trackIn) continue;
if (!trackOut) continue;
Double_t meanDrift = 250 - 0.5*TMath::Abs(trackIn->GetZ() + trackOut->GetZ());
Double_t dipAngleTgl = trackIn->GetTgl();
}
-void AliTPCcalibGainMult::DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack, AliTPCseed * seed, Int_t index){
+void AliTPCcalibGainMult::DumpTrack(AliESDtrack * track, AliESDfriendTrack *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 vtx;
- fCurrentEvent->GetPrimaryVertex(vtx);
- AliESDVertex *vertex=&vtx;
+ AliESDVertex *vertex= (AliESDVertex *)fCurrentEvent->GetPrimaryVertex();
//
// Estimate current MIP position -
//
if ( (isMuon==0 && isElectron==0) && (TMath::Sqrt(dca[0]*dca[0]+dca[1]*dca[1])>kDCAcut) ) return;
Double_t normdEdx= track->GetTPCsignal()/(medianMIP0); // TPC signal normalized to the MIP
//
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- if ( (track->GetTrackParamIp(trckIn)) <0) return;
- AliExternalTrackParam * trackIn = &trckIn;
+ AliExternalTrackParam * trackIn = (AliExternalTrackParam *)track->GetInnerParam();
+ AliExternalTrackParam * trackOut = (AliExternalTrackParam *)track->GetOuterParam();
+ AliExternalTrackParam * tpcOut = (AliExternalTrackParam *)ftrack->GetTPCOut();
if (!trackIn) return;
-
- AliExternalTrackParam trckOut;
- track->GetTrackParamOp(trckOut);
- if ( (track->GetTrackParamOp(trckOut)) <0) return;
- AliExternalTrackParam * trackOut = &trckOut;
if (!trackOut) return;
-
- AliExternalTrackParam trckTPCOut;
- ftrack->GetTrackParamTPCOut(trckTPCOut);
- if ( (ftrack->GetTrackParamTPCOut(trckTPCOut)) <0) return;
- AliExternalTrackParam * tpcOut = &trckTPCOut;
if (!tpcOut) return;
-
- if (trckIn.GetZ()*trckOut.GetZ()<0) return; // remove crossing tracks
+ if (trackIn->GetZ()*trackOut->GetZ()<0) return; // remove crossing tracks
//
// calculate local and global angle
Int_t side = (trackIn->GetZ()>0)? 1:-1;
// Select the kaons and Protons which are "isolated" in TPC dedx curve
//
//
- AliExternalTrackParam trkIn;
- track->GetTrackParamIp(trkIn);
- AliExternalTrackParam * trackIP = &trkIn;
- Double_t dedxP = AliExternalTrackParam::BetheBlochAleph(trackIP->GetP()/massP,kp1,kp2,kp3,kp4,kp5);
- Double_t dedxK = AliExternalTrackParam::BetheBlochAleph(trackIP->GetP()/massK,kp1,kp2,kp3,kp4,kp5);
+ Double_t dedxP = AliExternalTrackParam::BetheBlochAleph(track->GetInnerParam()->GetP()/massP,kp1,kp2,kp3,kp4,kp5);
+ Double_t dedxK = AliExternalTrackParam::BetheBlochAleph(track->GetInnerParam()->GetP()/massK,kp1,kp2,kp3,kp4,kp5);
if (dedxP>2 || dedxK>2){
if (track->GetP()<1.2 && normdEdx>1.8&&counterMIP0>10){ // not enough from TOF and V0s triggered by high dedx
// signing the Proton and kaon - using the "bitmask" bit 1 and 2 is dedicated for V0s and TOF selected
Double_t mass = 0;
Bool_t isHighPt = ((TMath::Power(1/track->Pt(),4)*gRandom->Rndm())<0.005); // rnadomly selected HPT tracks
// there are selected for the QA of the obtained calibration
- Bool_t isMIP = TMath::Abs(trackIP->P()-0.4)<0.005&&(counter<kMax); //
+ Bool_t isMIP = TMath::Abs(track->GetInnerParam()->P()-0.4)<0.005&&(counter<kMax); //
// REMINDER - it is not exactly MIP - we select the regtion where the Kaon and Electrons are well separated
if (isElectron>0) mass = massE;
-void AliTPCcalibGainMult::ProcessV0s(AliVEvent *event){
+void AliTPCcalibGainMult::ProcessV0s(AliESDEvent * event){
//
// Select the K0s and gamma - and sign daughter products
//
TTreeSRedirector * pcstream = GetDebugStreamer();
AliKFParticle::SetField(event->GetMagneticField());
- //AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindFriend());
- AliVfriendEvent *friendEvent=event->FindFriend();
- if (!friendEvent) {
- //Printf("ERROR: friendEvent not available");
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!esdFriend) {
+ //Printf("ERROR: esdFriend not available");
return;
}
- if (friendEvent->TestSkipBit()) return;
+ if (esdFriend->TestSkipBit()) return;
//
//
static const TDatabasePDG *pdg = TDatabasePDG::Instance();
const Double_t kMaxREl=70;
//
Int_t nv0 = event->GetNumberOfV0s();
-
-
- //AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
- AliESDVertex vtx;
- event->GetPrimaryVertex(vtx);
- AliESDVertex *vertex=&vtx;
-
+ AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
AliKFVertex kfvertex=*vertex;
-
-
//
for (Int_t iv0=0;iv0<nv0;iv0++){
- //AliESDv0 *v0 = event->GetV0(iv0);
- AliESDv0 v0dummy;
- event->GetV0(v0dummy, iv0);
- if( (event->GetV0(v0dummy, iv0)) < 0) continue;
- AliESDv0 *v0 = &v0dummy;
-
+ AliESDv0 *v0 = event->GetV0(iv0);
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 = (AliESDtrack*)event->GetTrack(pindex);
- //AliESDtrack * trackN = (AliESDtrack*)event->GetTrack(nindex);
- AliVTrack * trackP = event->GetVTrack(pindex);
- AliVTrack * trackN = event->GetVTrack(nindex);
+ AliESDtrack * trackP = event->GetTrack(pindex);
+ AliESDtrack * trackN = event->GetTrack(nindex);
if (!trackN) continue;
if (!trackP) continue;
Int_t nclP= (Int_t)trackP->GetTPCClusterInfo(2,1);
if (TMath::Abs(eta)>1) continue;
//
//
- //AliESDfriendTrack *friendTrackP = friendEvent->GetTrack(pindex);
- //AliESDfriendTrack *friendTrackN = friendEvent->GetTrack(nindex);
- const AliVfriendTrack *friendTrackP = friendEvent->GetTrack(pindex);
- const AliVfriendTrack *friendTrackN = friendEvent->GetTrack(nindex);
+ AliESDfriendTrack *friendTrackP = esdFriend->GetTrack(pindex);
+ AliESDfriendTrack *friendTrackN = esdFriend->GetTrack(nindex);
if (!friendTrackP) continue;
if (!friendTrackN) continue;
TObject *calibObject;
-void AliTPCcalibGainMult::ProcessCosmic(const AliVEvent *event) {
+void AliTPCcalibGainMult::ProcessCosmic(const AliESDEvent * event) {
//
// Find cosmic pairs trigger by random trigger
//
AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
AliTPCParam *param = AliTPCcalibDB::Instance()->GetParameters();
- 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();
+ AliESDVertex *vertexSPD = (AliESDVertex *)event->GetPrimaryVertexSPD();
+ AliESDVertex *vertexTPC = (AliESDVertex *)event->GetPrimaryVertexTPC();
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
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++) {
- AliVTrack *track0 = event->GetVTrack(itrack0);
+ AliESDtrack *track0 = event->GetTrack(itrack0);
if (!track0) continue;
- if (!track0->IsOn(AliVTrack::kTPCrefit)) continue;
+ if (!track0->IsOn(AliESDtrack::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++) {
- AliVTrack *track1 = event->GetVTrack(itrack1);
+ AliESDtrack *track1 = event->GetTrack(itrack1);
if (!track1) continue;
- if (!track1->IsOn(AliVTrack::kTPCrefit)) continue;
+ if (!track1->IsOn(AliESDtrack::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=(friendEvent) ? (friendEvent->GetTrack(itrack0)!=0):0;
+ Bool_t hasFriend=(esdFriend) ? (esdFriend->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";
}
//
- const AliVfriendTrack *friendTrack0 = friendEvent->GetTrack(itrack0);
+ AliESDfriendTrack *friendTrack0 = esdFriend->GetTrack(itrack0);
if (!friendTrack0) continue;
- const AliVfriendTrack *friendTrack1 = friendEvent->GetTrack(itrack1);
+ AliESDfriendTrack *friendTrack1 = esdFriend->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 AliVEvent *event){
+void AliTPCcalibGainMult::ProcessKinks(const AliESDEvent * event){
//
//
//
AliKFParticle::SetField(event->GetMagneticField());
- AliVfriendEvent *friendEvent=event->FindFriend();
- if (!friendEvent) {
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!esdFriend) {
//Printf("ERROR: esdFriend not available");
return;
}
const Int_t kMinNcl=110;
//
Int_t nkinks = event->GetNumberOfKinks();
- //AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
- AliESDVertex vtx;
- event->GetPrimaryVertex(vtx);
- AliESDVertex *vertex=&vtx;
-
+ AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
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();
- AliVTrack * trackM = event->GetVTrack(kink->GetIndex(0));
- AliVTrack * trackD = event->GetVTrack(kink->GetIndex(1));
+ AliESDtrack * trackM = event->GetTrack(kink->GetIndex(0));
+ AliESDtrack * trackD = event->GetTrack(kink->GetIndex(1));
if (!trackM) continue;
if (!trackD) continue;
Int_t nclM= (Int_t)trackM->GetTPCClusterInfo(2,1);
if (TMath::Abs(eta)>1) continue;
//
//
- const AliVfriendTrack *friendTrackM = friendEvent->GetTrack(kink->GetIndex(0));
- const AliVfriendTrack *friendTrackD = friendEvent->GetTrack(kink->GetIndex(1));
+ AliESDfriendTrack *friendTrackM = esdFriend->GetTrack(kink->GetIndex(0));
+ AliESDfriendTrack *friendTrackD = esdFriend->GetTrack(kink->GetIndex(1));
if (!friendTrackM) continue;
if (!friendTrackD) continue;
TObject *calibObject;
}
}
-void AliTPCcalibGainMult::DumpHPT(const AliVEvent *event){
+void AliTPCcalibGainMult::DumpHPT(const AliESDEvent * 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());
- AliVfriendEvent *friendEvent=event->FindFriend();
- if (!friendEvent) {
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!esdFriend) {
//Printf("ERROR: esdFriend not available");
return;
}
- if (friendEvent->TestSkipBit()) return;
+ if (esdFriend->TestSkipBit()) return;
Int_t ntracks=event->GetNumberOfTracks();
//
for (Int_t i=0;i<ntracks;++i) {
//
- AliVTrack *track = event->GetVTrack(i);
+ AliESDtrack *track = event->GetTrack(i);
if (!track) continue;
if (track->Pt()<4) continue;
UInt_t status = track->GetStatus();
//
-
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- if ((track->GetTrackParamIp(trckIn)) <0) continue;
- AliExternalTrackParam * trackIn = &trckIn;
+ AliExternalTrackParam * trackIn = (AliExternalTrackParam *)track->GetInnerParam();
if (!trackIn) continue;
- if ((status&AliVTrack::kTPCrefit)==0) continue;
- if ((status&AliVTrack::kITSrefit)==0) continue;
- const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+ if ((status&AliESDtrack::kTPCrefit)==0) continue;
+ if ((status&AliESDtrack::kITSrefit)==0) continue;
+ AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
if (!friendTrack) continue;
- AliExternalTrackParam prmitsOut;
- friendTrack->GetTrackParamITSOut(prmitsOut);
- if ((friendTrack->GetTrackParamITSOut(prmitsOut)) < 0) continue;
- AliExternalTrackParam * itsOut = &prmitsOut;
+ AliExternalTrackParam * itsOut = (AliExternalTrackParam *)(friendTrack->GetITSOut());
if (!itsOut) continue;
-
- //AliExternalTrackParam * itsOut2 = (AliExternalTrackParam *)(friendTrack->GetITSOut()->Clone());
- AliExternalTrackParam * itsOut2 = (AliExternalTrackParam *)(itsOut->Clone());
-
+ AliExternalTrackParam * itsOut2 = (AliExternalTrackParam *)(friendTrack->GetITSOut()->Clone());
AliExternalTrackParam * tpcIn2 = (AliExternalTrackParam *)(trackIn->Clone());
if (!itsOut2->Rotate(trackIn->GetAlpha())) continue;
//Double_t xmiddle=0.5*(itsOut2->GetX()+tpcIn2->GetX());
if (!itsOut2->PropagateTo(xmiddle,event->GetMagneticField())) continue;
if (!tpcIn2->PropagateTo(xmiddle,event->GetMagneticField())) continue;
//
- AliExternalTrackParam prmtpcInner;
- track->GetTrackParamTPCInner(prmtpcInner);
- if ((track->GetTrackParamTPCInner(prmtpcInner)) < 0) continue;
- AliExternalTrackParam * tpcInner = &prmtpcInner;
+ AliExternalTrackParam * tpcInner = (AliExternalTrackParam *)(track->GetTPCInnerParam());
if (!tpcInner) continue;
tpcInner->Rotate(track->GetAlpha());
tpcInner->PropagateTo(track->GetX(),event->GetMagneticField());
//
// tpc constrained
//
- AliExternalTrackParam prmtpcInnerC;
- track->GetTrackParamTPCInner(prmtpcInnerC);
- if ((track->GetTrackParamTPCInner(prmtpcInnerC)) < 0) continue;
- AliExternalTrackParam * tpcInnerC = &prmtpcInnerC;
- //AliExternalTrackParam * tpcInnerC = (AliExternalTrackParam *)(track->GetTPCInnerParam()->Clone());
+ AliExternalTrackParam * tpcInnerC = (AliExternalTrackParam *)(track->GetTPCInnerParam()->Clone());
if (!tpcInnerC) continue;
tpcInnerC->Rotate(track->GetAlpha());
tpcInnerC->PropagateTo(track->GetX(),event->GetMagneticField());
Double_t dz[2],cov[3];
- AliESDVertex dummyvtx;
- event->GetPrimaryVertex(dummyvtx);
- AliESDVertex *vtx=&dummyvtx;
-
+ AliESDVertex *vtx= (AliESDVertex *)event->GetPrimaryVertex();
if (!tpcInnerC->PropagateToDCA(vtx, event->GetMagneticField(), 3, dz, cov)) continue;
Double_t covar[6]; vtx->GetCovMatrix(covar);
-void AliTPCcalibGainMult::ProcessTOF(const AliVEvent *event){
+void AliTPCcalibGainMult::ProcessTOF(const AliESDEvent * event){
//
// 1. Loop over tracks
// 2. Fit T0
const Double_t kMaxD=20;
const Double_t kRMS0=200;
const Double_t kMaxDCAZ=10;
- AliESDVertex dummyvtx;
- event->GetPrimaryVertex(dummyvtx);
- AliESDVertex *vtx=&dummyvtx;
+ AliESDVertex *vtx= (AliESDVertex *)event->GetPrimaryVertex();
//
TTreeSRedirector * pcstream = GetDebugStreamer();
AliKFParticle::SetField(event->GetMagneticField());
- AliVfriendEvent *friendEvent=event->FindFriend();
- if (!friendEvent) {
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!esdFriend) {
//Printf("ERROR: esdFriend not available");
return;
}
counter=0;
for (Int_t i=0;i<ntracks;++i) {
//
- AliVTrack *track = event->GetVTrack(i);
+ AliESDtrack *track = event->GetTrack(i);
if (!track) continue;
- if (!track->IsOn(AliVTrack::kTIME)) continue;
+ if (!track->IsOn(AliESDtrack::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) {
//
- AliVTrack *track = event->GetVTrack(i);
+ AliESDtrack *track = event->GetTrack(i);
if (!track) continue;
- if (!track->IsOn(AliVTrack::kTIME)) continue;
+ if (!track->IsOn(AliESDtrack::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 AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
-class AliVfriendTrack;
+class AliESDEvent;
+class AliESDtrack;
class AliTPCseed;
#include "TTreeStream.h"
void SetBBParam(TVectorD * param) {fBBParam=param;}
// virtual void Terminate();
//
- //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 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 Long64_t Merge(TCollection *li);
virtual void Analyze();
- void DumpTrack(AliVTrack * track, AliVfriendTrack *ftrack, AliTPCseed * seed, Int_t index);
+ void DumpTrack(AliESDtrack * track, AliESDfriendTrack *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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliESDtrack *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 "AliVEvent.h"
-#include "AliVTrack.h"
-#include "AliVfriendEvent.h"
-#include "AliVfriendTrack.h"
-
+#include "AliESDEvent.h"
+#include "AliESDfriend.h"
+#include "AliESDtrack.h"
#include "AliTPCTracklet.h"
#include "TH1D.h"
#include "TH1F.h"
AliTPCcalibLaser::AliTPCcalibLaser():
AliTPCcalibBase(),
- fEvent(0),
- fEventFriend(0),
+ fESD(0),
+ fESDfriend(0),
fNtracks(0),
fTracksMirror(336),
- fTracks(336),
+ fTracksEsd(336),
fTracksEsdParam(336),
fTracksTPC(336),
fFullCalib(kTRUE),
AliTPCcalibLaser::AliTPCcalibLaser(const Text_t *name, const Text_t *title, Bool_t full):
AliTPCcalibBase(),
- fEvent(0),
- fEventFriend(0),
+ fESD(0),
+ fESDfriend(0),
fNtracks(0),
fTracksMirror(336),
- fTracks(336),
+ fTracksEsd(336),
fTracksEsdParam(336),
fTracksTPC(336),
fFullCalib(full),
AliTPCcalibLaser::AliTPCcalibLaser(const AliTPCcalibLaser& calibLaser):
AliTPCcalibBase(calibLaser),
- fEvent(0),
- fEventFriend(0),
+ fESD(0),
+ fESDfriend(0),
fNtracks(0),
fTracksMirror(336),
- fTracks(336),
+ fTracksEsd(336),
fTracksEsdParam(336),
fTracksTPC(336),
fFullCalib(calibLaser.fFullCalib),
-void AliTPCcalibLaser::Process(AliVEvent *event) {
+void AliTPCcalibLaser::Process(AliESDEvent * event) {
//
//
// Loop over tracks and call Process function
const Int_t kMinTracks=20;
const Int_t kMinClusters=40;
- fEvent = event;
- if (!fEvent) {
- //Printf("****ERROR AliTPCcalibLaser::Process(): Event not available!!********");
+ fESD = event;
+ if (!fESD) {
return;
}
- fEventFriend=fEvent->FindFriend();
- if (!fEventFriend) {
+ fESDfriend=static_cast<AliESDfriend*>(fESD->FindListObject("AliESDfriend"));
+ if (!fESDfriend) {
return;
}
- if (fEventFriend->TestSkipBit()) return;
- if (fEvent->GetNumberOfTracks()<kMinTracks) return; //not enough tracks
+ if (fESDfriend->TestSkipBit()) return;
+ if (fESD->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<fEvent->GetNumberOfTracks();++i) {
- AliVTrack *track=fEvent->GetVTrack(i);
+ for (Int_t i=0;i<fESD->GetNumberOfTracks();++i) {
+ AliESDtrack *track=fESD->GetTrack(i);
if (!track) continue;
hisCE.Fill(track->GetZ());
hisCE.Fill(track->GetZ()+2);
fTracksTPC.Clear();
- fTracks.Clear();
+ fTracksEsd.Clear();
fTracksEsdParam.Delete();
for (Int_t id=0; id<336;id++) {
fCounter[id]=0;
fClusterSatur[id]=0;
}
//
- Int_t n=fEvent->GetNumberOfTracks();
+ Int_t n=fESD->GetNumberOfTracks();
Int_t counter=0;
for (Int_t i=0;i<n;++i) {
- const AliVfriendTrack *friendTrack=fEventFriend->GetTrack(i);
+ AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(i);
if (!friendTrack) continue;
- AliVTrack *track= fEvent->GetVTrack(i);
+ AliESDtrack *track=fESD->GetTrack(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);
- AliVTrack *track = (AliVTrack*)fTracks.At(id);
+ AliESDtrack *track = (AliESDtrack*)fTracksEsd.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;
- AliVTrack *track = (AliVTrack*)fTracks.At(id);
+ AliESDtrack *track = (AliESDtrack*)fTracksEsd.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;
- AliVTrack *track = (AliVTrack*)fTracks.At(id);
+ AliESDtrack *track = (AliESDtrack*)fTracksEsd.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(AliVTrack *track, AliTPCseed *seed){
+Int_t AliTPCcalibLaser::FindMirror(AliESDtrack *track, AliTPCseed *seed){
//
// Find corresponding mirror
// add the corresponding tracks
-
- AliExternalTrackParam trckOut;
- track->GetTrackParamOp(trckOut);
- if ((track->GetTrackParamOp(trckOut)) < 0) return -1;
- AliExternalTrackParam * trackOut = &trckOut;
- if (!trackOut) return -1;
+
+ if (!track->GetOuterParam()) return -1;
Float_t kRadius0 = 252;
Float_t kRadius = 254.2;
if (csideC>0.5*seed->GetNumberOfClusters()) side=1;
- AliExternalTrackParam param(*trackOut);
+ AliExternalTrackParam param(*(track->GetOuterParam()));
AliTracker::PropagateTrackTo(¶m,kRadius0,TDatabasePDG::Instance()->GetParticle("mu+")->Mass(),3,kTRUE);
AliTracker::PropagateTrackTo(¶m,kRadius,TDatabasePDG::Instance()->GetParticle("mu+")->Mass(),0.1,kTRUE);
AliTPCLaserTrack ltr;
if (accept){
fClusterCounter[id]=countercl;
fTracksEsdParam.AddAt(param.Clone(),id);
- fTracks.AddAt(track,id);
+ fTracksEsd.AddAt(track,id);
fTracksTPC.AddAt(seed,id);
}
return id;
//
// Dump Laser info to the tree
//
- AliVTrack *track = (AliVTrack*)fTracks.At(id);
+ AliESDtrack *track = (AliESDtrack*)fTracksEsd.At(id);
AliExternalTrackParam *param=(AliExternalTrackParam*)fTracksEsdParam.At(id);
AliTPCLaserTrack *ltrp = ( AliTPCLaserTrack*)fTracksMirror.At(id);
//
if (fStreamLevel>0){
TTreeSRedirector *cstream = GetDebugStreamer();
- Int_t time = fEvent->GetTimeStamp();
+ Int_t time = fESD->GetTimeStamp();
Bool_t accept = AcceptLaser(id);
if (cstream){
(*cstream)<<"Track"<<
class AliExternalTrackParam;
-//class AliESDtrack;
-//class AliESDEvent;
-//class AliESDfriend;
-class AliVEvent;
-class AliVTrack;
-class AliVfriendEvent;
+class AliESDtrack;
+class AliESDEvent;
+class AliESDfriend;
class TGraphErrors;
class TTree;
class TH2F;
AliTPCcalibLaser(const AliTPCcalibLaser& laser);
AliTPCcalibLaser & operator=(const AliTPCcalibLaser& calibLaser);
virtual ~AliTPCcalibLaser();
- virtual void Process(AliVEvent *event);
+ virtual void Process(AliESDEvent *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(AliVTrack *track, AliTPCseed *seed);
+ Int_t FindMirror(AliESDtrack *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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliESDtrack *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;}
- AliVEvent * fEvent; //! ESD event - not OWNER
- AliVfriendEvent * fEventFriend; //! ESD event - not OWNER
+ AliESDEvent * fESD; //! ESD event - not OWNER
+ AliESDfriend * fESDfriend; //! ESD event - not OWNER
Int_t fNtracks; //! counter of associated laser tracks
//
TObjArray fTracksMirror; //! tracks with mirror information
- TObjArray fTracks; //! tracks with reconstructed information -
+ TObjArray fTracksEsd; //! 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 "AliVEvent.h"
-#include "AliVTrack.h"
-#include "AliVfriendEvent.h"
-#include "AliVfriendTrack.h"
-
+#include "AliESDfriend.h"
#include "AliLog.h"
#include "AliRelAlignerKalman.h"
#include "AliTPCCalROC.h"
-void AliTPCcalibTime::Process(AliVEvent *event){
+void AliTPCcalibTime::Process(AliESDEvent *event){
//
// main function to make calibration
//
-
- //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!");
+ if(!event) return;
+ if (event->GetNumberOfTracks()<2) return;
+ AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!ESDfriend) {
return;
}
- if (friendEvent->TestSkipBit()) return;
+ if (ESDfriend->TestSkipBit()) return;
ResetCurrent();
-
- //AliESDEvent *ev=(AliESDEvent*)event;
//if(IsLaser (event))
ProcessLaser (event);
//if(IsCosmics(event))
ProcessBeam (event);
}
-void AliTPCcalibTime::ProcessLaser(AliVEvent *event){
+void AliTPCcalibTime::ProcessLaser(AliESDEvent *event){
//
// Fit drift velocity using laser
//
}
}
-void AliTPCcalibTime::ProcessCosmic(const AliVEvent *const event){
+void AliTPCcalibTime::ProcessCosmic(const AliESDEvent *const event){
//
// process Cosmic event - track matching A side C side
//
if (!event) {
- //Printf("ERROR: event not available");
+ Printf("ERROR: ESD not available");
return;
}
if (event->GetTimeStamp() == 0 ) {
- //Printf("no time stamp!");
+ Printf("no time stamp!");
return;
}
if (ntracks > fCutTracks) return;
if (GetDebugLevel()>20) printf("Hallo world: Im here\n");
- //AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
- AliVfriendEvent *friendEvent=event->FindFriend();
+ AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
+
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;
- AliVTrack *track = event->GetVTrack(i);
- if(!track) continue;
-
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- if ( (track->GetTrackParamIp(trckIn)) <0) continue;
- AliExternalTrackParam * trackIn = &trckIn;
+ AliESDtrack *track = event->GetTrack(i);
+
+ const AliExternalTrackParam * trackIn = track->GetInnerParam();
+ const AliExternalTrackParam * trackOut = track->GetOuterParam();
if (!trackIn) continue;
-
- AliExternalTrackParam trckOut;
- track->GetTrackParamOp(trckOut);
- if ( (track->GetTrackParamOp(trckOut)) <0) continue;
- AliExternalTrackParam * trackOut = &trckOut;
if (!trackOut) continue;
- const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+ AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
if (!friendTrack) continue;
if (friendTrack) ProcessSame(track,friendTrack,event);
- if (friendTrack) ProcessAlignITS(track,friendTrack,event,friendEvent);
+ if (friendTrack) ProcessAlignITS(track,friendTrack,event,esdFriend);
if (friendTrack) ProcessAlignTRD(track,friendTrack);
if (friendTrack) ProcessAlignTOF(track,friendTrack);
TObject *calibObject;
//
for (Int_t i=0;i<ntracks;++i) {
- AliVTrack *track0 = event->GetVTrack(i);
+ AliESDtrack *track0 = event->GetTrack(i);
// track0 - choosen upper part
if (!track0) continue;
-
- AliExternalTrackParam trckOut;
- track0->GetTrackParamOp(trckOut);
- if ( (track0->GetTrackParamOp(trckOut)) < 0) continue;
- AliExternalTrackParam * trackOut = &trckOut;
- if (!trackOut) continue;
- if (trackOut->GetAlpha()<0) continue;
+ if (!track0->GetOuterParam()) continue;
+ if (track0->GetOuterParam()->GetAlpha()<0) continue;
Double_t d1[3];
track0->GetDirection(d1);
for (Int_t j=0;j<ntracks;++j) {
if (i==j) continue;
- AliVTrack *track1 = event->GetVTrack(j);
+ AliESDtrack *track1 = event->GetTrack(j);
//track 1 lower part
if (!track1) continue;
-
- AliExternalTrackParam trck1Out;
- track1->GetTrackParamOp(trck1Out);
- if ( (track1->GetTrackParamOp(trck1Out)) < 0) continue;
- AliExternalTrackParam * track1Out = &trck1Out;
- if (!track1Out) continue;
+ if (!track1->GetOuterParam()) continue;
if (track0->GetTPCNcls()+ track1->GetTPCNcls()< kMinClusters) continue;
Int_t nAC = TMath::Max( TMath::Min(clusterSideA[i], clusterSideC[j]),
TMath::Min(clusterSideC[i], clusterSideA[j]));
//
//
Float_t dmax = TMath::Max(TMath::Abs(dist0),TMath::Abs(dist1));
- AliExternalTrackParam param0;
- param0.CopyFromVTrack(track0);
- AliExternalTrackParam param1;
- param1.CopyFromVTrack(track1);
+ AliExternalTrackParam param0(*track0);
+ AliExternalTrackParam param1(*track1);
//
// Propagate using Magnetic field and correct fo material budget
//
if (GetDebugLevel()>20) printf("Trigger: %s\n",event->GetFiredTriggerClasses().Data());
}
-void AliTPCcalibTime::ProcessBeam(const AliVEvent *const event){
+void AliTPCcalibTime::ProcessBeam(const AliESDEvent *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"));
- AliVfriendEvent *friendEvent=event->FindFriend();
+ AliESDfriend *esdFriend=(AliESDfriend*)(((AliESDEvent*)event)->FindListObject("AliESDfriend"));
//
// 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 vtxSPD;
- event->GetPrimaryVertexSPD(vtxSPD);
- AliESDVertex *vertexSPD=&vtxSPD;
-
- AliESDVertex vtx;
- event->GetPrimaryVertex(vtx);
- AliESDVertex *vertex=&vtx;
-
- AliESDVertex vtxTracks;
- event->GetPrimaryVertexTracks(vtxTracks);
- AliESDVertex *vertexTracks=&vtxTracks;
-
-
+ AliESDVertex *vertexSPD = (AliESDVertex *)event->GetPrimaryVertexSPD();
+ AliESDVertex *vertex = (AliESDVertex *)event->GetPrimaryVertex();
+ AliESDVertex *vertexTracks = (AliESDVertex *)event->GetPrimaryVertexTracks();
Double_t vertexZA[10000], vertexZC[10000];
//
Int_t ntracksA= 0;
Int_t ntracksC= 0;
//
for (Int_t itrack=0;itrack<ntracks;itrack++) {
- AliVTrack *track = event->GetVTrack(itrack);
- if(!track) continue;
- const AliVfriendTrack *friendTrack = friendEvent->GetTrack(itrack);
+ AliESDtrack *track = event->GetTrack(itrack);
+ AliESDfriendTrack *friendTrack = esdFriend->GetTrack(itrack);
if (!friendTrack) continue;
if (TMath::Abs(track->GetTgl())>kMaxTgl) continue;
if (TMath::Abs(track->Pt())<kMinPt) continue;
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- AliExternalTrackParam * trackIn = &trckIn;
-
+ const AliExternalTrackParam * trackIn = track->GetInnerParam();
TObject *calibObject=0;
AliTPCseed *seed = 0;
Int_t nA=0, nC=0;
return kTRUE;
}
-Bool_t AliTPCcalibTime::IsCross(const AliVTrack *const tr0, const AliVTrack *const tr1){
+Bool_t AliTPCcalibTime::IsCross(const AliESDtrack *const tr0, const AliESDtrack *const tr1){
//
// check if the cosmic pair of tracks crossed A/C side
//
- AliExternalTrackParam trck0Out;
- tr0->GetTrackParamOp(trck0Out);
-
- AliExternalTrackParam trck1Out;
- tr1->GetTrackParamOp(trck1Out);
-
- Bool_t result= trck0Out.GetZ()*trck1Out.GetZ()<0;
+ Bool_t result= tr0->GetOuterParam()->GetZ()*tr1->GetOuterParam()->GetZ()<0;
if (result==kFALSE) return result;
result=kTRUE;
return result;
}
-Bool_t AliTPCcalibTime::IsSame(const AliVTrack *const tr0, const AliVTrack *const tr1){
+Bool_t AliTPCcalibTime::IsSame(const AliESDtrack *const tr0, const AliESDtrack *const tr1){
//
// track crossing the CE
// 0. minimal number of clusters
//
// 1. alpha cut - sector+-1
//
- AliExternalTrackParam trck0Out;
- tr0->GetTrackParamOp(trck0Out);
-
- AliExternalTrackParam trck1Out;
- tr1->GetTrackParamOp(trck1Out);
-
- if (TMath::Abs(trck0Out.GetAlpha()-trck1Out.GetAlpha())>kalphaCut) return kFALSE;
+ if (TMath::Abs(tr0->GetOuterParam()->GetAlpha()-tr1->GetOuterParam()->GetAlpha())>kalphaCut) return kFALSE;
//
// 2. Z crossing
//
- AliExternalTrackParam trck0In;
- tr0->GetTrackParamIp(trck0In);
-
- AliExternalTrackParam trck1In;
- tr1->GetTrackParamIp(trck1In);
- //if (tr0->GetOuterParam()->GetZ()*tr0->GetInnerParam()->GetZ()>0) result&=kFALSE;
- //if (tr1->GetOuterParam()->GetZ()*tr1->GetInnerParam()->GetZ()>0) result&=kFALSE;
- if (trck0Out.GetZ()*trck0In.GetZ()>0) result&=kFALSE;
- if (trck1Out.GetZ()*trck1In.GetZ()>0) result&=kFALSE;
-
+ if (tr0->GetOuterParam()->GetZ()*tr0->GetInnerParam()->GetZ()>0) result&=kFALSE;
+ if (tr1->GetOuterParam()->GetZ()*tr1->GetInnerParam()->GetZ()>0) result&=kFALSE;
if (result==kFALSE){
return result;
}
//
//
- const Double_t *p0I = trck0In.GetParameter();
- const Double_t *p1I = trck1In.GetParameter();
- const Double_t *p0O = trck0Out.GetParameter();
- const Double_t *p1O = trck1Out.GetParameter();
+ const Double_t *p0I = tr0->GetInnerParam()->GetParameter();
+ const Double_t *p1I = tr1->GetInnerParam()->GetParameter();
+ const Double_t *p0O = tr0->GetOuterParam()->GetParameter();
+ const Double_t *p1O = tr1->GetOuterParam()->GetParameter();
//
if (TMath::Abs(p0I[0]-p1I[0])>fCutMaxD) result&=kFALSE;
if (TMath::Abs(p0I[1]-p1I[1])>fCutMaxDz) result&=kFALSE;
}
-void AliTPCcalibTime::ProcessSame(const AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event){
+void AliTPCcalibTime::ProcessSame(const AliESDtrack *const track, AliESDfriendTrack *const friendTrack, const AliESDEvent *const event){
//
// Process TPC tracks crossing CE
//
const Double_t kMaxDy=1; // maximal distance in y
const Double_t kMaxDsnp=0.05; // maximal distance in snp
const Double_t kMaxDtheta=0.05; // maximal distance in theta
-
- AliExternalTrackParam trckIn;
- track->GetTrackParam(trckIn);
-
- AliExternalTrackParam trckTPCOut;
- friendTrack->GetTrackParamTPCOut(trckTPCOut);
- if ( (friendTrack->GetTrackParamTPCOut(trckTPCOut)) < 0) return;
- AliExternalTrackParam * trackTPCOut = &trckTPCOut;
- if (!trackTPCOut) return;
+
+ if (!friendTrack->GetTPCOut()) return;
//
// 0. Select only track crossing the CE
//
- if (trckIn.GetZ()*trckTPCOut.GetZ()>0) return;
+ if (track->GetInnerParam()->GetZ()*friendTrack->GetTPCOut()->GetZ()>0) return;
//
// 1. cut on track length
//
}
if (!seed) return;
//
- //AliExternalTrackParam trackIn(*track->GetInnerParam());
- AliExternalTrackParam trackIn(trckIn);
-
- AliExternalTrackParam trckOut;
- track->GetTrackParamOp(trckOut);
- AliExternalTrackParam trackOut(trckOut);
-
+ AliExternalTrackParam trackIn(*track->GetInnerParam());
+ AliExternalTrackParam trackOut(*track->GetOuterParam());
Double_t cov[3]={0.01,0.,0.01}; //use the same errors
Double_t xyz[3]={0,0.,0.0};
Double_t bz =0;
}
-void AliTPCcalibTime::ProcessAlignITS(AliVTrack *const track, const AliVfriendTrack *const friendTrack, const AliVEvent *const event, AliVfriendEvent *const friendEvent){
+void AliTPCcalibTime::ProcessAlignITS(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack, const AliESDEvent *const event, AliESDfriend *const esdFriend){
//
// Process track - Update TPC-ITS alignment
// Updates:
//
Int_t dummycl[1000];
if (track->GetTPCNcls()<kMinTPC) return; // minimal amount of clusters cut
- if (!track->IsOn(AliVTrack::kTPCrefit)) return;
-
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- if ( (track->GetTrackParamIp(trckIn)) < 0) return;
- AliExternalTrackParam * trackIn = &trckIn;
- if (!trackIn) return;
-
- AliExternalTrackParam trckOut;
- track->GetTrackParamOp(trckOut);
- if ( (track->GetTrackParamOp(trckOut)) < 0) return;
- AliExternalTrackParam * trackOut = &trckOut;
- if (!trackOut) return;
-
- if (trackIn->Pt()<kMinPt) return;
+ if (!track->IsOn(AliESDtrack::kTPCrefit)) return;
+ if (!track->GetInnerParam()) return;
+ if (!track->GetOuterParam()) return;
+ if (track->GetInnerParam()->Pt()<kMinPt) return;
// exclude crossing track
- if (trckOut.GetZ()*trckIn.GetZ()<0) return;
- if (TMath::Abs(trackIn->GetZ())<kMinZ/3.) return;
- if (trackIn->GetX()>90) return;
+ if (track->GetOuterParam()->GetZ()*track->GetInnerParam()->GetZ()<0) return;
+ if (TMath::Abs(track->GetInnerParam()->GetZ())<kMinZ/3.) return;
+ if (track->GetInnerParam()->GetX()>90) return;
//
- AliExternalTrackParam &pTPC=(AliExternalTrackParam &)(*trackIn);
+ AliExternalTrackParam &pTPC=(AliExternalTrackParam &)(*(track->GetInnerParam()));
//
AliExternalTrackParam pITS; // ITS standalone if possible
AliExternalTrackParam pITS2; //TPC-ITS track
-
- AliExternalTrackParam trckITSOut;
- friendTrack->GetTrackParamITSOut(trckITSOut);
- AliExternalTrackParam * trackITSOut = &trckITSOut;
-
- if ( (friendTrack->GetTrackParamITSOut(trckITSOut)) == 0 && (trackITSOut) ){
- pITS2=(*trackITSOut); //TPC-ITS track - snapshot ITS out
+ if (friendTrack->GetITSOut()){
+ pITS2=(*(friendTrack->GetITSOut())); //TPC-ITS track - snapshot ITS out
pITS2.Rotate(pTPC.GetAlpha());
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++){
- AliVTrack * trackITS = event->GetVTrack(i);
+ AliESDtrack * trackITS = event->GetTrack(i);
if (!trackITS) continue;
if (trackITS->GetITSclusters(dummycl)<kMinITS) continue; // minimal amount of clusters
- const AliVfriendTrack *itsfriendTrack = friendEvent->GetTrack(i);
+ itsfriendTrack = esdFriend->GetTrack(i);
if (!itsfriendTrack) continue;
-
- AliExternalTrackParam itstrckOut;
- itsfriendTrack->GetTrackParamITSOut(itstrckOut);
- if ( (itsfriendTrack->GetTrackParamITSOut(itstrckOut)) < 0) continue;
- AliExternalTrackParam * ITStrackOut = &itstrckOut;
- if (!ITStrackOut) continue;
+ if (!itsfriendTrack->GetITSOut()) continue;
- if (TMath::Abs(pTPC.GetTgl()-ITStrackOut->GetTgl())> kMaxAngle) continue;
- if (TMath::Abs(pTPC.GetSigned1Pt()-ITStrackOut->GetSigned1Pt())> kMax1Pt) continue;
- pITS=(*ITStrackOut);
+ if (TMath::Abs(pTPC.GetTgl()-itsfriendTrack->GetITSOut()->GetTgl())> kMaxAngle) continue;
+ if (TMath::Abs(pTPC.GetSigned1Pt()-itsfriendTrack->GetITSOut()->GetSigned1Pt())> kMax1Pt) continue;
+ pITS=(*(itsfriendTrack->GetITSOut()));
//
pITS.Rotate(pTPC.GetAlpha());
AliTracker::PropagateTrackToBxByBz(&pITS,pTPC.GetX(),0.1,0.1,kFALSE);
-void AliTPCcalibTime::ProcessAlignTRD(AliVTrack *const track, const AliVfriendTrack *const friendTrack){
+void AliTPCcalibTime::ProcessAlignTRD(AliESDtrack *const track, const AliESDfriendTrack *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(AliVTrack::kTRDout)) return;
-
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- if ( (track->GetTrackParamIp(trckIn)) < 0) return;
- AliExternalTrackParam * trackIn = &trckIn;
- if (!trackIn) return;
-
- AliExternalTrackParam trckTPCOut;
- friendTrack->GetTrackParamTPCOut(trckTPCOut);
- if ( (friendTrack->GetTrackParamTPCOut(trckTPCOut)) < 0) return;
- AliExternalTrackParam * trackTPCOut = &trckTPCOut;
- if (!trackTPCOut) return;
+ if (!track->IsOn(AliESDtrack::kTRDout)) return;
+ if (!track->GetInnerParam()) return;
+ if (!friendTrack->GetTPCOut()) return;
// exclude crossing track
- if (trckTPCOut.GetZ()*trckIn.GetZ()<0) return;
+ if (friendTrack->GetTPCOut()->GetZ()*track->GetInnerParam()->GetZ()<0) return;
//
- AliExternalTrackParam &pTPC=(AliExternalTrackParam &)(*trackTPCOut);
+ AliExternalTrackParam &pTPC=(AliExternalTrackParam &)(*(friendTrack->GetTPCOut()));
AliTracker::PropagateTrackToBxByBz(&pTPC,kRefX,0.1,0.1,kFALSE);
AliExternalTrackParam *pTRDtrack = 0;
TObject *calibObject=0;
- for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) {
+ for (Int_t l=0;(calibObject=((AliESDfriendTrack*)friendTrack)->GetCalibObject(l));++l) {
if ((dynamic_cast< AliTPCseed*>(calibObject))) continue;
if ((pTRDtrack=dynamic_cast< AliExternalTrackParam*>(calibObject))) break;
}
}
-void AliTPCcalibTime::ProcessAlignTOF(AliVTrack *const track, const AliVfriendTrack *const friendTrack){
+void AliTPCcalibTime::ProcessAlignTOF(AliESDtrack *const track, const AliESDfriendTrack *const friendTrack){
//
//
// Process track - Update TPC-TOF alignment
// Clusters are not in friends - use alingment points
//
if (track->GetTOFsignal()<=0) return;
-
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- if ( (track->GetTrackParamIp(trckIn)) < 0) return;
- AliExternalTrackParam * trackIn = &trckIn;
- if (!trackIn) return;
-
- AliExternalTrackParam trckTPCOut;
- friendTrack->GetTrackParamTPCOut(trckTPCOut);
- if ( (friendTrack->GetTrackParamTPCOut(trckTPCOut)) < 0) return;
- AliExternalTrackParam * trackTPCOut = &trckTPCOut;
- if (!trackTPCOut) return;
-
+ if (!friendTrack->GetTPCOut()) return;
+ if (!track->GetInnerParam()) return;
+ if (!friendTrack->GetTPCOut()) return;
const AliTrackPointArray *points=friendTrack->GetTrackPointArray();
if (!points) return;
- AliExternalTrackParam pTPC(*trackTPCOut);
+ AliExternalTrackParam pTPC(*(friendTrack->GetTPCOut()));
AliExternalTrackParam pTOF(pTPC);
Double_t mass = TDatabasePDG::Instance()->GetParticle("mu+")->Mass();
Int_t npoints = points->GetNPoints();
//
if (track->GetTPCNcls()<kMinTPC) return; // minimal amount of clusters cut
// exclude crossing track
- if (trckTPCOut.GetZ()*trckIn.GetZ()<0) return;
+ if (friendTrack->GetTPCOut()->GetZ()*track->GetInnerParam()->GetZ()<0) return;
//
if (TMath::Abs(pTOF.GetY()-pTPC.GetY()) >kMaxDy) return;
if (TMath::Abs(pTOF.GetSnp()-pTPC.GetSnp())>kMaxAngle) return;
}
-void AliTPCcalibTime::FillResHistoTPC(const AliVTrack *pTrack){
+void AliTPCcalibTime::FillResHistoTPC(const AliESDtrack * pTrack){
//
// fill residual histograms pTPC - vertex
// Histogram is filled only for primary tracks
//
if (fMemoryMode<2) return;
Double_t histoX[4];
- AliExternalTrackParam prmTPCIn;
- pTrack->GetTrackParamIp(prmTPCIn);
- AliExternalTrackParam * pTPCIn = &prmTPCIn;
-
- AliExternalTrackParam pTPCvertex(*pTPCIn);
+ const AliExternalTrackParam * pTPCIn = pTrack->GetInnerParam();
+ AliExternalTrackParam pTPCvertex(*(pTrack->GetInnerParam()));
//
-
- AliExternalTrackParam cnstrPrm;
- pTrack->GetTrackParamCp(cnstrPrm);
- if ( (pTrack->GetTrackParamCp(cnstrPrm)) <0) return;
- AliExternalTrackParam * constrainedParam = &cnstrPrm;
- if (!constrainedParam) return;
- AliExternalTrackParam lits(*constrainedParam);
+ if (!(pTrack->GetConstrainedParam())) return;
+ AliExternalTrackParam lits(*(pTrack->GetConstrainedParam()));
if (TMath::Abs(pTrack->GetY())>3) return; // beam pipe
pTPCvertex.Rotate(lits.GetAlpha());
//pTPCvertex.PropagateTo(pTPCvertex->GetX(),fMagF);
class TH2F;
class TH1D;
class TList;
-//class AliESDEvent;
-class AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
-class AliExternalTrackParam;
+class AliESDEvent;
+class AliESDtrack;
class AliTPCcalibLaser;
class TGraphErrors;
class AliSplineFit;
-//class AliESDfriendTrack;
-class AliVfriendTrack;
-class AliVfriendEvent;
+class AliESDfriendTrack;
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(AliVEvent *event);
+ virtual void Process(AliESDEvent *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 (AliVEvent *event);
- void ProcessCosmic(const AliVEvent *const event);
- void ProcessBeam (const AliVEvent *const event);
-
+ void ProcessLaser (AliESDEvent *event);
+ void ProcessCosmic(const AliESDEvent *const event);
+ void ProcessBeam (const AliESDEvent *const event);
Bool_t IsPair(const AliExternalTrackParam *tr0, const AliExternalTrackParam *tr1);
- 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);
+ 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);
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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliESDtrack *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 AliVTrack * pTrack);
+ void FillResHistoTPC(const AliESDtrack * 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(AliVEvent *event) {
+void AliTPCcalibTimeGain::Process(AliESDEvent *event) {
//
// main track loop
//
- //Printf("AliTPCcalibTimeGain::Process(event)...");
-
if (!event) {
- //Printf("ERROR AliTPCcalibTimeGain::Process(): event not available");
+ Printf("ERROR: ESD not available");
return;
}
-
- AliVfriendEvent *friendEvent=event->FindFriend();
-
- if (!friendEvent) {
- //Printf("ERROR AliTPCcalibTimeGain::Process(): friendEvent not available");
+ AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!ESDfriend) {
return;
}
- //Printf("friendEvent->TestSkipBit() = %d",friendEvent->TestSkipBit() );
- if (friendEvent->TestSkipBit()) {
- return;
- }
+ if (ESDfriend->TestSkipBit()) return;
if (fIsCosmic) { // this should be removed at some point based on trigger mask !?
ProcessCosmicEvent(event);
ProcessBeamEvent(event);
}
+
+
+
}
-void AliTPCcalibTimeGain::ProcessCosmicEvent(AliVEvent *event) {
+void AliTPCcalibTimeGain::ProcessCosmicEvent(AliESDEvent *event) {
//
// Process in case of cosmic event
//
- //Printf("AliTPCcalibTimeGain::ProcessCosmicEvent(event)...");
-
- AliVfriendEvent *friendEvent=event->FindFriend();
- if (!friendEvent) {
- //Printf("ERROR AliTPCcalibTimeGain::ProcessCosmicEvent(): ESDfriend not available");
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!esdFriend) {
+ Printf("ERROR: ESDfriend not available");
return;
}
//
UInt_t time = event->GetTimeStamp();
- Int_t nFriendTracks = friendEvent->GetNumberOfTracks();
+ Int_t nFriendTracks = esdFriend->GetNumberOfTracks();
Int_t runNumber = event->GetRunNumber();
//
// track loop
//
for (Int_t i=0;i<nFriendTracks;++i) {
- AliVTrack *track = event->GetVTrack(i);
+ AliESDtrack *track = event->GetTrack(i);
if (!track) continue;
- const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
- if (!friendTrack) continue;
- //const AliExternalTrackParam * trackIn = track->GetInnerParam();
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- if ( (track->GetTrackParamIp(trckIn)) < 0) continue;
- AliExternalTrackParam * trackIn = &trckIn;
+ AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+ if (!friendTrack) continue;
+ const AliExternalTrackParam * trackIn = track->GetInnerParam();
+ const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
if (!trackIn) continue;
-
- //const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
- AliExternalTrackParam trckOut;
- friendTrack->GetTrackParamTPCOut(trckOut);
- if ( (friendTrack->GetTrackParamTPCOut(trckOut)) < 0) continue;
- AliExternalTrackParam * trackOut = &trckOut;
if (!trackOut) continue;
// calculate necessary track parameters
-void AliTPCcalibTimeGain::ProcessBeamEvent(AliVEvent *event) {
+void AliTPCcalibTimeGain::ProcessBeamEvent(AliESDEvent *event) {
//
// Process in case of beam event
//
- //Printf("AliTPCcalibTimeGain::ProcessBeamEvent(event)...");
-
- AliVfriendEvent *friendEvent=event->FindFriend();
- if (!friendEvent) {
- //Printf("ERROR AliTPCcalibTimeGain::ProcessBeamEvent(): ESDfriend not available");
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+ if (!esdFriend) {
+ Printf("ERROR: ESDfriend not available");
return;
}
//
UInt_t time = event->GetTimeStamp();
- if (!time) Printf("ERROR: no time stamp available!");
- Int_t nFriendTracks = friendEvent->GetNumberOfTracks();
+ Int_t nFriendTracks = esdFriend->GetNumberOfTracks();
Int_t runNumber = event->GetRunNumber();
//
// track loop
//
for (Int_t i=0;i<nFriendTracks;++i) { // begin track loop
- 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;
- }
+ AliESDtrack *track = event->GetTrack(i);
+ if (!track) continue;
+ AliESDfriendTrack *friendTrack = esdFriend->GetTrack(i);
+ if (!friendTrack) continue;
- //const AliExternalTrackParam * trackIn = track->GetInnerParam();
- AliExternalTrackParam trckIn;
- track->GetTrackParamIp(trckIn);
- if ( (track->GetTrackParamIp(trckIn)) < 0) continue;
- AliExternalTrackParam * trackIn = &trckIn;
+ const AliExternalTrackParam * trackIn = track->GetInnerParam();
+ const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
if (!trackIn) continue;
-
- //const AliExternalTrackParam * trackOut = friendTrack->GetTPCOut();
- AliExternalTrackParam trckOut;
- friendTrack->GetTrackParamTPCOut(trckOut);
- if ( (friendTrack->GetTrackParamTPCOut(trckOut)) < 0) continue;
- AliExternalTrackParam * trackOut = &trckOut;
if (!trackOut) continue;
// calculate necessary track parameters
if (TMath::Abs(trackIn->Eta()) > fCutEtaWindow) continue;
//
UInt_t status = track->GetStatus();
- if ((status&AliVTrack::kTPCrefit)==0) continue;
- if ((status&AliVTrack::kITSrefit)==0 && fCutRequireITSrefit) continue; // ITS cluster
+ if ((status&AliESDtrack::kTPCrefit)==0) continue;
+ if ((status&AliESDtrack::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&AliVTrack::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;
//
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 v0dummy;
- event->GetV0(v0dummy, iv0);
- AliESDv0 *v0 = &v0dummy;
-
- //if (!v0) Printf("ERROR AliTPCcalibTimeGain::ProcessBeamEvent(): ESDv0 not available! ");
-
+ AliESDv0 * v0 = event->GetV0(iv0);
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();
- AliVTrack * trackP = event->GetVTrack(index);
- if (!trackP) continue; //Printf("***ERROR*** trackP not available!");
- const AliVfriendTrack *friendTrackP = friendEvent->GetTrack(index);
+ AliESDtrack * trackP = event->GetTrack(index);
+ AliESDfriendTrack *friendTrackP = esdFriend->GetTrack(index);
if (!friendTrackP) continue;
- //const AliExternalTrackParam * trackPIn = trackP->GetInnerParam();
- AliExternalTrackParam trckPIn;
- trackP->GetTrackParamIp(trckPIn);
- if ( (trackP->GetTrackParamIp(trckPIn)) < 0) continue;
- AliExternalTrackParam * trackPIn = &trckPIn;
+ const AliExternalTrackParam * trackPIn = trackP->GetInnerParam();
+ const AliExternalTrackParam * trackPOut = friendTrackP->GetTPCOut();
if (!trackPIn) continue;
-
- //const AliExternalTrackParam * trackPOut = friendTrackP->GetTPCOut();
- AliExternalTrackParam trckPOut;
- friendTrackP->GetTrackParamTPCOut(trckPOut);
- if ( (friendTrackP->GetTrackParamTPCOut(trckPOut)) < 0) continue;
- AliExternalTrackParam * trackPOut = &trckPOut;
if (!trackPOut) continue;
-
// calculate necessary track parameters
Double_t meanP = trackPIn->GetP();
Double_t meanDrift = 250 - 0.5*TMath::Abs(trackPIn->GetZ() + trackPOut->GetZ());
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)};
- //Printf("Fill Gain histo in v0 loop...");
- fHistGainTime->Fill(vec);
+ fHistGainTime->Fill(vec);
}
}
class TH2F;
class TList;
class TGraphErrors;
-//class AliESDEvent;
-class AliVEvent;
-//class AliESDtrack;
-class AliVTrack;
+class AliESDEvent;
+class AliESDtrack;
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(AliVEvent *event);
+ virtual void Process(AliESDEvent *event);
virtual Long64_t Merge(TCollection *li);
virtual void AnalyzeRun(Int_t minEntries);
//
- //void ProcessCosmicEvent(AliESDEvent *event);
- //void ProcessBeamEvent(AliESDEvent *event);
-
- void ProcessCosmicEvent(AliVEvent *event);
- void ProcessBeamEvent(AliVEvent *event);
+ void ProcessCosmicEvent(AliESDEvent *event);
+ void ProcessBeamEvent(AliESDEvent *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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliESDtrack *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 AliVEvent;
-class AliVTrack;
+class AliESDEvent;
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(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);}
+ void Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);};
+ void Process(AliESDtrack *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 AliVTrack * track) const {
+Int_t AliTPCcalibTracksCuts::AcceptTrack(const AliESDtrack * track) const {
//
// Function, that decides wheather a given track is accepted for
// the analysis or not.
class TChain;
class AliTPCseed;
-class AliVTrack;
+class AliESDtrack;
using namespace std;
static AliTPCcalibTracksCuts *CreateCuts(char* ctype);
Int_t AcceptTrack(const AliTPCseed * track) const;
- Int_t AcceptTrack(const AliVTrack * track) const;
+ Int_t AcceptTrack(const AliESDtrack * 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(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);}
+ void Process(AliESDEvent *event) {AliTPCcalibBase::Process(event);};
+ void Process(AliESDtrack *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 "AliESDVertex.h"
-
-#include "AliVEvent.h"
-#include "AliVTrack.h"
-#include "AliVfriendTrack.h"
-#include "AliVfriendEvent.h"
-
+#include "AliESDfriendTrack.h"
#include "AliMathBase.h"
#include "AliTPCseed.h"
#include "AliTPCclusterMI.h"
fV0Tree(0),
fHPTTree(0),
fStack(0),
- fEvent(0),
+ fESD(0),
fPdg(0),
fParticles(0),
fV0s(0),
fV0Tree(0),
fHPTTree(0),
fStack(0),
- fEvent(0),
+ fESD(0),
fPdg(0),
fParticles(0),
fV0s(0),
-void AliTPCcalibV0::ProcessESD(AliVEvent *event){
+void AliTPCcalibV0::ProcessESD(AliESDEvent *esd){
//
//
//
- fEvent = event;
- AliKFParticle::SetField(event->GetMagneticField());
+ fESD = esd;
+ AliKFParticle::SetField(esd->GetMagneticField());
if (TMath::Abs(AliTracker::GetBz())<1) return;
- DumpToTree(event);
- DumpToTreeHPT(event);
+ DumpToTree(esd);
+ DumpToTreeHPT(esd);
}
-void AliTPCcalibV0::DumpToTreeHPT(AliVEvent *event){
+void AliTPCcalibV0::DumpToTreeHPT(AliESDEvent *esd){
//
// 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.;
- AliVfriendEvent *friendEvent=event->FindFriend();
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
// if (!esdFriend) {
// Printf("ERROR: esdFriend not available");
// return;
// }
//
- Int_t ntracks=event->GetNumberOfTracks();
+ Int_t ntracks=esd->GetNumberOfTracks();
for (Int_t i=0;i<ntracks;++i) {
Bool_t isOK=kFALSE;
- AliVTrack *track = event->GetVTrack(i);
- if(!track) continue;
+ AliESDtrack *track = esd->GetTrack(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(AliVTrack::kITSrefit)) isAccepted=kFALSE;
- if (!track->IsOn(AliVTrack::kTPCrefit)) isAccepted=kFALSE;
- if (!track->IsOn(AliVTrack::kTOFout)) isAccepted=kFALSE;
+ if (!track->IsOn(AliESDtrack::kITSrefit)) isAccepted=kFALSE;
+ if (!track->IsOn(AliESDtrack::kTPCrefit)) isAccepted=kFALSE;
+ if (!track->IsOn(AliESDtrack::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(AliVTrack::kITSin)||track->IsOn(AliVTrack::kTRDout)||track->IsOn(AliVTrack::kTOFin))
+ if (track->IsOn(AliESDtrack::kITSin)||track->IsOn(AliESDtrack::kTRDout)||track->IsOn(AliESDtrack::kTOFin))
isOK=kTRUE;
if (isOK){
TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
- Int_t eventNumber = event->GetEventNumberInFile();
- Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(i)!=0):0;
+ Int_t eventNumber = esd->GetEventNumberInFile();
+ Bool_t hasFriend=(esdFriend) ? (esdFriend->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 = event->GetEventNumberInFile();
- Bool_t hasFriend=(friendEvent) ? (friendEvent->GetTrack(i)!=0):0;
+ Int_t eventNumber = esd->GetEventNumberInFile();
+ Bool_t hasFriend=(esdFriend) ? (esdFriend->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 (!friendEvent) continue;
- const AliVfriendTrack *friendTrack = friendEvent->GetTrack(i);
+ if (!esdFriend) continue;
+ AliESDfriendTrack *friendTrack = esdFriend->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.",&dummytrack);
- fHPTTree->Branch("ft.",&dummyfriendTrack);
+ fHPTTree->Branch("t.",&track);
+ fHPTTree->Branch("ft.",&friendTrack);
fHPTTree->Branch("s.",&seed);
}else{
- fHPTTree->SetBranchAddress("t.",&dummytrack);
- fHPTTree->SetBranchAddress("ft.",&dummyfriendTrack);
+ fHPTTree->SetBranchAddress("t.",&track);
+ fHPTTree->SetBranchAddress("ft.",&friendTrack);
fHPTTree->SetBranchAddress("s.",&seed);
}
fHPTTree->Fill();
-void AliTPCcalibV0::DumpToTree(AliVEvent *event){
+void AliTPCcalibV0::DumpToTree(AliESDEvent *esd){
//
// Dump V0s fith full firend information to the
//
- Int_t nV0s = fEvent->GetNumberOfV0s();
+ Int_t nV0s = fESD->GetNumberOfV0s();
const Int_t kMinCluster=110;
const Double_t kDownscale=0.01;
const Float_t kMinPt =1.0;
const Float_t kMinMinPt =0.7;
- AliVfriendEvent *friendEvent=event->FindFriend();
+ AliESDfriend *esdFriend=static_cast<AliESDfriend*>(esd->FindListObject("AliESDfriend"));
//
for (Int_t ivertex=0; ivertex<nV0s; ivertex++){
Bool_t isOK=kFALSE;
- 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) continue;
+ AliESDv0 * v0 = (AliESDv0*) esd->GetV0(ivertex);
+ AliESDtrack * track0 = fESD->GetTrack(v0->GetIndex(0)); // negative track
+ AliESDtrack * track1 = fESD->GetTrack(v0->GetIndex(1)); // positive track
if (track0->GetTPCNcls()<kMinCluster) continue;
- if (track0->GetKinkIndex(0)>0) continue;
- if(!track1) continue;
+ if (track0->GetKinkIndex(0)>0) continue;
if (track1->GetTPCNcls()<kMinCluster) continue;
if (track1->GetKinkIndex(0)>0) continue;
if (v0->GetOnFlyStatus()==kFALSE) continue;
if (!isOK) continue;
//
TString filename(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
- Int_t eventNumber = event->GetEventNumberInFile();
+ Int_t eventNumber = esd->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,(friendEvent!=0), hasITS);
+ printf("DUMPHPTV0:%s|%f|%d|%d|%d\n",filename.Data(), (TMath::Min(track0->Pt(),track1->Pt())), eventNumber,(esdFriend!=0), hasITS);
//
- if (!friendEvent) continue;
+ if (!esdFriend) continue;
//
//
- const AliVfriendTrack *ftrack0 = friendEvent->GetTrack(v0->GetIndex(0));
+ AliESDfriendTrack *ftrack0 = esdFriend->GetTrack(v0->GetIndex(0));
if (!ftrack0) continue;
- const AliVfriendTrack *ftrack1 = friendEvent->GetTrack(v0->GetIndex(1));
+ AliESDfriendTrack *ftrack1 = esdFriend->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.",&dummytrack0);
- fV0Tree->Branch("t1.",&dummytrack1);
- fV0Tree->Branch("ft0.",&dummyftrack0);
- fV0Tree->Branch("ft1.",&dummyftrack1);
+ fV0Tree->Branch("t0.",&track0);
+ fV0Tree->Branch("t1.",&track1);
+ fV0Tree->Branch("ft0.",&ftrack0);
+ fV0Tree->Branch("ft1.",&ftrack1);
fV0Tree->Branch("s0.",&seed0);
fV0Tree->Branch("s1.",&seed1);
}else{
fV0Tree->SetBranchAddress("v0.",&v0);
- fV0Tree->SetBranchAddress("t0.",&dummytrack0);
- fV0Tree->SetBranchAddress("t1.",&dummytrack1);
- fV0Tree->SetBranchAddress("ft0.",&dummyftrack0);
- fV0Tree->SetBranchAddress("ft1.",&dummyftrack1);
+ fV0Tree->SetBranchAddress("t0.",&track0);
+ fV0Tree->SetBranchAddress("t1.",&track1);
+ fV0Tree->SetBranchAddress("ft0.",&ftrack0);
+ fV0Tree->SetBranchAddress("ft1.",&ftrack1);
fV0Tree->SetBranchAddress("s0.",&seed0);
fV0Tree->SetBranchAddress("s1.",&seed1);
}
-void AliTPCcalibV0::FilterV0s(AliVEvent *event){
+void AliTPCcalibV0::FilterV0s(AliESDEvent* event){
//
//
TDatabasePDG pdg;
const Double_t ptCut=0.2;
const Int_t kMinNcl=110;
//
- 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;
+ Int_t nv0 = event->GetNumberOfV0s();
+ AliESDVertex *vertex= (AliESDVertex *)event->GetPrimaryVertex();
AliKFVertex kfvertex=*vertex;
-
//
for (Int_t iv0=0;iv0<nv0;iv0++){
- AliESDv0 dummyv0;
- event->GetV0(dummyv0,iv0);
- AliESDv0 *v0=&dummyv0;
-
+ AliESDv0 *v0 = event->GetV0(iv0);
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){
- AliVTrack * trackP = event->GetVTrack(v0->GetPindex());
- AliVTrack * trackN = event->GetVTrack(v0->GetNindex());
+ AliESDtrack * trackP = event->GetTrack(v0->GetPindex());
+ AliESDtrack * trackN = event->GetTrack(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 AliVEvent;
-class AliVTrack;
+class AliESDtrack;
+class AliESDEvent;
class TH3F;
class TH1F;
class TH2F;
AliTPCcalibV0();
AliTPCcalibV0(const Text_t *name, const Text_t *title);
virtual ~AliTPCcalibV0();
- virtual void Process(AliVEvent *event) {return ProcessESD(event);}
- void FilterV0s(AliVEvent* event);
+ virtual void Process(AliESDEvent *event) {return ProcessESD(event);}
+ void FilterV0s(AliESDEvent* event);
Long64_t Merge(TCollection *const li);
void AddTree(TTree * treeInput);
void AddTreeHPT(TTree * treeInput);
//
//
//
- void ProcessESD(AliVEvent *event);
- void DumpToTree(AliVEvent *event);
- void DumpToTreeHPT(AliVEvent *event);
+ void ProcessESD(AliESDEvent *esd);
+ void DumpToTree(AliESDEvent *esd);
+ void DumpToTreeHPT(AliESDEvent *esd);
TTree * GetV0Tree(){return fV0Tree;}
TTree * GetHPTTree(){return fHPTTree;}
//
TTree *fHPTTree; // tree with high mometa tracks - full calib info
//
AliStack *fStack; // pointer to kinematic tree
- AliVEvent *fEvent; //! current ED to proccess - NOT OWNER
+ AliESDEvent *fESD; //! 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(AliVTrack *track, Int_t runNo=-1){AliTPCcalibBase::Process(track,runNo);}
+ void Process(AliESDtrack *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