#include "AliExternalTrackParam.h"
#include "AliESDVertex.h"
#include "AliESDEvent.h"
-#include "AliESDfriend.h"
#include "AliESDInputHandler.h"
-#include "AliTrackPointArray.h"
#include "AliTrackReference.h"
+//#include "AliTriggerAnalysis.h"
#include "AliMCEventHandler.h"
#include "AliMCEvent.h"
//________________________________________________________________________
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),
-fESDfriend(0),
fOutput(0),
fNtupleVertexESD(0),
-fhTrackPoints(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 {
- // Disable all branches and enable only the needed ones
- // The next two lines are different when data produced as AliESDEvent is read
- // tree->SetBranchStatus("*", kFALSE);
- tree->SetBranchStatus("fTriggerMask", 1);
- tree->SetBranchStatus("fSPDVertex*", 1);
- tree->SetBranchStatus("fSPDMult*", 1);
-
- tree->SetBranchStatus("ESDfriend*", 1);
- tree->SetBranchAddress("ESDfriend.",&fESDfriend);
-
- 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","xtrue:ytrue:ztrue:xSPD:xdiffSPD:xerrSPD:ySPD:ydiffSPD:yerrSPD:zSPD:zdiffSPD:zerrSPD:ntrksSPD:xTPC:xdiffTPC:xerrTPC:yTPC:ydiffTPC:yerrTPC:zTPC:zdiffTPC:zerrTPC:ntrksTPC:xTRK:xdiffTRK:xerrTRK:yTRK:ydiffTRK:yerrTRK:zTRK:zdiffTRK:zerrTRK:ntrksTRK:ntrklets:nESDtracks:nITSrefit5or6:nTPCin:nTPCinEta09:dndygen:triggered:SPD3D:SPD0cls:constrTRK");
+ 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);
- fhTrackPoints = new TH2F("fhTrackPoints","Track points; x; y",1000,-4,4,1000,-4,4);
- fOutput->Add(fhTrackPoints);
+ 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);
- return;
+ 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;
}
-
+ 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());
}
// *********** MC info ***************
- // *********** ESD friends ***********
- fESD->SetESDfriend(fESDfriend); //Attach the friend to the ESD
- // *********** ESD friends ***********
-
- //
// Trigger
- ULong64_t triggerMask;
- ULong64_t spdFO = (1 << 14);
- ULong64_t v0left = (1 << 11);
- ULong64_t v0right = (1 << 12);
+ //ULong64_t triggerMask;
+ //ULong64_t spdFO = (1 << 14);
+ //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)));
+ //Bool_t eventTriggered = (triggerMask & spdFO || ((triggerMask & v0left) || (triggerMask & v0right)));
//MB2: GFO && V0R
//triggerMask & spdFO && ((triggerMask&v0left) || (triggerMask&v0right))
+ //Bool_t eventTriggered = (triggerMask & spdFO);
+ //static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis();
+ 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++;
}
- // tracks with two SPD points
- if(!TESTBIT(t->GetITSClusterMap(),0) ||
- !TESTBIT(t->GetITSClusterMap(),1)) continue;
- // AliTrackPoints
- const AliTrackPointArray *array = t->GetTrackPointArray();
- AliTrackPoint point;
- for(Int_t ipt=0; ipt<array->GetNPoints(); ipt++) {
- array->GetPoint(point,ipt);
- fhTrackPoints->Fill(point.GetX(),point.GetY());
- }
}
- const AliESDVertex *spdv=fESD->GetPrimaryVertexSPD();
- const AliESDVertex *tpcv=fESD->GetPrimaryVertexTPC();
- const AliESDVertex *trkv=fESD->GetPrimaryVertex();
+ const AliESDVertex *spdv=esdE->GetPrimaryVertexSPD();
+ const AliESDVertex *spdvp=esdE->GetPileupVertexSPD(0);
+ const AliESDVertex *tpcv=esdE->GetPrimaryVertexTPC();
+ const AliESDVertex *trkv=esdE->GetPrimaryVertexTracks();
- //Float_t tpccontrorig=tpcv->GetNContributors();
- //tpcv = 0;
- //tpcv = ReconstructPrimaryVertexTPC();
-
- 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--;
+
+
+ // 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());
}
- spd0cls = alimult->GetNumberOfSingleClusters()+ntrklets;
}
+
+ if(trkv) {
+ if(trkv->GetNContributors()>0) {
+ fhTRKVertexX->Fill(trkv->GetXv());
+ fhTRKVertexY->Fill(trkv->GetYv());
+ fhTRKVertexZ->Fill(trkv->GetZv());
+ }
+ }
+
+ if(tpcv) {
+ if(tpcv->GetNContributors()>0) {
+ fhTPCVertexX->Fill(tpcv->GetXv());
+ fhTPCVertexY->Fill(tpcv->GetYv());
+ fhTPCVertexZ->Fill(tpcv->GetZv());
+ }
+ }
+
+ 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 index=0;
+ Int_t indexSecNt=0;
+
+ xnt[index++]=(Float_t)esdE->GetRunNumber();
+ secnt[indexSecNt++]=(Float_t)esdE->GetRunNumber();
+ xnt[index++]=cetTime; //(Float_t)esdE->GetTimeStamp();
+ secnt[indexSecNt++]=cetTime;
- Float_t xnt[43];
+ xnt[index++]=(Float_t)esdE->GetBunchCrossNumber();
+
+ xnt[index++]=(eventTriggered ? 1. : 0.);
+ secnt[indexSecNt++]=(eventTriggered ? 1. : 0.);
- xnt[0]=mcVertex[0];
- xnt[1]=mcVertex[1];
- xnt[2]=mcVertex[2];
+ xnt[index++]=(Float_t)dNchdy;
- xnt[3]=spdv->GetXv();
- xnt[4]=(spdv->GetXv()-mcVertex[0])*10000.;
- xnt[5]=spdv->GetXRes();
- xnt[6]=spdv->GetYv();
- xnt[7]=(spdv->GetYv()-mcVertex[1])*10000.;
- xnt[8]=spdv->GetYRes();
- xnt[9]=spdv->GetZv();
- xnt[10]=(spdv->GetZv()-mcVertex[2])*10000.;
- xnt[11]=spdv->GetZRes();
- xnt[12]=spdv->GetNContributors();
+ xnt[index++]=mcVertex[0];
+ xnt[index++]=mcVertex[1];
+ xnt[index++]=mcVertex[2];
- xnt[13]=tpcv->GetXv();
- xnt[14]=(tpcv->GetXv()-mcVertex[0])*10000.;
- xnt[15]=tpcv->GetXRes();
- xnt[16]=tpcv->GetYv();
- xnt[17]=(tpcv->GetYv()-mcVertex[1])*10000.;
- xnt[18]=tpcv->GetYRes();
- xnt[19]=tpcv->GetZv();
- xnt[20]=(tpcv->GetZv()-mcVertex[2])*10000.;
- xnt[21]=tpcv->GetZRes();
- xnt[22]=tpcv->GetNContributors();
+ xnt[index++]=spdv->GetXv();
+ xnt[index++]=spdv->GetXRes();
+ xnt[index++]=spdv->GetYv();
+ xnt[index++]=spdv->GetYRes();
+ 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[23]=trkv->GetXv();
- xnt[24]=(trkv->GetXv()-mcVertex[0])*10000.;
- xnt[25]=trkv->GetXRes();
- xnt[26]=trkv->GetYv();
- xnt[27]=(trkv->GetYv()-mcVertex[1])*10000.;
- xnt[28]=trkv->GetYRes();
- xnt[29]=trkv->GetZv();
- xnt[30]=(trkv->GetZv()-mcVertex[2])*10000.;
- xnt[31]=trkv->GetZRes();
- xnt[32]=trkv->GetNContributors();// tpccontrorig;
+ xnt[index++]=tpcv->GetXv();
+ xnt[index++]=tpcv->GetXRes();
+ xnt[index++]=tpcv->GetYv();
+ xnt[index++]=tpcv->GetYRes();
+ 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->GetYv();
+ xnt[index++]=trkv->GetYRes();
+ 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[33]=float(ntrklets);
- xnt[34]=float(ntracks);
- xnt[35]=float(nITS5or6);
- xnt[36]=float(nTPCin);
- xnt[37]=float(nTPCinEta09);
-
- xnt[38]=float(dNchdy);
+ xnt[index++]=float(ntrklets);
+ secnt[indexSecNt++]=float(ntrklets);
- xnt[39]=0.;
- if(eventTriggered) xnt[39]=1.;
+ xnt[index++]=float(ntracks);
+ xnt[index++]=float(nITS5or6);
- xnt[40]=0.;
- TString spdtitle = spdv->GetTitle();
- if(spdtitle.Contains("vertexer: 3D")) xnt[40]=1.;
+ xnt[index++]=float(nTPCin);
+ xnt[index++]=float(nTPCinEta09);
- xnt[42]=0.;
- TString trktitle = trkv->GetTitle();
- if(trktitle.Contains("WithConstraint")) xnt[42]=1.;
+ 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
+
+ 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;
+
- xnt[41]=spd0cls;
+ 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() {
+AliESDVertex* AliAnalysisTaskVertexESD::ReconstructPrimaryVertexTPC(Bool_t constr) const {
// On the fly reco of TPC vertex from ESD
+ AliESDEvent* evt = (AliESDEvent*) fInputEvent;
+ AliVertexerTracks vertexer(evt->GetMagneticField());
+ vertexer.SetTPCMode(); // defaults
+ 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;
+ if(!constr) vertexer.SetConstraintOff();
+
+ return vertexer.FindPrimaryVertex(evt);
+}
- AliVertexerTracks vertexer(fESD->GetMagneticField());
- vertexer.SetTPCMode(0.1,1.0,5.,0,1,3.,0.1,1.5); // defaults
- //vertexer.SetTPCMode(0.1,1.0,5.,0,1,3.,0.1,1.5); // defaults
- 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);
+//_________________________________________________________________________
+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
+
+ AliESDEvent* evt = (AliESDEvent*) fInputEvent;
+ AliVertexerTracks vertexer(evt->GetMagneticField());
+ vertexer.SetITSMode(); // defaults
+ 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 || mode>0) {
+ Int_t iskip=0;
+ 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);
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff