//________________________________________________________________________
AliAnalysisTaskVertexESD::AliAnalysisTaskVertexESD(const char *name) :
-AliAnalysisTask(name, "VertexESDTask"),
+AliAnalysisTaskSE(name),
fCheckEventType(kTRUE),
fReadMC(kFALSE),
fRecoVtxTPC(kFALSE),
fRecoVtxITSTPC(kFALSE),
+fRecoVtxITSTPCHalfEvent(kFALSE),
fOnlyITSTPCTracks(kFALSE),
fOnlyITSSATracks(kFALSE),
+fFillNtuple(kFALSE),
+fFillNtupleBeamSpot(kFALSE),
fESD(0),
fOutput(0),
fNtupleVertexESD(0),
-fhTrackRefs(0)
+fhSPDVertexX(0),
+fhSPDVertexY(0),
+fhSPDVertexZ(0),
+fhTRKVertexX(0),
+fhTRKVertexY(0),
+fhTRKVertexZ(0),
+fhTPCVertexX(0),
+fhTPCVertexY(0),
+fhTPCVertexZ(0),
+fhTrackRefs(0),
+fNtupleBeamSpot(0)
{
// Constructor
// Define input and output slots here
- // Input slot #0 works with a TChain
- DefineInput(0, TChain::Class());
// Output slot #0 writes into a TList container
- DefineOutput(0, TList::Class()); //My private output
+ DefineOutput(1, TList::Class()); //My private output
}
//________________________________________________________________________
AliAnalysisTaskVertexESD::~AliAnalysisTaskVertexESD()
}
}
-//________________________________________________________________________
-void AliAnalysisTaskVertexESD::ConnectInputData(Option_t *)
-{
- // Connect ESD or AOD here
- // Called once
-
- TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
- if (!tree) {
- Printf("ERROR: Could not read chain from input slot 0");
- } else {
-
- AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
-
- if (!esdH) {
- Printf("ERROR: Could not get ESDInputHandler");
- } else {
- fESD = esdH->GetEvent();
- }
-
- }
-
- return;
-}
//________________________________________________________________________
-void AliAnalysisTaskVertexESD::CreateOutputObjects()
+void AliAnalysisTaskVertexESD::UserCreateOutputObjects()
{
// Create histograms
// Called once
fOutput = new TList;
fOutput->SetOwner();
- fNtupleVertexESD = new TNtuple("fNtupleVertexESD","vertices","run:tstamp:xtrue:ytrue:ztrue:xSPD:xerrSPD:ySPD:yerrSPD:zSPD:zerrSPD:ntrksSPD:xTPC:xerrTPC:yTPC:yerrTPC:zTPC:zerrTPC:ntrksTPC:xTRK:xerrTRK:yTRK:yerrTRK:zTRK:zerrTRK:ntrksTRK:ntrklets:nESDtracks:nITSrefit5or6:nTPCin:nTPCinEta09:dndygen:triggered:SPD3D:SPD0cls:constrTRK:constrTPC");
+ fNtupleVertexESD = new TNtuple("fNtupleVertexESD","vertices","run:tstamp:bunchcross:triggered:dndygen:xtrue:ytrue:ztrue:xSPD:xerrSPD:ySPD:yerrSPD:zSPD:zerrSPD:ntrksSPD:SPD3D:dphiSPD:xTPC:xerrTPC:yTPC:yerrTPC:zTPC:zerrTPC:ntrksTPC:constrTPC:xTRK:xerrTRK:yTRK:yerrTRK:zTRK:zerrTRK:ntrksTRK:constrTRK:ntrklets:nESDtracks:nITSrefit5or6:nTPCin:nTPCinEta09:SPD0cls:xSPDp:xerrSPDp:ySPDp:yerrSPDp:zSPDp:zerrSPDp:ntrksSPDp:xTPCnc:xerrTPCnc:yTPCnc:yerrTPCnc:zTPCnc:zerrTPCnc:ntrksTPCnc:xTPCc:xerrTPCc:yTPCc:yerrTPCc:zTPCc:zerrTPCc:ntrksTPCc:xTRKnc:xerrTRKnc:yTRKnc:yerrTRKnc:zTRKnc:zerrTRKnc:ntrksTRKnc:xTRKc:xerrTRKc:yTRKc:yerrTRKc:zTRKc:zerrTRKc:ntrksTRKc:deltaxTRKnc:deltayTRKnc:deltazTRKnc:deltaxerrTRKnc:deltayerrTRKnc:deltazerrTRKnc:ntrksEvenTRKnc:ntrksOddTRKnc");
fOutput->Add(fNtupleVertexESD);
+ fhSPDVertexX = new TH1F("fhSPDVertexX","SPDVertex x; x vertex [cm]; events",200,-1,1);
+ fOutput->Add(fhSPDVertexX);
+ fhSPDVertexY = new TH1F("fhSPDVertexY","SPDVertex y; y vertex [cm]; events",200,-1,1);
+ fOutput->Add(fhSPDVertexY);
+ fhSPDVertexZ = new TH1F("fhSPDVertexZ","SPDVertex z; z vertex [cm]; events",200,-20,20);
+ fOutput->Add(fhSPDVertexZ);
+ fhTRKVertexX = new TH1F("fhTRKVertexX","TRKVertex x; x vertex [cm]; events",200,-1,1);
+ fOutput->Add(fhTRKVertexX);
+ fhTRKVertexY = new TH1F("fhTRKVertexY","TRKVertex y; y vertex [cm]; events",200,-1,1);
+ fOutput->Add(fhTRKVertexY);
+ fhTRKVertexZ = new TH1F("fhTRKVertexZ","TRKVertex z; z vertex [cm]; events",200,-20,20);
+ fOutput->Add(fhTRKVertexZ);
+ fhTPCVertexX = new TH1F("fhTPCVertexX","TPCVertex x; x vertex [cm]; events",200,-3,3);
+ fOutput->Add(fhTPCVertexX);
+ fhTPCVertexY = new TH1F("fhTPCVertexY","TPCVertex y; y vertex [cm]; events",200,-3,3);
+ fOutput->Add(fhTPCVertexY);
+ fhTPCVertexZ = new TH1F("fhTPCVertexZ","TPCVertex z; z vertex [cm]; events",200,-20,20);
+ fOutput->Add(fhTPCVertexZ);
+
fhTrackRefs = new TH2F("fhTrackRefs","Track references; x; y",1000,-4,4,1000,-4,4);
fOutput->Add(fhTrackRefs);
+ fNtupleBeamSpot = new TNtuple("fNtupleBeamSpot", "beamSpot", "run:tstamp:triggered:ntrklets:xTRKnc:yTRKnc:zTRKnc:ntrksTRKnc");
+ fOutput->Add(fNtupleBeamSpot);
+ PostData(1, fOutput);
+
return;
}
//________________________________________________________________________
-void AliAnalysisTaskVertexESD::Exec(Option_t *)
+void AliAnalysisTaskVertexESD::UserExec(Option_t *)
{
// Main loop
// Called for each event
- if (!fESD) {
+ if (!InputEvent()) {
Printf("ERROR: fESD not available");
return;
}
-
- if(fCheckEventType && (fESD->GetEventType())!=7) return;
+ AliESDEvent* esdE = (AliESDEvent*) InputEvent();
+
+ if(fCheckEventType && (esdE->GetEventType())!=7) return;
TArrayF mcVertex(3);
mcVertex[0]=9999.; mcVertex[1]=9999.; mcVertex[2]=9999.;
Float_t dNchdy=-999.;
-
// *********** MC info ***************
if (fReadMC) {
AliMCEventHandler* eventHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
//ULong64_t v0left = (1 << 10);
//ULong64_t v0right = (1 << 11);
- //triggerMask=fESD->GetTriggerMask();
+ //triggerMask=esdE->GetTriggerMask();
// MB1: SPDFO || V0L || V0R
//Bool_t eventTriggered = (triggerMask & spdFO || ((triggerMask & v0left) || (triggerMask & v0right)));
//MB2: GFO && V0R
//Bool_t eventTriggered = (triggerMask & spdFO);
//static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis();
- Bool_t eventTriggered = 0;//triggerAnalysis->IsTriggerFired(fESD, AliTriggerAnalysis::kSPDGFO /*| AliTriggerAnalysis::kOfflineFlag*/);
+ Bool_t eventTriggered = 0;//triggerAnalysis->IsTriggerFired(esdE, AliTriggerAnalysis::kSPDGFO /*| AliTriggerAnalysis::kOfflineFlag*/);
+
+ // use response of AliPhysicsSelection
+ eventTriggered = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
- Int_t ntracks = fESD->GetNumberOfTracks();
+ const AliMultiplicity *alimult = esdE->GetMultiplicity();
+ Int_t ntrklets=0,spd0cls=0;
+ if(alimult) {
+ ntrklets = alimult->GetNumberOfTracklets();
+
+ // if (ntrklets<10) return;
+
+ for(Int_t l=0;l<alimult->GetNumberOfTracklets();l++){
+ if(alimult->GetDeltaPhi(l)<-9998.) ntrklets--;
+ }
+ spd0cls = alimult->GetNumberOfSingleClusters()+ntrklets;
+ }
+
+
+ Float_t tstamp = esdE->GetTimeStamp();
+ Float_t cetTime = tstamp-1262307600.;
+
+ Int_t ntracks = esdE->GetNumberOfTracks();
Int_t nITS5or6=0,nTPCin=0,nTPCinEta09=0;
- //printf("Tracks # = %d\n",fESD->GetNumberOfTracks());
+ //printf("Tracks # = %d\n",esdE->GetNumberOfTracks());
for(Int_t itr=0; itr<ntracks; itr++) {
- AliESDtrack *t = fESD->GetTrack(itr);
+ AliESDtrack *t = esdE->GetTrack(itr);
if(t->GetNcls(0)>=5) nITS5or6++;
- Double_t z0; t->GetZAt(0,fESD->GetMagneticField(),z0);
- if(t->GetNcls(1)>0 && TMath::Abs(t->GetD(0,0,fESD->GetMagneticField()))<2.8 && TMath::Abs(z0)<20) {
+ Double_t z0; t->GetZAt(0,esdE->GetMagneticField(),z0);
+ if(t->GetNcls(1)>0 && TMath::Abs(t->GetD(0,0,esdE->GetMagneticField()))<2.8 && TMath::Abs(z0)<20) {
nTPCin++;
if(TMath::Abs(t->GetTgl())<1.5) nTPCinEta09++;
}
}
- const AliESDVertex *spdv=fESD->GetPrimaryVertexSPD();
- const AliESDVertex *tpcv=fESD->GetPrimaryVertexTPC();
- const AliESDVertex *trkv=fESD->GetPrimaryVertexTracks();
-
- //Float_t tpccontrorig=tpcv->GetNContributors();
+ const AliESDVertex *spdv=esdE->GetPrimaryVertexSPD();
+ const AliESDVertex *spdvp=esdE->GetPileupVertexSPD(0);
+ const AliESDVertex *tpcv=esdE->GetPrimaryVertexTPC();
+ const AliESDVertex *trkv=esdE->GetPrimaryVertexTracks();
- if(fRecoVtxTPC) {
- tpcv = 0;
- tpcv = ReconstructPrimaryVertexTPC();
+
+
+ // fill histos
+
+ if(spdv) {
+ if(spdv->GetNContributors()>0) {
+ TString title=spdv->GetTitle();
+ if(title.Contains("3D")) {
+ fhSPDVertexX->Fill(spdv->GetXv());
+ fhSPDVertexY->Fill(spdv->GetYv());
+ }
+ fhSPDVertexZ->Fill(spdv->GetZv());
+ }
}
- if(fRecoVtxITSTPC) {
- trkv = 0;
- trkv = ReconstructPrimaryVertexITSTPC();
+
+ if(trkv) {
+ if(trkv->GetNContributors()>0) {
+ fhTRKVertexX->Fill(trkv->GetXv());
+ fhTRKVertexY->Fill(trkv->GetYv());
+ fhTRKVertexZ->Fill(trkv->GetZv());
+ }
}
-
- const AliMultiplicity *alimult = fESD->GetMultiplicity();
- Int_t ntrklets=0,spd0cls=0;
- if(alimult) {
- ntrklets = alimult->GetNumberOfTracklets();
- for(Int_t l=0;l<alimult->GetNumberOfTracklets();l++){
- if(alimult->GetDeltaPhi(l)<-9998.) ntrklets--;
+
+ if(tpcv) {
+ if(tpcv->GetNContributors()>0) {
+ fhTPCVertexX->Fill(tpcv->GetXv());
+ fhTPCVertexY->Fill(tpcv->GetYv());
+ fhTPCVertexZ->Fill(tpcv->GetZv());
}
- spd0cls = alimult->GetNumberOfSingleClusters()+ntrklets;
+ }
+
+ Float_t xpile=-999.;
+ Float_t ypile=-999.;
+ Float_t zpile=-999.;
+ Float_t expile=-999.;
+ Float_t eypile=-999.;
+ Float_t ezpile=-999.;
+ Int_t ntrkspile=-1;
+
+ if(esdE->GetNumberOfPileupVerticesSPD()>0 && spdvp){
+ xpile=spdvp->GetXv();
+ expile=spdvp->GetXRes();
+ ypile=spdvp->GetYv();
+ eypile=spdvp->GetYRes();
+ zpile=spdvp->GetZv();
+ ezpile=spdvp->GetZRes();
+ ntrkspile=spdvp->GetNContributors();
}
+ // fill ntuple
+ Int_t isize=82;
+ Float_t xnt[82]; for(Int_t iii=0;iii<isize;iii++) xnt[iii]=0.;
+
+ Int_t isizeSecNt=8;
+ Float_t secnt[8]; for(Int_t iii=0;iii<isizeSecNt;iii++) secnt[iii]=0.;
- Int_t isize=37;
- Float_t xnt[37];
-
Int_t index=0;
+ Int_t indexSecNt=0;
+
+ xnt[index++]=(Float_t)esdE->GetRunNumber();
+ secnt[indexSecNt++]=(Float_t)esdE->GetRunNumber();
- xnt[index++]=(Float_t)fESD->GetRunNumber();
- xnt[index++]=(Float_t)fESD->GetTimeStamp();
+ xnt[index++]=cetTime; //(Float_t)esdE->GetTimeStamp();
+ secnt[indexSecNt++]=cetTime;
+ xnt[index++]=(Float_t)esdE->GetBunchCrossNumber();
+
+ xnt[index++]=(eventTriggered ? 1. : 0.);
+ secnt[indexSecNt++]=(eventTriggered ? 1. : 0.);
+
+ xnt[index++]=(Float_t)dNchdy;
+
xnt[index++]=mcVertex[0];
xnt[index++]=mcVertex[1];
xnt[index++]=mcVertex[2];
xnt[index++]=spdv->GetZv();
xnt[index++]=spdv->GetZRes();
xnt[index++]=spdv->GetNContributors();
+ TString spdtitle = spdv->GetTitle();
+ xnt[index++]=(spdtitle.Contains("vertexer: 3D") ? 1. : 0.);
+ xnt[index++]=spdv->GetDispersion();
xnt[index++]=tpcv->GetXv();
xnt[index++]=tpcv->GetXRes();
xnt[index++]=tpcv->GetZv();
xnt[index++]=tpcv->GetZRes();
xnt[index++]=tpcv->GetNContributors();
+ TString tpctitle = tpcv->GetTitle();
+ xnt[index++]=(tpctitle.Contains("WithConstraint") ? 1. : 0.);
xnt[index++]=trkv->GetXv();
xnt[index++]=trkv->GetXRes();
xnt[index++]=trkv->GetZv();
xnt[index++]=trkv->GetZRes();
xnt[index++]=trkv->GetNContributors();// tpccontrorig;
-
+ TString trktitle = trkv->GetTitle();
+ xnt[index++]=(trktitle.Contains("WithConstraint") ? 1. : 0.);
xnt[index++]=float(ntrklets);
+ secnt[indexSecNt++]=float(ntrklets);
+
xnt[index++]=float(ntracks);
xnt[index++]=float(nITS5or6);
+
xnt[index++]=float(nTPCin);
xnt[index++]=float(nTPCinEta09);
- xnt[index++]=float(dNchdy);
-
- xnt[index++]=(eventTriggered ? 1. : 0.);
-
- TString spdtitle = spdv->GetTitle();
- xnt[index++]=(spdtitle.Contains("vertexer: 3D") ? 1. : 0.);
-
xnt[index++]=spd0cls;
+
+ xnt[index++]=xpile;
+ xnt[index++]=expile;
+ xnt[index++]=ypile;
+ xnt[index++]=eypile;
+ xnt[index++]=zpile;
+ xnt[index++]=ezpile;
+ xnt[index++]=(Float_t)ntrkspile;
+
+
+
+ // add recalculated vertices TRK and TPC
- TString trktitle = trkv->GetTitle();
- xnt[index++]=(trktitle.Contains("WithConstraint") ? 1. : 0.);
-
- TString tpctitle = tpcv->GetTitle();
- xnt[index++]=(tpctitle.Contains("WithConstraint") ? 1. : 0.);
+ if(fRecoVtxTPC) {
+ AliESDVertex *tpcvnc = ReconstructPrimaryVertexTPC(kFALSE);
+ xnt[index++]=tpcvnc->GetXv();
+ xnt[index++]=tpcvnc->GetXRes();
+ xnt[index++]=tpcvnc->GetYv();
+ xnt[index++]=tpcvnc->GetYRes();
+ xnt[index++]=tpcvnc->GetZv();
+ xnt[index++]=tpcvnc->GetZRes();
+ xnt[index++]=tpcvnc->GetNContributors();
+ delete tpcvnc; tpcvnc=0;
+
+ AliESDVertex *tpcvc = ReconstructPrimaryVertexTPC(kTRUE);
+ xnt[index++]=tpcvc->GetXv();
+ xnt[index++]=tpcvc->GetXRes();
+ xnt[index++]=tpcvc->GetYv();
+ xnt[index++]=tpcvc->GetYRes();
+ xnt[index++]=tpcvc->GetZv();
+ xnt[index++]=tpcvc->GetZRes();
+ xnt[index++]=tpcvc->GetNContributors();
+ delete tpcvc; tpcvc=0;
+ } else index+=14;
+ if(fRecoVtxITSTPC) {
+ AliESDVertex *trkvnc = ReconstructPrimaryVertexITSTPC(kFALSE);
+ xnt[index++]=trkvnc->GetXv();
+ xnt[index++]=trkvnc->GetXRes();
+ xnt[index++]=trkvnc->GetYv();
+ xnt[index++]=trkvnc->GetYRes();
+ xnt[index++]=trkvnc->GetZv();
+ xnt[index++]=trkvnc->GetZRes();
+ xnt[index++]=trkvnc->GetNContributors();
+
+ secnt[indexSecNt++]=trkvnc->GetXv();
+ secnt[indexSecNt++]=trkvnc->GetYv();
+ secnt[indexSecNt++]=trkvnc->GetZv();
+ secnt[indexSecNt++]=trkvnc->GetNContributors();
+
+ delete trkvnc; trkvnc=0;
+
+
+ AliESDVertex *trkvc = ReconstructPrimaryVertexITSTPC(kTRUE);
+ xnt[index++]=trkvc->GetXv();
+ xnt[index++]=trkvc->GetXRes();
+ xnt[index++]=trkvc->GetYv();
+ xnt[index++]=trkvc->GetYRes();
+ xnt[index++]=trkvc->GetZv();
+ xnt[index++]=trkvc->GetZRes();
+ xnt[index++]=trkvc->GetNContributors();
+ delete trkvc; trkvc=0;
+ } else index+=14;
+
+ if(fRecoVtxITSTPCHalfEvent) {
+ AliESDVertex *trkvncodd = ReconstructPrimaryVertexITSTPC(kFALSE,1);
+ AliESDVertex *trkvnceven = ReconstructPrimaryVertexITSTPC(kFALSE,2);
+ if(trkvncodd->GetNContributors()>0 &&
+ trkvnceven->GetNContributors()>0) {
+ xnt[index++]=trkvncodd->GetXv()-trkvnceven->GetXv();
+ xnt[index++]=trkvncodd->GetYv()-trkvnceven->GetYv();
+ xnt[index++]=trkvncodd->GetZv()-trkvnceven->GetZv();
+ xnt[index++]=TMath::Sqrt(trkvncodd->GetXRes()*trkvncodd->GetXRes()+trkvnceven->GetXRes()*trkvnceven->GetXRes());
+ xnt[index++]=TMath::Sqrt(trkvncodd->GetYRes()*trkvncodd->GetYRes()+trkvnceven->GetYRes()*trkvnceven->GetYRes());
+ xnt[index++]=TMath::Sqrt(trkvncodd->GetZRes()*trkvncodd->GetZRes()+trkvnceven->GetZRes()*trkvnceven->GetZRes());
+ xnt[index++]=trkvnceven->GetNContributors();
+ xnt[index++]=trkvncodd->GetNContributors();
+ } else {
+ xnt[index++]=0.;
+ xnt[index++]=0.;
+ xnt[index++]=0.;
+ xnt[index++]=0.;
+ xnt[index++]=0.;
+ xnt[index++]=0.;
+ xnt[index++]=-1;
+ xnt[index++]=-1;
+ }
+ delete trkvncodd; trkvncodd=0;
+ delete trkvnceven; trkvnceven=0;
+ } else index+=8;
+
- if(index!=isize) printf("AliAnalysisTaskVertexESD: ERROR, index!=isize\n");
+ if(index>isize) printf("AliAnalysisTaskVertexESD: ERROR, index!=isize\n");
+ if(fFillNtuple) fNtupleVertexESD->Fill(xnt);
- fNtupleVertexESD->Fill(xnt);
+ if(indexSecNt>isizeSecNt) printf("AliAnalysisTaskVertexESD: ERROR, indexSecNt!=isizeSecNt\n");
+ if(fFillNtupleBeamSpot) fNtupleBeamSpot->Fill(secnt);
// Post the data already here
- PostData(0, fOutput);
+ PostData(1, fOutput);
return;
}
{
// Draw result to the screen
// Called once at the end of the query
- fOutput = dynamic_cast<TList*> (GetOutputData(0));
+ fOutput = dynamic_cast<TList*> (GetOutputData(1));
if (!fOutput) {
Printf("ERROR: fOutput not available");
return;
}
-
+
+ if (!fNtupleVertexESD){
+ Printf("ERROR: fNtuple not available");
+ return;
+ }
+
fNtupleVertexESD = dynamic_cast<TNtuple*>(fOutput->FindObject("fNtupleVertexESD"));
+ fNtupleBeamSpot = dynamic_cast<TNtuple*>(fOutput->FindObject("fNtupleBeamSpot"));
+
return;
}
//_________________________________________________________________________
-AliESDVertex* AliAnalysisTaskVertexESD::ReconstructPrimaryVertexTPC() const {
+AliESDVertex* AliAnalysisTaskVertexESD::ReconstructPrimaryVertexTPC(Bool_t constr) const {
// On the fly reco of TPC vertex from ESD
-
- AliVertexerTracks vertexer(fESD->GetMagneticField());
+ AliESDEvent* evt = (AliESDEvent*) fInputEvent;
+ AliVertexerTracks vertexer(evt->GetMagneticField());
vertexer.SetTPCMode(); // defaults
- //vertexer.SetTPCMode(0.1,1.0,5.,0,1,3.,0.1,1.5);
- Double_t pos[3]={+0.0220,-0.0340,+0.270};
- Double_t err[3]={0.0200,0.0200,7.5};
- AliESDVertex *initVertex = new AliESDVertex(pos,err);
+ Float_t diamondcovxy[3]; evt->GetDiamondCovXY(diamondcovxy);
+ Double_t pos[3]={evt->GetDiamondX(),evt->GetDiamondY(),0};
+ Double_t cov[6]={diamondcovxy[0],diamondcovxy[1],diamondcovxy[2],0.,0.,10.*10.};
+ AliESDVertex *initVertex = new AliESDVertex(pos,cov,1.,1);
vertexer.SetVtxStart(initVertex);
delete initVertex;
- vertexer.SetConstraintOff();
+ if(!constr) vertexer.SetConstraintOff();
- return vertexer.FindPrimaryVertex(fESD);
+ return vertexer.FindPrimaryVertex(evt);
}
//_________________________________________________________________________
-AliESDVertex* AliAnalysisTaskVertexESD::ReconstructPrimaryVertexITSTPC() const {
+AliESDVertex* AliAnalysisTaskVertexESD::ReconstructPrimaryVertexITSTPC(Bool_t constr,Int_t mode) const {
// On the fly reco of ITS+TPC vertex from ESD
+ // mode=0 use all tracks
+ // mode=1 use odd-number tracks
+ // mode=2 use even-number tracks
- AliVertexerTracks vertexer(fESD->GetMagneticField());
+ AliESDEvent* evt = (AliESDEvent*) fInputEvent;
+ AliVertexerTracks vertexer(evt->GetMagneticField());
vertexer.SetITSMode(); // defaults
- //vertexer.SetTPCMode(0.1,1.0,5.,0,1,3.,0.1,1.5);
- Double_t pos[3]={+0.0220,-0.0340,+0.270};
- Double_t err[3]={0.0200,0.0200,7.5};
- AliESDVertex *initVertex = new AliESDVertex(pos,err);
+ vertexer.SetMinClusters(4); // default is 5
+ //vertexer.SetITSpureSA();
+ Float_t diamondcovxy[3]; evt->GetDiamondCovXY(diamondcovxy);
+ Double_t pos[3]={evt->GetDiamondX(),evt->GetDiamondY(),0};
+ Double_t cov[6]={diamondcovxy[0],diamondcovxy[1],diamondcovxy[2],0.,0.,10.*10.};
+ AliESDVertex *initVertex = new AliESDVertex(pos,cov,1.,1);
vertexer.SetVtxStart(initVertex);
delete initVertex;
- vertexer.SetConstraintOff();
+ if(!constr) vertexer.SetConstraintOff();
// use only ITS-TPC or only ITS-SA tracks
- if(fOnlyITSTPCTracks || fOnlyITSSATracks) {
+ if(fOnlyITSTPCTracks || fOnlyITSSATracks || mode>0) {
Int_t iskip=0;
- Int_t *skip = new Int_t[fESD->GetNumberOfTracks()];
- for(Int_t itr=0;itr<fESD->GetNumberOfTracks(); itr++) {
- AliESDtrack* track = fESD->GetTrack(itr);
+ Int_t *skip = new Int_t[evt->GetNumberOfTracks()];
+ for(Int_t itr=0;itr<evt->GetNumberOfTracks(); itr++) {
+ AliESDtrack* track = evt->GetTrack(itr);
if(fOnlyITSTPCTracks && track->GetNcls(1)==0) { // skip ITSSA
skip[iskip++]=itr;
+ continue;
}
if(fOnlyITSSATracks && track->GetNcls(1)>0) { // skip ITSTPC
skip[iskip++]=itr;
+ continue;
}
+ if(mode==1 && itr%2==0) skip[iskip++]=itr;
+ if(mode==2 && itr%2==1) skip[iskip++]=itr;
}
vertexer.SetSkipTracks(iskip,skip);
delete [] skip; skip=NULL;
}
- return vertexer.FindPrimaryVertex(fESD);
+ return vertexer.FindPrimaryVertex(evt);
}