fESD(0),
fMC(0),
fStack(0),
+ fVtx(0x0),
fTrackCuts(0),
- fTrackCutsITS(0),
+ fTrackCutsReject(),
fTrackType(0),
+ fSigmaConstrainedMax(1e6),
fPtMax(100.),
fAvgTrials(1),
fNEventAll(0),
fh1PtHardTrials(0),
fPtAll(0),
fPtSel(0),
+ fPtSelFakes(0),
+ fNPointTPCFakes(0),
+ fPtSelLargeLabel(0),
+ fMultRec(0),
+ fNPointTPCMultRec(0),
+ fDeltaPtMultRec(0),
+ fPtAllvsPtMC(0),
fPtAllminPtMCvsPtAll(0),
+ fPtAllvsPtMCvsMult(0),
+ fPtAllminPtMCvsPtAllvsMult(0),
fPtAllminPtMCvsPtAllNPointTPC(0),
+ fPtAllminPtMCvsPtAllNPointTPCIter1(0),
+ fPtAllminPtMCvsPtAllChi2TPC(0),
+ fPtAllminPtMCvsPtAllChi2TPCIter1(0),
fPtAllminPtMCvsPtAllDCAR(0),
fPtAllminPtMCvsPtAllDCAZ(0),
fPtAllminPtMCvsPtAllPhi(0),
fPtAllminPtMCvsPtAllRel1PtUncertainty(0),
fPtAllMC(0),
fPtSelMC(0),
- fPtSelMCITS(0),
- fHistList(0),
- fPtSelITS(0),
- fPtITSminPtMCvsPtITS(0),
- fPtITSminPtMCvsPtITSNPointTPC(0),
- fPtITSminPtMCvsPtITSDCAR(0),
- fPtITSminPtMCvsPtITSDCAZ(0),
- fPtITSminPtMCvsPtITSPhi(0),
- fPtITSminPtMCvsPtITSNPointITS(0),
- fPtITSminPtMCvsPtITSNSigmaToVertex(0),
- fPtITSminPtMCvsPtITSChi2C(0),
- fPtITSminPtMCvsPtITSRel1PtUncertainty(0),
- fHistListITS(0)
+ fHistList(0)
{
+ fPtBinEdges[0][0] = 10.;
+ fPtBinEdges[0][1] = 1.;
+ fPtBinEdges[1][0] = 20.;
+ fPtBinEdges[1][1] = 2.;
+ fPtBinEdges[2][0] = 100.;
+ fPtBinEdges[2][1] = 10.;
+
}
//________________________________________________________________________
AliPWG4HighPtQAMC::AliPWG4HighPtQAMC(const char *name):
fESD(0),
fMC(0),
fStack(0),
+ fVtx(0x0),
fTrackCuts(),
- fTrackCutsITS(),
+ fTrackCutsReject(),
fTrackType(0),
+ fSigmaConstrainedMax(1e6),
fPtMax(100.),
fAvgTrials(1),
fNEventAll(0),
fh1PtHardTrials(0),
fPtAll(0),
fPtSel(0),
+ fPtSelFakes(0),
+ fNPointTPCFakes(0),
+ fPtSelLargeLabel(0),
+ fMultRec(0),
+ fNPointTPCMultRec(0),
+ fDeltaPtMultRec(0),
+ fPtAllvsPtMC(0),
fPtAllminPtMCvsPtAll(0),
+ fPtAllvsPtMCvsMult(0),
+ fPtAllminPtMCvsPtAllvsMult(0),
fPtAllminPtMCvsPtAllNPointTPC(0),
+ fPtAllminPtMCvsPtAllNPointTPCIter1(0),
+ fPtAllminPtMCvsPtAllChi2TPC(0),
+ fPtAllminPtMCvsPtAllChi2TPCIter1(0),
fPtAllminPtMCvsPtAllDCAR(0),
fPtAllminPtMCvsPtAllDCAZ(0),
fPtAllminPtMCvsPtAllPhi(0),
fPtAllminPtMCvsPtAllRel1PtUncertainty(0),
fPtAllMC(0),
fPtSelMC(0),
- fPtSelMCITS(0),
- fHistList(0),
- fPtSelITS(0),
- fPtITSminPtMCvsPtITS(0),
- fPtITSminPtMCvsPtITSNPointTPC(0),
- fPtITSminPtMCvsPtITSDCAR(0),
- fPtITSminPtMCvsPtITSDCAZ(0),
- fPtITSminPtMCvsPtITSPhi(0),
- fPtITSminPtMCvsPtITSNPointITS(0),
- fPtITSminPtMCvsPtITSNSigmaToVertex(0),
- fPtITSminPtMCvsPtITSChi2C(0),
- fPtITSminPtMCvsPtITSRel1PtUncertainty(0),
- fHistListITS(0)
+ fHistList(0)
{
//
// Constructor. Initialization of Inputs and Outputs
//
AliDebug(2,Form("AliPWG4HighPtQAMC Calling Constructor"));
+
+ fPtBinEdges[0][0] = 10.;
+ fPtBinEdges[0][1] = 1.;
+ fPtBinEdges[1][0] = 20.;
+ fPtBinEdges[1][1] = 2.;
+ fPtBinEdges[2][0] = 100.;
+ fPtBinEdges[2][1] = 10.;
+
// Input slot #0 works with a TChain ESD
DefineInput(0, TChain::Class());
// Output slot #0, #1 write into a TList
DefineOutput(0, TList::Class());
- DefineOutput(1, TList::Class());
+}
+
+//________________________________________________________________________
+void AliPWG4HighPtQAMC::SetPtBinEdges(Int_t region, Double_t ptmax, Double_t ptBinWidth) {
+
+ if(region<3) {
+ fPtBinEdges[region][0] = ptmax;
+ fPtBinEdges[region][1] = ptBinWidth;
+ }
+ else {
+ AliError("Only 3 regions alowed. Use region 0/1/2\n");
+ return;
+ }
+
}
//________________________________________________________________________
OpenFile(0);
fHistList = new TList();
fHistList->SetOwner(kTRUE);
- OpenFile(1);
- fHistListITS = new TList();
- fHistListITS->SetOwner(kTRUE);
- Int_t fgkNPhiBins=18;
- Float_t kMinPhi = 0.;
- Float_t kMaxPhi = 2.*TMath::Pi();
-
- Int_t fgkNPtBins=98;
- Float_t fgkPtMin=2.;
- Float_t fgkPtMax=fPtMax;
+ Float_t fgkPtMin = 0.;
+
+ //fPtBinEdges[region][0] = ptmax of region ; fPtBinEdges[region][1] = binWidth of region
+ const Float_t ptmin1 = fgkPtMin;
+ const Float_t ptmax1 = fPtBinEdges[0][0];
+ const Float_t ptmin2 = ptmax1 ;
+ const Float_t ptmax2 = fPtBinEdges[1][0];
+ const Float_t ptmin3 = ptmax2 ;
+ const Float_t ptmax3 = fPtBinEdges[2][0];//fgkPtMax;
+ const Int_t nbin11 = (int)((ptmax1-ptmin1)/fPtBinEdges[0][1]);
+ const Int_t nbin12 = (int)((ptmax2-ptmin2)/fPtBinEdges[1][1])+nbin11;
+ const Int_t nbin13 = (int)((ptmax3-ptmin3)/fPtBinEdges[2][1])+nbin12;
+ Int_t fgkNPtBins=nbin13;
+ //Create array with low edges of each bin
+ Double_t *binsPt=new Double_t[fgkNPtBins+1];
+ for(Int_t i=0; i<=fgkNPtBins; i++) {
+ if(i<=nbin11) binsPt[i]=(Double_t)ptmin1 + (ptmax1-ptmin1)/nbin11*(Double_t)i ;
+ if(i<=nbin12 && i>nbin11) binsPt[i]=(Double_t)ptmin2 + (ptmax2-ptmin2)/(nbin12-nbin11)*((Double_t)i-(Double_t)nbin11) ;
+ if(i<=nbin13 && i>nbin12) binsPt[i]=(Double_t)ptmin3 + (ptmax3-ptmin3)/(nbin13-nbin12)*((Double_t)i-(Double_t)nbin12) ;
+ }
+
+ Int_t fgkNPhiBins = 18*6;
+ Float_t kMinPhi = 0.;
+ Float_t kMaxPhi = 2.*TMath::Pi();
+ Double_t *binsPhi = new Double_t[fgkNPhiBins+1];
+ for(Int_t i=0; i<=fgkNPhiBins; i++) binsPhi[i]=(Double_t)kMinPhi + (kMaxPhi-kMinPhi)/fgkNPhiBins*(Double_t)i ;
+
Int_t fgkResPtBins=80;
+ Float_t kMinResPt = -1.;
+ Float_t kMaxResPt = 1.;
+ Double_t *binsResPt = new Double_t[fgkResPtBins+1];
+ for(Int_t i=0; i<=fgkResPtBins; i++) binsResPt[i]=(Double_t)kMinResPt + (kMaxResPt-kMinResPt)/fgkResPtBins*(Double_t)i ;
+
+ Int_t fgkMultBins=50;
+ Float_t kMinMult = 0.;
+ Float_t kMaxMult = 3000.;
+ Double_t *binsMult = new Double_t[fgkMultBins+1];
+ for(Int_t i=0; i<=fgkMultBins; i++) binsMult[i]=(Double_t)kMinMult + (kMaxMult-kMinMult)/fgkMultBins*(Double_t)i ;
+
+ Int_t fgkNEtaBins=20;
+ Float_t fgkEtaMin = -1.;
+ Float_t fgkEtaMax = 1.;
+ Double_t *binsEta=new Double_t[fgkNEtaBins+1];
+ for(Int_t i=0; i<=fgkNEtaBins; i++) binsEta[i]=(Double_t)fgkEtaMin + (fgkEtaMax-fgkEtaMin)/fgkNEtaBins*(Double_t)i ;
+
+ Int_t fgkNNClustersTPCBins=80;
+ Float_t fgkNClustersTPCMin = 0.5;
+ Float_t fgkNClustersTPCMax = 160.5;
+ Double_t *binsNClustersTPC=new Double_t[fgkNNClustersTPCBins+1];
+ for(Int_t i=0; i<=fgkNNClustersTPCBins; i++) binsNClustersTPC[i]=(Double_t)fgkNClustersTPCMin + (fgkNClustersTPCMax-fgkNClustersTPCMin)/fgkNNClustersTPCBins*(Double_t)i ;
+
+ Int_t fgkNDCA2DBins=80;
+ Float_t fgkDCA2DMin = -0.2;
+ Float_t fgkDCA2DMax = 0.2;
+ if(fTrackType==1 || fTrackType==2 || fTrackType==4) {
+ fgkDCA2DMin = -2.;
+ fgkDCA2DMax = 2.;
+ }
+ Double_t *binsDCA2D=new Double_t[fgkNDCA2DBins+1];
+ for(Int_t i=0; i<=fgkNDCA2DBins; i++) binsDCA2D[i]=(Double_t)fgkDCA2DMin + (fgkDCA2DMax-fgkDCA2DMin)/fgkNDCA2DBins*(Double_t)i ;
+
+ Int_t fgkNDCAZBins=80;
+ Float_t fgkDCAZMin = -2.;
+ Float_t fgkDCAZMax = 2.;
+ if(fTrackType==1 || fTrackType==2 || fTrackType==4) {
+ fgkDCAZMin = -5.;
+ fgkDCAZMax = 5.;
+ }
+ Double_t *binsDCAZ=new Double_t[fgkNDCAZBins+1];
+ for(Int_t i=0; i<=fgkNDCAZBins; i++) binsDCAZ[i]=(Double_t)fgkDCAZMin + (fgkDCAZMax-fgkDCAZMin)/fgkNDCAZBins*(Double_t)i ;
+
+ Int_t fgkNNPointITSBins=9;
+ Float_t fgkNPointITSMin = -0.5;
+ Float_t fgkNPointITSMax = 8.5;
+ Double_t *binsNPointITS=new Double_t[fgkNNPointITSBins+1];
+ for(Int_t i=0; i<=fgkNNPointITSBins; i++) binsNPointITS[i]=(Double_t)fgkNPointITSMin + (fgkNPointITSMax-fgkNPointITSMin)/fgkNNPointITSBins*(Double_t)i ;
+
+ Int_t fgkNNSigmaToVertexBins=20;
+ Float_t fgkNSigmaToVertexMin = 0.;
+ Float_t fgkNSigmaToVertexMax = 8.;
+ Double_t *binsNSigmaToVertex=new Double_t[fgkNNSigmaToVertexBins+1];
+ for(Int_t i=0; i<=fgkNNSigmaToVertexBins; i++) binsNSigmaToVertex[i]=(Double_t)fgkNSigmaToVertexMin + (fgkNSigmaToVertexMax-fgkNSigmaToVertexMin)/fgkNNSigmaToVertexBins*(Double_t)i ;
+
+ Int_t fgkNChi2CBins=20;
+ Float_t fgkChi2CMin = 0.;
+ Float_t fgkChi2CMax = 100.;
+ Double_t *binsChi2C=new Double_t[fgkNChi2CBins+1];
+ for(Int_t i=0; i<=fgkNChi2CBins; i++) binsChi2C[i]=(Double_t)fgkChi2CMin + (fgkChi2CMax-fgkChi2CMin)/fgkNChi2CBins*(Double_t)i ;
+
+ Int_t fgkNRel1PtUncertaintyBins=50;
+ Float_t fgkRel1PtUncertaintyMin = 0.;
+ Float_t fgkRel1PtUncertaintyMax = 1.;
+ Double_t *binsRel1PtUncertainty=new Double_t[fgkNRel1PtUncertaintyBins+1];
+ for(Int_t i=0; i<=fgkNRel1PtUncertaintyBins; i++) binsRel1PtUncertainty[i]=(Double_t)fgkRel1PtUncertaintyMin + (fgkRel1PtUncertaintyMax-fgkRel1PtUncertaintyMin)/fgkNRel1PtUncertaintyBins*(Double_t)i ;
+
+ Float_t fgkChi2PerClusMin = 0.;
+ Float_t fgkChi2PerClusMax = 4.;
+ Int_t fgkNChi2PerClusBins = (int)(fgkChi2PerClusMax*10.);
+ Double_t *binsChi2PerClus=new Double_t[fgkNChi2PerClusBins+1];
+ for(Int_t i=0; i<=fgkNChi2PerClusBins; i++) binsChi2PerClus[i]=(Double_t)fgkChi2PerClusMin + (fgkChi2PerClusMax-fgkChi2PerClusMin)/fgkNChi2PerClusBins*(Double_t)i ;
+
fNEventAll = new TH1F("fNEventAll","NEventAll",1,-0.5,0.5);
fHistList->Add(fNEventAll);
fNEventSel = new TH1F("fNEventSel","NEvent Selected for analysis",1,-0.5,0.5);
fHistList->Add(fNEventSel);
fNEventReject = new TH1F("fNEventReject","Reason events are rejectected for analysis",20,0,20);
+ //Set labels
+ fNEventReject->Fill("noESD",0);
+ fNEventReject->Fill("Trigger",0);
+ fNEventReject->Fill("noMCEvent",0);
+ fNEventReject->Fill("noStack",0);
+ fNEventReject->Fill("NTracks<2",0);
+ fNEventReject->Fill("noVTX",0);
+ fNEventReject->Fill("VtxStatus",0);
+ fNEventReject->Fill("NCont<2",0);
+ fNEventReject->Fill("ZVTX>10",0);
fHistList->Add(fNEventReject);
fh1Xsec = new TProfile("fh1Xsec","xsec from pyxsec.root",1,0,1);
fh1PtHardTrials = new TH1F("fh1PtHardTrials","PYTHIA Pt hard weight with trials;p_{T,hard}",350,-.5,349.5);
fHistList->Add(fh1PtHardTrials);
- fPtAll = new TH1F("fPtAll","PtAll",fgkNPtBins, fgkPtMin, fgkPtMax);
+ fPtAll = new TH1F("fPtAll","PtAll",fgkNPtBins, binsPt);
fHistList->Add(fPtAll);
- fPtSel = new TH1F("fPtSel","PtSel",fgkNPtBins, fgkPtMin, fgkPtMax);
+ fPtSel = new TH1F("fPtSel","PtSel",fgkNPtBins, binsPt);
fHistList->Add(fPtSel);
-
- fPtAllminPtMCvsPtAll = new TH2F("fPtAllminPtMCvsPtAll","PtAllminPtMCvsPtAll",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
+
+ fPtSelFakes = new TH1F("fPtSelFakes","PtSelFakes",fgkNPtBins, binsPt);
+ fHistList->Add(fPtSelFakes);
+
+ fNPointTPCFakes = new TH1F("fNPointTPCFakes","fNPointTPCFakes",fgkNNClustersTPCBins, binsNClustersTPC);
+ fHistList->Add(fNPointTPCFakes);
+
+ fPtSelLargeLabel = new TH1F("fPtSelLargeLabel","PtSelLargeLabel",fgkNPtBins, binsPt);
+ fHistList->Add(fPtSelLargeLabel);
+
+ fMultRec = new TH1F("fMultRec","Multiple reconstruction of tracks",fgkMultBins, binsMult);
+ fHistList->Add(fMultRec);
+
+ fNPointTPCMultRec = new TH1F("fNPointTPCMultRec","Multiple reconstruction of tracks",fgkNNClustersTPCBins, binsNClustersTPC);
+ fHistList->Add(fNPointTPCMultRec);
+
+ fDeltaPtMultRec = new TH2F("fDeltaPtMultRec","Delta pT vs pT for multiple reconstructed tracks",50,0.,50.,40,-20.,20.);
+ fHistList->Add(fDeltaPtMultRec);
+
+ fPtAllvsPtMC = new TH2F("fPtAllvsPtMC","fPtAllvsPtMC;p_{T,MC};p_{T,rec}",fgkNPtBins, binsPt,fgkNPtBins, binsPt);
+ fHistList->Add(fPtAllvsPtMC);
+
+ fPtAllminPtMCvsPtAll = new TH2F("fPtAllminPtMCvsPtAll","PtAllminPtMCvsPtAll",fgkNPtBins, binsPt,fgkResPtBins,binsResPt);
fPtAllminPtMCvsPtAll->SetXTitle("p_{t}^{MC}");
fPtAllminPtMCvsPtAll->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
fHistList->Add(fPtAllminPtMCvsPtAll);
+
+ fPtAllvsPtMCvsMult = new TH3F("fPtAllvsPtMCvsMult","fPtAllvsPtMCvsMult;p_{T,MC};p_{T,rec};N_{tracks}",fgkNPtBins, binsPt,fgkNPtBins, binsPt,fgkMultBins,binsMult);
+ fHistList->Add(fPtAllvsPtMCvsMult);
+
+ fPtAllminPtMCvsPtAllvsMult = new TH3F("fPtAllminPtMCvsPtAllvsMult","fPtAllminPtMCvsPtAllvsMult",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkMultBins,binsMult);
+ fPtAllminPtMCvsPtAllvsMult->SetXTitle("p_{t}^{MC}");
+ fPtAllminPtMCvsPtAllvsMult->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
+ fPtAllminPtMCvsPtAllvsMult->SetZTitle("N_{tracks}");
+ fHistList->Add(fPtAllminPtMCvsPtAllvsMult);
- fPtAllminPtMCvsPtAllNPointTPC = new TH3F("fPtAllminPtMCvsPtAllNPointTPC","PtAllminPtMCvsPtAllNPointTPC",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,160,0.5,160.5);
+ fPtAllminPtMCvsPtAllNPointTPC = new TH3F("fPtAllminPtMCvsPtAllNPointTPC","PtAllminPtMCvsPtAllNPointTPC",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNNClustersTPCBins, binsNClustersTPC);
fPtAllminPtMCvsPtAllNPointTPC->SetXTitle("p_{t}^{MC}");
fPtAllminPtMCvsPtAllNPointTPC->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
- fPtAllminPtMCvsPtAllNPointTPC->SetZTitle("N_{point,TPC}");
+ fPtAllminPtMCvsPtAllNPointTPC->SetZTitle("N_{cls,TPC}");
fHistList->Add(fPtAllminPtMCvsPtAllNPointTPC);
- fPtAllminPtMCvsPtAllDCAR = new TH3F("fPtAllminPtMCvsPtAllDCAR","PtAllminPtMCvsPtAllDCAR",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,80,-0.2,0.2);
+ fPtAllminPtMCvsPtAllNPointTPCIter1 = new TH3F("fPtAllminPtMCvsPtAllNPointTPCIter1","PtAllminPtMCvsPtAllNPointTPCIter1",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNNClustersTPCBins, binsNClustersTPC);
+ fPtAllminPtMCvsPtAllNPointTPCIter1->SetXTitle("p_{t}^{MC}");
+ fPtAllminPtMCvsPtAllNPointTPCIter1->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
+ fPtAllminPtMCvsPtAllNPointTPCIter1->SetZTitle("N_{clsIter1,TPC}");
+ fHistList->Add(fPtAllminPtMCvsPtAllNPointTPCIter1);
+
+ fPtAllminPtMCvsPtAllChi2TPC = new TH3F("fPtAllminPtMCvsPtAllChi2TPC","PtAllminPtMCvsPtAllChi2TPC",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNChi2PerClusBins, binsChi2PerClus);
+ fPtAllminPtMCvsPtAllChi2TPC->SetXTitle("p_{t}^{MC}");
+ fPtAllminPtMCvsPtAllChi2TPC->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
+ fPtAllminPtMCvsPtAllChi2TPC->SetZTitle("#chi^{2} TPC");
+ fHistList->Add(fPtAllminPtMCvsPtAllChi2TPC);
+
+ fPtAllminPtMCvsPtAllChi2TPCIter1 = new TH3F("fPtAllminPtMCvsPtAllChi2TPCIter1","PtAllminPtMCvsPtAllChi2TPCIter1",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNChi2PerClusBins, binsChi2PerClus);
+ fPtAllminPtMCvsPtAllChi2TPCIter1->SetXTitle("p_{t}^{MC}");
+ fPtAllminPtMCvsPtAllChi2TPCIter1->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
+ fPtAllminPtMCvsPtAllChi2TPCIter1->SetZTitle("#chi^{2} TPC Iter1");
+ fHistList->Add(fPtAllminPtMCvsPtAllChi2TPCIter1);
+
+ fPtAllminPtMCvsPtAllDCAR = new TH3F("fPtAllminPtMCvsPtAllDCAR","PtAllminPtMCvsPtAllDCAR",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNDCA2DBins,binsDCA2D);
fPtAllminPtMCvsPtAllDCAR->SetXTitle("p_{t}^{MC}");
fPtAllminPtMCvsPtAllDCAR->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
fPtAllminPtMCvsPtAllDCAR->SetZTitle("DCA_{R}");
fHistList->Add(fPtAllminPtMCvsPtAllDCAR);
- fPtAllminPtMCvsPtAllDCAZ = new TH3F("fPtAllminPtMCvsPtAllDCAZ","PtAllminPtMCvsPtAllDCAZ",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,80,-2.,2.);
+ fPtAllminPtMCvsPtAllDCAZ = new TH3F("fPtAllminPtMCvsPtAllDCAZ","PtAllminPtMCvsPtAllDCAZ",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNDCAZBins,binsDCAZ);
fPtAllminPtMCvsPtAllDCAZ->SetXTitle("p_{t}^{MC}");
fPtAllminPtMCvsPtAllDCAZ->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
fPtAllminPtMCvsPtAllDCAZ->SetZTitle("DCA_{Z}");
fHistList->Add(fPtAllminPtMCvsPtAllDCAZ);
- fPtAllminPtMCvsPtAllPhi = new TH3F("fPtAllminPtMCvsPtAllPhi","PtAllminPtMCvsPtAllPhi",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkNPhiBins,kMinPhi,kMaxPhi);
+ fPtAllminPtMCvsPtAllPhi = new TH3F("fPtAllminPtMCvsPtAllPhi","PtAllminPtMCvsPtAllPhi",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNPhiBins,binsPhi);
fPtAllminPtMCvsPtAllPhi->SetXTitle("p_{t}^{MC}");
fPtAllminPtMCvsPtAllPhi->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
fPtAllminPtMCvsPtAllPhi->SetZTitle("#phi");
fHistList->Add(fPtAllminPtMCvsPtAllPhi);
- fPtAllminPtMCvsPtAllNPointITS = new TH3F("fPtAllminPtMCvsPtAllNPointITS","PtAllminPtMCvsPtAllNPointITS",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,9,-0.5,8.5);
+ fPtAllminPtMCvsPtAllNPointITS = new TH3F("fPtAllminPtMCvsPtAllNPointITS","PtAllminPtMCvsPtAllNPointITS",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNNPointITSBins,binsNPointITS);
fPtAllminPtMCvsPtAllNPointITS->SetXTitle("p_{t}^{MC}");
fPtAllminPtMCvsPtAllNPointITS->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
fPtAllminPtMCvsPtAllNPointITS->SetZTitle("N_{point,ITS}}");
fHistList->Add(fPtAllminPtMCvsPtAllNPointITS);
- fPtAllminPtMCvsPtAllNSigmaToVertex = new TH3F("fPtAllminPtMCvsPtAllNSigmaToVertex","PtAllminPtMCvsPtAllNSigmaToVertex",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,40,0.,8.);
+ fPtAllminPtMCvsPtAllNSigmaToVertex = new TH3F("fPtAllminPtMCvsPtAllNSigmaToVertex","PtAllminPtMCvsPtAllNSigmaToVertex",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNNSigmaToVertexBins,binsNSigmaToVertex);
fPtAllminPtMCvsPtAllNSigmaToVertex->SetXTitle("p_{t}^{MC}");
fPtAllminPtMCvsPtAllNSigmaToVertex->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
fPtAllminPtMCvsPtAllNSigmaToVertex->SetZTitle("N#sigma to vertex");
fHistList->Add(fPtAllminPtMCvsPtAllNSigmaToVertex);
- fPtAllminPtMCvsPtAllChi2C = new TH3F("fPtAllminPtMCvsPtAllChi2C","PtAllminPtMCvsPtAllChi2C",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,20,0.,10.);
+ fPtAllminPtMCvsPtAllChi2C = new TH3F("fPtAllminPtMCvsPtAllChi2C","PtAllminPtMCvsPtAllChi2C",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNChi2CBins,binsChi2C);
fPtAllminPtMCvsPtAllChi2C->SetXTitle("p_{t}^{MC}");
fPtAllminPtMCvsPtAllChi2C->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
fPtAllminPtMCvsPtAllChi2C->SetZTitle("Constrained #chi^{2}");
fHistList->Add(fPtAllminPtMCvsPtAllChi2C);
- fPtAllminPtMCvsPtAllRel1PtUncertainty = new TH3F("fPtAllminPtMCvsPtAllRel1PtUncertainty","PtAllminPtMCvsPtAllRel1PtUncertainty",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,30,0.,0.3);
+ fPtAllminPtMCvsPtAllRel1PtUncertainty = new TH3F("fPtAllminPtMCvsPtAllRel1PtUncertainty","PtAllminPtMCvsPtAllRel1PtUncertainty",fgkNPtBins, binsPt,fgkResPtBins,binsResPt,fgkNRel1PtUncertaintyBins,binsRel1PtUncertainty);
fPtAllminPtMCvsPtAllRel1PtUncertainty->SetXTitle("p_{t}^{MC}");
fPtAllminPtMCvsPtAllRel1PtUncertainty->SetYTitle("(1/p_{t}^{All}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
fPtAllminPtMCvsPtAllRel1PtUncertainty->SetZTitle("Rel1PtUncertainty");
fHistList->Add(fPtAllminPtMCvsPtAllRel1PtUncertainty);
- //ITSrefit
- fPtSelITS = new TH1F("fPtSelITSrefit","PtSel",fgkNPtBins, fgkPtMin, fgkPtMax);
- fHistListITS->Add(fPtSelITS);
-
- fPtITSminPtMCvsPtITS = new TH2F("fPtITSminPtMCvsPtITS","PtITSminPtMCvsPtITS",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.);
- fPtITSminPtMCvsPtITS->SetXTitle("p_{t}^{MC}");
- fPtITSminPtMCvsPtITS->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
- fHistListITS->Add(fPtITSminPtMCvsPtITS);
-
- fPtITSminPtMCvsPtITSNPointTPC = new TH3F("fPtITSminPtMCvsPtITSNPointTPC","PtITSminPtMCvsPtITSNPointTPC",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,160,0.5,160.5);
- fPtITSminPtMCvsPtITSNPointTPC->SetXTitle("p_{t}^{MC}");
- fPtITSminPtMCvsPtITSNPointTPC->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
- fPtITSminPtMCvsPtITSNPointTPC->SetZTitle("N_{point,TPC}");
- fHistListITS->Add(fPtITSminPtMCvsPtITSNPointTPC);
-
- fPtITSminPtMCvsPtITSDCAR = new TH3F("fPtITSminPtMCvsPtITSDCAR","PtITSminPtMCvsPtITSDCAR",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,80,-0.2,0.2);
- fPtITSminPtMCvsPtITSDCAR->SetXTitle("p_{t}^{MC}");
- fPtITSminPtMCvsPtITSDCAR->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
- fPtITSminPtMCvsPtITSDCAR->SetZTitle("DCA_{R}");
- fHistListITS->Add(fPtITSminPtMCvsPtITSDCAR);
-
- fPtITSminPtMCvsPtITSDCAZ = new TH3F("fPtITSminPtMCvsPtITSDCAZ","PtITSminPtMCvsPtITSDCAZ",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,80,-2.,2.);
- fPtITSminPtMCvsPtITSDCAZ->SetXTitle("p_{t}^{MC}");
- fPtITSminPtMCvsPtITSDCAZ->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
- fPtITSminPtMCvsPtITSDCAZ->SetZTitle("DCA_{Z}");
- fHistListITS->Add(fPtITSminPtMCvsPtITSDCAZ);
-
- fPtITSminPtMCvsPtITSPhi = new TH3F("fPtITSminPtMCvsPtITSPhi","PtITSminPtMCvsPtITSPhi",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,fgkNPhiBins,kMinPhi,kMaxPhi);
- fPtITSminPtMCvsPtITSPhi->SetXTitle("p_{t}^{MC}");
- fPtITSminPtMCvsPtITSPhi->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
- fPtITSminPtMCvsPtITSPhi->SetZTitle("#phi");
- fHistListITS->Add(fPtITSminPtMCvsPtITSPhi);
-
- fPtITSminPtMCvsPtITSNPointITS = new TH3F("fPtITSminPtMCvsPtITSNPointITS","PtITSminPtMCvsPtITSNPointITS",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,9,-0.5,8.5);
- fPtITSminPtMCvsPtITSNPointITS->SetXTitle("p_{t}^{MC}");
- fPtITSminPtMCvsPtITSNPointITS->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{MC})/(1/p_{t}^{MC})}");
- fPtITSminPtMCvsPtITSNPointITS->SetZTitle("N_{point,ITS}}");
- fHistListITS->Add(fPtITSminPtMCvsPtITSNPointITS);
-
- fPtITSminPtMCvsPtITSNSigmaToVertex = new TH3F("fPtITSminPtMCvsPtITSNSigmaToVertex","PtITSminPtMCvsPtITSNSigmaToVertex",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,40,0.,8.);
- fPtITSminPtMCvsPtITSNSigmaToVertex->SetXTitle("p_{t}^{MC}");
- fPtITSminPtMCvsPtITSNSigmaToVertex->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
- fPtITSminPtMCvsPtITSNSigmaToVertex->SetZTitle("N#sigma to vertex");
- fHistListITS->Add(fPtITSminPtMCvsPtITSNSigmaToVertex);
-
- fPtITSminPtMCvsPtITSChi2C = new TH3F("fPtITSminPtMCvsPtITSChi2C","PtITSminPtMCvsPtITSChi2C",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,20,0.,10.);
- fPtITSminPtMCvsPtITSChi2C->SetXTitle("p_{t}^{MC}");
- fPtITSminPtMCvsPtITSChi2C->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
- fPtITSminPtMCvsPtITSChi2C->SetZTitle("Constrained #chi^{2}");
- fHistListITS->Add(fPtITSminPtMCvsPtITSChi2C);
-
- fPtITSminPtMCvsPtITSRel1PtUncertainty = new TH3F("fPtITSminPtMCvsPtITSRel1PtUncertainty","PtITSminPtMCvsPtITSRel1PtUncertainty",fgkNPtBins, fgkPtMin,fgkPtMax,fgkResPtBins,-1.,1.,30,0.,0.3);
- fPtITSminPtMCvsPtITSRel1PtUncertainty->SetXTitle("p_{t}^{MC}");
- fPtITSminPtMCvsPtITSRel1PtUncertainty->SetYTitle("(1/p_{t}^{ITS}-1/p_{t}^{MC})/(1/p_{t}^{MC})");
- fPtITSminPtMCvsPtITSRel1PtUncertainty->SetZTitle("Rel1PtUncertainty");
- fHistListITS->Add(fPtITSminPtMCvsPtITSRel1PtUncertainty);
-
- fPtAllMC = new TH1F("fPtAllMC","PtAll",fgkNPtBins, fgkPtMin, fgkPtMax);
+
+ fPtAllMC = new TH1F("fPtAllMC","PtAll",fgkNPtBins, binsPt);
fHistList->Add(fPtAllMC);
- fPtSelMC = new TH1F("fPtSelMC","PtSel",fgkNPtBins, fgkPtMin, fgkPtMax);
+ fPtSelMC = new TH1F("fPtSelMC","PtSel",fgkNPtBins, binsPt);
fHistList->Add(fPtSelMC);
- fPtSelMCITS = new TH1F("fPtSelMCITS","PtSel",fgkNPtBins, fgkPtMin, fgkPtMax);
- fHistList->Add(fPtSelMCITS);
-
+
TH1::AddDirectory(oldStatus);
+ PostData(0, fHistList);
+
+ if(binsPt) delete [] binsPt;
+ if(binsResPt) delete [] binsResPt;
+ if(binsPhi) delete [] binsPhi;
+ if(binsNClustersTPC) delete [] binsNClustersTPC;
+ if(binsDCA2D) delete [] binsDCA2D;
+ if(binsDCAZ) delete [] binsDCAZ;
+ if(binsNPointITS) delete [] binsNPointITS;
+ if(binsNSigmaToVertex) delete [] binsNSigmaToVertex;
+ if(binsChi2C) delete [] binsChi2C;
+ if(binsEta) delete [] binsEta;
+ if(binsRel1PtUncertainty) delete [] binsRel1PtUncertainty;
+ if(binsChi2PerClus) delete [] binsChi2PerClus;
+ if(binsMult) delete [] binsMult;
+
}
//________________________________________________________________________
if(fMC) {
AliDebug(2,Form("MC particles: %d", fMC->GetNumberOfTracks()));
fStack = fMC->Stack(); //Particles Stack
- AliDebug(2,Form("MC particles stack: %d", fStack->GetNtrack()));
+ if(fStack) {
+ AliDebug(2,Form("MC particles stack: %d", fStack->GetNtrack()));
+ }
+ else {
+ AliDebug(2,Form("ERROR: Could not retrieve MC eventHandler"));
+ fNEventReject->Fill("noStack",1);
+ selectEvent = kFALSE;
+ return selectEvent;
+ }
} else {
- AliDebug(2,Form("ERROR: Could not retrieve MC eventHandler"));
+ AliDebug(2,Form("ERROR: Could not retrieve stack"));
fNEventReject->Fill("noMCEvent",1);
selectEvent = kFALSE;
return selectEvent;
}
//Check if vertex is reconstructed
- const AliESDVertex *vtx = fESD->GetPrimaryVertex();
+ if(fTrackType==1) fVtx = fESD->GetPrimaryVertexTPC();
+ else fVtx = fESD->GetPrimaryVertexSPD();
+
+ if(!fVtx) {
+ fNEventReject->Fill("noVTX",1);
+ selectEvent = kFALSE;
+ return selectEvent;
+ }
+
+ if(!fVtx->GetStatus()) {
+ fNEventReject->Fill("VtxStatus",1);
+ selectEvent = kFALSE;
+ return selectEvent;
+ }
+
// Need vertex cut
- TString vtxName(vtx->GetName());
- if(vtx->GetNContributors() < 2 || (vtxName.Contains("TPCVertex")) ) {
- // SPD vertex
- vtx = fESD->GetPrimaryVertexSPD();
- if(vtx->GetNContributors()<2) {
- vtx = 0x0;
- fNEventReject->Fill("noVTX",1);
- selectEvent = kFALSE;
- return selectEvent;
- }
+ // TString vtxName(fVtx->GetName());
+ if(fVtx->GetNContributors()<2) {
+ fNEventReject->Fill("NCont<2",1);
+ selectEvent = kFALSE;
+ return selectEvent;
}
-
+
//Check if z-vertex < 10 cm
double primVtx[3];
- vtx->GetXYZ(primVtx);
+ fVtx->GetXYZ(primVtx);
if(TMath::Sqrt(primVtx[0]*primVtx[0] + primVtx[1]*primVtx[1])>1. || TMath::Abs(primVtx[2]>10.)){
fNEventReject->Fill("ZVTX>10",1);
selectEvent = kFALSE;
return selectEvent;
}
-
- AliDebug(2,Form("Vertex title %s, status %d, nCont %d\n",vtx->GetTitle(), vtx->GetStatus(), vtx->GetNContributors()));
+
+ AliDebug(2,Form("Vertex title %s, status %d, nCont %d\n",fVtx->GetTitle(), fVtx->GetStatus(), fVtx->GetNContributors()));
return selectEvent;
if(!SelectEvent()) {
// Post output data
- fNEventReject->Fill("NTracks<2",1);
PostData(0, fHistList);
- PostData(1, fHistListITS);
return;
}
Float_t nSigmaToVertex = 0.;
Float_t relUncertainty1Pt = 0.;
+ int mult = fTrackCuts->CountAcceptedTracks(fESD);
+
for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
- AliESDtrack *track;
+ AliESDtrack *track = 0;
AliESDtrack *esdtrack = fESD->GetTrack(iTrack);
if(!esdtrack) continue;
- AliExternalTrackParam *trackTPC = (AliExternalTrackParam *)esdtrack->GetTPCInnerParam();
- if(fTrackType==1)
+ if(fTrackType==1) {
+ track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
+ if(!track) continue;
+ }
+ else if(fTrackType==2) {
track = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack->GetID());
+ if(!track) continue;
+
+ AliExternalTrackParam exParam;
+ Bool_t relate = track->RelateToVertexTPC(fVtx,fESD->GetMagneticField(),kVeryBig,&exParam);
+ if( !relate ) {
+ delete track;
+ continue;
+ }
+ track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance());
+ }
+ else if(fTrackType==7) {
+ //use global constrained track
+ track = new AliESDtrack(*esdtrack);
+ // track = esdtrack;
+ // track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
+ }
else
track = esdtrack;
-
if(!track) continue;
+
+ if(fTrackType==2) {
+ //Cut on chi2 of constrained fit
+ if(track->GetConstrainedChi2TPC() > fSigmaConstrainedMax*fSigmaConstrainedMax) {
+ delete track;
+ continue;
+ }
+ }
Int_t label = TMath::Abs(track->GetLabel());
- if(label>=nMCtracks)continue;
+ if(label>=nMCtracks) {
+ if (fTrackCuts->AcceptTrack(track)) { fPtSelLargeLabel->Fill(pt); }
+ if(fTrackType==1 || fTrackType==2 || fTrackType==7) delete track;
+ continue;
+ }
+
TParticle *particle = fStack->Particle(label) ;
- if(!particle) continue;
+ if(!particle) {
+ if(fTrackType==1 || fTrackType==2 || fTrackType==7) {
+ if(track) delete track;
+ }
+ continue;
+ }
ptMC = particle->Pt();
- if(fTrackType==0) { //Global
- pt = track->Pt();
- phi = track->Phi();
- track->GetImpactParameters(dca2D,dcaZ);
- }
- else if(fTrackType==1) { //TPConly
- pt = trackTPC->Pt();
- phi = trackTPC->Phi();
- track->GetImpactParametersTPC(dca2D,dcaZ);
- }
- else {continue;}
-
+ if(fTrackType==1 || fTrackType==2)
+ track->GetImpactParametersTPC(dca2D,dcaZ); //TPConly
+ else
+ track->GetImpactParameters(dca2D,dcaZ); //Global
UChar_t itsMap = track->GetITSClusterMap();
for (Int_t i=0; i < 6; i++) {
if (itsMap & (1 << i))
nPointITS ++;
}
- nSigmaToVertex = fTrackCuts->GetSigmaToVertex(track);// Calculates the number of sigma to the vertex for a track.
- chi2C = track->GetConstrainedChi2();
- relUncertainty1Pt = TMath::Sqrt(track->GetSigma1Pt2())*pt;
- fPtAll->Fill(pt);
+ // fPtAll->Fill(pt);
fPtAllMC->Fill(ptMC);
if (fTrackCuts->AcceptTrack(track)) {
+ if(fTrackType==7) {
+ if(fTrackCutsReject ) {
+ if(fTrackCutsReject->AcceptTrack(track) ) {
+ if(track) delete track;
+ continue;
+ }
+ }
+
+ if(esdtrack->GetConstrainedParam())
+ track->Set(esdtrack->GetConstrainedParam()->GetX(),esdtrack->GetConstrainedParam()->GetAlpha(),esdtrack->GetConstrainedParam()->GetParameter(),esdtrack->GetConstrainedParam()->GetCovariance());
+ }
+
+ pt = track->Pt();
+ phi = track->Phi();
+
+ nSigmaToVertex = fTrackCuts->GetSigmaToVertex(track);// Calculates the number of sigma to the vertex for a track.
+ chi2C = track->GetConstrainedChi2();
+ relUncertainty1Pt = TMath::Sqrt(track->GetSigma1Pt2())*pt;
+
fPtSel->Fill(pt);
-
+ if(track->GetLabel()<0) {
+ fPtSelFakes->Fill(pt);
+ fNPointTPCFakes->Fill(track->GetTPCNcls());
+ }
fPtSelMC->Fill(ptMC);
+ fPtAllvsPtMC->Fill(ptMC,pt);
fPtAllminPtMCvsPtAll->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC) );
fPtAllminPtMCvsPtAllNPointTPC->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),track->GetTPCNcls());
+ fPtAllminPtMCvsPtAllNPointTPCIter1->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),track->GetTPCNclsIter1());
+ if(track->GetTPCNcls()>0.)
+ fPtAllminPtMCvsPtAllChi2TPC->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),track->GetTPCchi2()/track->GetTPCNcls());
+ if(track->GetTPCNclsIter1()>0.)
+ fPtAllminPtMCvsPtAllChi2TPCIter1->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),track->GetTPCchi2Iter1()/track->GetTPCNclsIter1());
fPtAllminPtMCvsPtAllDCAR->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),dca2D);
fPtAllminPtMCvsPtAllDCAZ->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),dcaZ);
fPtAllminPtMCvsPtAllPhi->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),phi);
fPtAllminPtMCvsPtAllNSigmaToVertex->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),nSigmaToVertex);
fPtAllminPtMCvsPtAllChi2C->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),chi2C);
fPtAllminPtMCvsPtAllRel1PtUncertainty->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),relUncertainty1Pt);
- }//fTrackCuts selection
-
-
-
- //ITSrefit selection
- if (fTrackCutsITS->AcceptTrack(track) && fTrackType==0) {
+
+ fPtAllvsPtMCvsMult->Fill(ptMC,pt,mult);
+ fPtAllminPtMCvsPtAllvsMult->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC), mult);
+
+ //Check if track is reconstructed multiple times
+ /*
+ int multCounter = 1;
+ for (Int_t iTrack2 = iTrack+1; iTrack2 < nTracks; iTrack2++) {
+ // AliESDtrack *track2 = GetTrackForAnalysis(iTrack2);
+ AliESDtrack *track2;
+ AliESDtrack *esdtrack2 = fESD->GetTrack(iTrack2);
+ if(!esdtrack2) continue;
- fPtSelITS->Fill(pt);
- fPtSelMCITS->Fill(ptMC);
- fPtITSminPtMCvsPtITS->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC) );
- fPtITSminPtMCvsPtITSNPointTPC->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),track->GetTPCNcls());
- fPtITSminPtMCvsPtITSDCAR->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),dca2D);
- fPtITSminPtMCvsPtITSDCAZ->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),dcaZ);
- fPtITSminPtMCvsPtITSPhi->Fill(ptMC,(pt-ptMC)/(pt),phi);
- fPtITSminPtMCvsPtITSNPointITS->Fill(ptMC,(pt-ptMC)/(pt),nPointITS);
- fPtITSminPtMCvsPtITSNSigmaToVertex->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),nSigmaToVertex);
- fPtITSminPtMCvsPtITSChi2C->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),chi2C);
- fPtITSminPtMCvsPtITSRel1PtUncertainty->Fill(ptMC,(1./pt-1./ptMC)/(1./ptMC),relUncertainty1Pt);
- }//fTrackCutsITS loop
-
+ if(fTrackType==1)
+ track2 = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack2->GetID());
+ else if(fTrackType==2) {
+ track2 = AliESDtrackCuts::GetTPCOnlyTrack(fESD,esdtrack2->GetID());
+ if(!track2) {
+ continue;
+ }
+ AliExternalTrackParam exParam2;
+ Bool_t relate = track2->RelateToVertexTPC(fVtx,fESD->GetMagneticField(),kVeryBig,&exParam2);
+ if( !relate ) {
+ delete track2;
+ continue;
+ }
+ track2->Set(exParam2.GetX(),exParam2.GetAlpha(),exParam2.GetParameter(),exParam2.GetCovariance());
+ }
+ else
+ track2 = esdtrack2;
+ if(!track2) {
+ continue;
+ }
+
+ if (fTrackCuts->AcceptTrack(track2)) {
+ Int_t label2 = TMath::Abs(track2->GetLabel());
+ if(label==label2) {
+ fNPointTPCMultRec->Fill(track->GetTPCNcls());
+ fNPointTPCMultRec->Fill(track2->GetTPCNcls());
+ fDeltaPtMultRec->Fill(track->Pt(),track->Pt()-track2->Pt());
+ multCounter++;
+ }
+ }
+ if(fTrackType==1 || fTrackType==2) delete track2;
+ }//track2 loop
+ if(multCounter>1) fMultRec->Fill(multCounter);
+ */
+
+ }//fTrackCuts selection
+
+
+ if(fTrackType==1 || fTrackType==2 || fTrackType==7) {
+ if(track) delete track;
+ }
+
}//ESD track loop
// Post output data
PostData(0, fHistList);
- PostData(1, fHistListITS);
-
+
}
//________________________________________________________________________
Bool_t AliPWG4HighPtQAMC::PythiaInfoFromFile(const char* currFile,Float_t &fXsec,Float_t &fTrials){
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff