From 7cc34f080feee8388847dae2f2016d14841d46f5 Mon Sep 17 00:00:00 2001 From: jotwinow Date: Sat, 7 Nov 2009 01:25:59 +0000 Subject: [PATCH] move all TPC related classes --- PWG1/TPC/AliComparisonDCA.cxx | 601 +++++++++++ PWG1/TPC/AliComparisonDCA.h | 105 ++ PWG1/TPC/AliComparisonDEdx.cxx | 362 +++++++ PWG1/TPC/AliComparisonDEdx.h | 90 ++ PWG1/TPC/AliComparisonDraw.cxx | 678 ++++++++++++ PWG1/TPC/AliComparisonDraw.h | 119 +++ PWG1/TPC/AliComparisonEff.cxx | 561 ++++++++++ PWG1/TPC/AliComparisonEff.h | 85 ++ PWG1/TPC/AliComparisonObject.cxx | 55 + PWG1/TPC/AliComparisonObject.h | 59 ++ PWG1/TPC/AliComparisonRes.cxx | 574 ++++++++++ PWG1/TPC/AliComparisonRes.h | 99 ++ PWG1/TPC/AliComparisonTask.cxx | 213 ++++ PWG1/TPC/AliComparisonTask.h | 48 + PWG1/TPC/AliESDRecInfo.cxx | 530 ++++++++++ PWG1/TPC/AliESDRecInfo.h | 100 ++ PWG1/TPC/AliESDRecKinkInfo.cxx | 216 ++++ PWG1/TPC/AliESDRecKinkInfo.h | 53 + PWG1/TPC/AliESDRecV0Info.cxx | 392 +++++++ PWG1/TPC/AliESDRecV0Info.h | 83 ++ PWG1/TPC/AliESDresolMakerFast.cxx | 223 ++++ PWG1/TPC/AliESDresolMakerFast.h | 33 + PWG1/TPC/AliESDresolParams.cxx | 174 ++++ PWG1/TPC/AliESDresolParams.h | 52 + PWG1/TPC/AliGenInfoMaker.cxx | 813 +++++++++++++++ PWG1/TPC/AliGenInfoMaker.h | 116 +++ PWG1/TPC/AliGenInfoTask.cxx | 541 ++++++++++ PWG1/TPC/AliGenInfoTask.h | 84 ++ PWG1/TPC/AliGenKinkInfo.cxx | 216 ++++ PWG1/TPC/AliGenKinkInfo.h | 62 ++ PWG1/TPC/AliGenV0Info.cxx | 262 +++++ PWG1/TPC/AliGenV0Info.h | 71 ++ PWG1/TPC/AliMCInfo.cxx | 510 +++++++++ PWG1/TPC/AliMCInfo.h | 148 +++ PWG1/TPC/AliMCInfoCuts.cxx | 162 +++ PWG1/TPC/AliMCInfoCuts.h | 97 ++ PWG1/TPC/AliMCTrackingTestTask.cxx | 591 +++++++++++ PWG1/TPC/AliMCTrackingTestTask.h | 73 ++ PWG1/TPC/AliMaterialBudget.cxx | 1052 +++++++++++++++++++ PWG1/TPC/AliMaterialBudget.h | 94 ++ PWG1/TPC/AliPerformanceDCA.cxx | 610 +++++++++++ PWG1/TPC/AliPerformanceDCA.h | 91 ++ PWG1/TPC/AliPerformanceDEdx.cxx | 466 +++++++++ PWG1/TPC/AliPerformanceDEdx.h | 91 ++ PWG1/TPC/AliPerformanceEff.cxx | 1554 ++++++++++++++++++++++++++++ PWG1/TPC/AliPerformanceEff.h | 101 ++ PWG1/TPC/AliPerformanceMC.cxx | 796 ++++++++++++++ PWG1/TPC/AliPerformanceMC.h | 107 ++ PWG1/TPC/AliPerformanceMatch.cxx | 653 ++++++++++++ PWG1/TPC/AliPerformanceMatch.h | 107 ++ PWG1/TPC/AliPerformanceObject.cxx | 146 +++ PWG1/TPC/AliPerformanceObject.h | 72 ++ PWG1/TPC/AliPerformanceRes.cxx | 1009 ++++++++++++++++++ PWG1/TPC/AliPerformanceRes.h | 109 ++ PWG1/TPC/AliPerformanceTPC.cxx | 386 +++++++ PWG1/TPC/AliPerformanceTPC.h | 88 ++ PWG1/TPC/AliPerformanceTask.cxx | 238 +++++ PWG1/TPC/AliPerformanceTask.h | 58 ++ PWG1/TPC/AliRecInfoCuts.cxx | 81 ++ PWG1/TPC/AliRecInfoCuts.h | 57 + PWG1/TPC/AliRecInfoMaker.cxx | 1256 ++++++++++++++++++++++ PWG1/TPC/AliRecInfoMaker.h | 126 +++ PWG1/TPC/AliTPCComparisonPID.cxx | 354 +++++++ PWG1/TPC/AliTPCComparisonPID.h | 72 ++ PWG1/TPC/AliTPCtaskPID.cxx | 410 ++++++++ PWG1/TPC/AliTPCtaskPID.h | 61 ++ PWG1/TPC/AliTPCtaskQA.cxx | 349 +++++++ PWG1/TPC/AliTPCtaskQA.h | 56 + PWG1/TPC/AliTreeDraw.cxx | 659 ++++++++++++ PWG1/TPC/AliTreeDraw.h | 78 ++ 70 files changed, 20638 insertions(+) create mode 100644 PWG1/TPC/AliComparisonDCA.cxx create mode 100644 PWG1/TPC/AliComparisonDCA.h create mode 100644 PWG1/TPC/AliComparisonDEdx.cxx create mode 100644 PWG1/TPC/AliComparisonDEdx.h create mode 100644 PWG1/TPC/AliComparisonDraw.cxx create mode 100644 PWG1/TPC/AliComparisonDraw.h create mode 100644 PWG1/TPC/AliComparisonEff.cxx create mode 100644 PWG1/TPC/AliComparisonEff.h create mode 100644 PWG1/TPC/AliComparisonObject.cxx create mode 100644 PWG1/TPC/AliComparisonObject.h create mode 100644 PWG1/TPC/AliComparisonRes.cxx create mode 100644 PWG1/TPC/AliComparisonRes.h create mode 100644 PWG1/TPC/AliComparisonTask.cxx create mode 100644 PWG1/TPC/AliComparisonTask.h create mode 100644 PWG1/TPC/AliESDRecInfo.cxx create mode 100644 PWG1/TPC/AliESDRecInfo.h create mode 100644 PWG1/TPC/AliESDRecKinkInfo.cxx create mode 100644 PWG1/TPC/AliESDRecKinkInfo.h create mode 100644 PWG1/TPC/AliESDRecV0Info.cxx create mode 100644 PWG1/TPC/AliESDRecV0Info.h create mode 100644 PWG1/TPC/AliESDresolMakerFast.cxx create mode 100644 PWG1/TPC/AliESDresolMakerFast.h create mode 100644 PWG1/TPC/AliESDresolParams.cxx create mode 100644 PWG1/TPC/AliESDresolParams.h create mode 100644 PWG1/TPC/AliGenInfoMaker.cxx create mode 100644 PWG1/TPC/AliGenInfoMaker.h create mode 100644 PWG1/TPC/AliGenInfoTask.cxx create mode 100644 PWG1/TPC/AliGenInfoTask.h create mode 100644 PWG1/TPC/AliGenKinkInfo.cxx create mode 100644 PWG1/TPC/AliGenKinkInfo.h create mode 100644 PWG1/TPC/AliGenV0Info.cxx create mode 100644 PWG1/TPC/AliGenV0Info.h create mode 100644 PWG1/TPC/AliMCInfo.cxx create mode 100644 PWG1/TPC/AliMCInfo.h create mode 100644 PWG1/TPC/AliMCInfoCuts.cxx create mode 100644 PWG1/TPC/AliMCInfoCuts.h create mode 100644 PWG1/TPC/AliMCTrackingTestTask.cxx create mode 100644 PWG1/TPC/AliMCTrackingTestTask.h create mode 100644 PWG1/TPC/AliMaterialBudget.cxx create mode 100644 PWG1/TPC/AliMaterialBudget.h create mode 100644 PWG1/TPC/AliPerformanceDCA.cxx create mode 100644 PWG1/TPC/AliPerformanceDCA.h create mode 100644 PWG1/TPC/AliPerformanceDEdx.cxx create mode 100644 PWG1/TPC/AliPerformanceDEdx.h create mode 100644 PWG1/TPC/AliPerformanceEff.cxx create mode 100644 PWG1/TPC/AliPerformanceEff.h create mode 100644 PWG1/TPC/AliPerformanceMC.cxx create mode 100644 PWG1/TPC/AliPerformanceMC.h create mode 100644 PWG1/TPC/AliPerformanceMatch.cxx create mode 100644 PWG1/TPC/AliPerformanceMatch.h create mode 100644 PWG1/TPC/AliPerformanceObject.cxx create mode 100644 PWG1/TPC/AliPerformanceObject.h create mode 100644 PWG1/TPC/AliPerformanceRes.cxx create mode 100644 PWG1/TPC/AliPerformanceRes.h create mode 100644 PWG1/TPC/AliPerformanceTPC.cxx create mode 100644 PWG1/TPC/AliPerformanceTPC.h create mode 100644 PWG1/TPC/AliPerformanceTask.cxx create mode 100644 PWG1/TPC/AliPerformanceTask.h create mode 100644 PWG1/TPC/AliRecInfoCuts.cxx create mode 100644 PWG1/TPC/AliRecInfoCuts.h create mode 100644 PWG1/TPC/AliRecInfoMaker.cxx create mode 100644 PWG1/TPC/AliRecInfoMaker.h create mode 100644 PWG1/TPC/AliTPCComparisonPID.cxx create mode 100644 PWG1/TPC/AliTPCComparisonPID.h create mode 100644 PWG1/TPC/AliTPCtaskPID.cxx create mode 100644 PWG1/TPC/AliTPCtaskPID.h create mode 100644 PWG1/TPC/AliTPCtaskQA.cxx create mode 100644 PWG1/TPC/AliTPCtaskQA.h create mode 100644 PWG1/TPC/AliTreeDraw.cxx create mode 100644 PWG1/TPC/AliTreeDraw.h diff --git a/PWG1/TPC/AliComparisonDCA.cxx b/PWG1/TPC/AliComparisonDCA.cxx new file mode 100644 index 00000000000..24f3ac61d59 --- /dev/null +++ b/PWG1/TPC/AliComparisonDCA.cxx @@ -0,0 +1,601 @@ +//------------------------------------------------------------------------------ +// Implementation of AliComparisonDCA class. It keeps information from +// comparison of reconstructed and MC particle tracks. In addtion, +// it keeps selection cuts used during comparison. The comparison +// information is stored in the ROOT histograms. Analysis of these +// histograms can be done by using Analyse() class function. The result of +// the analysis (histograms/graphs) are stored in the folder +// which is a data member of AliComparisonDCA. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + TFile f("Output.root"); + //AliComparisonDCA * compObj = (AliComparisonDCA*)f.Get("AliComparisonDCA"); + AliComparisonDCA * compObj = (AliComparisonDCA*)cOutput->FindObject("AliComparisonDCA"); + + // Analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderDCA" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_DCA.root","recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include +#include +#include +#include +#include + +#include "AliComparisonDCA.h" +#include "AliESDEvent.h" +#include "AliESDRecInfo.h" +#include "AliESDVertex.h" +#include "AliLog.h" +#include "AliMCInfo.h" +#include "AliMCInfoCuts.h" +#include "AliMathBase.h" +#include "AliRecInfoCuts.h" +#include "AliTracker.h" + +using namespace std; + +ClassImp(AliComparisonDCA) + +//_____________________________________________________________________________ +AliComparisonDCA::AliComparisonDCA(): + AliComparisonObject("AliComparisonDCA"), + + // DCA histograms + fDCAHisto(0), + /* + fD0TanSPtTPCITS(0), + fD1TanSPtTPCITS(0), + fD0TanSPt(0), + fD1TanSPt(0), + fD0TanSPtTPC(0), + fD1TanSPtTPC(0), + */ + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // default constructor +} + +//_____________________________________________________________________________ +AliComparisonDCA::AliComparisonDCA(Char_t* name="AliComparisonDCA", Char_t* title="AliComparisonDCA",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE): + AliComparisonObject(name,title), + + // DCA histograms + fDCAHisto(0), + /* + fD0TanSPtTPCITS(0), + fD1TanSPtTPCITS(0), + fD0TanSPt(0), + fD1TanSPt(0), + fD0TanSPtTPC(0), + fD1TanSPtTPC(0), + */ + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + Init(); +} + + +//_____________________________________________________________________________ +AliComparisonDCA::~AliComparisonDCA() +{ + // destructor + if(fDCAHisto) delete fDCAHisto; fDCAHisto=0; + /* + if(fD0TanSPtTPCITS) delete fD0TanSPtTPCITS; fD0TanSPtTPCITS=0; + if(fD1TanSPtTPCITS) delete fD1TanSPtTPCITS; fD1TanSPtTPCITS=0; + if(fD0TanSPt) delete fD0TanSPt; fD0TanSPt=0; + if(fD1TanSPt) delete fD1TanSPt; fD1TanSPt=0; + if(fD0TanSPtTPC) delete fD0TanSPtTPC; fD0TanSPtTPC=0; + if(fD1TanSPtTPC) delete fD1TanSPtTPC; fD1TanSPtTPC=0; + */ + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; + +} + +//_____________________________________________________________________________ +void AliComparisonDCA::Init() +{ + // DCA histograms + + Int_t nPBins = 31; + Double_t binsP[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.}; + Double_t pMin = 0., pMax = 10.; + + if(IsHptGenerator() == kTRUE) { + nPBins = 100; + pMin = 0.; pMax = 100.; + } + + //dca_r, dca_z, eta, pt + Int_t binsQA[4] = {100,100,20,nPBins}; + Double_t xminQA[4] = {-10.,-10.,-1., pMin}; + Double_t xmaxQA[4] = {10.,10.,1., pMax}; + + fDCAHisto = new THnSparseF("fDCAHisto","dca_r:dca_z:eta:pt",4,binsQA,xminQA,xmaxQA); + if(!IsHptGenerator()) fDCAHisto->SetBinEdges(3,binsP); + + fDCAHisto->GetAxis(0)->SetTitle("dca_r (cm)"); + fDCAHisto->GetAxis(1)->SetTitle("dca_z (cm)"); + fDCAHisto->GetAxis(2)->SetTitle("eta"); + fDCAHisto->GetAxis(3)->SetTitle("pt (GeV/c)"); + fDCAHisto->Sumw2(); + + /* + fD0TanSPtTPCITS = new TH3F("DCAyTanSPtTPCITS","DCAyTanSPt",40,-2,2, 10,0.3,3, 100,-1,1); + fD0TanSPtTPCITS->SetXTitle("tan(#theta)"); + fD0TanSPtTPCITS->SetYTitle("#sqrt{p_{t}(GeV)}"); + fD0TanSPtTPCITS->SetZTitle("DCA_{xy}"); + + fD1TanSPtTPCITS = new TH3F("DCAzTanSPtTPCITS","DCAzTanSPt",40,-2,2, 10,0.3,3, 100,-1,1); + fD1TanSPtTPCITS->SetXTitle("tan(#theta)"); + fD1TanSPtTPCITS->SetYTitle("#sqrt(p_{t}(GeV))"); + fD1TanSPtTPCITS->SetZTitle("DCA_{z}"); + + fD0TanSPt = new TH3F("DCAyTanSPt","DCAyTanSPt",40,-2,2, 10,0.3,3, 100,-1,1); + fD0TanSPt->SetXTitle("tan(#theta)"); + fD0TanSPt->SetYTitle("#sqrt{p_{t}(GeV)}"); + fD0TanSPt->SetZTitle("DCA_{xy}"); + + fD1TanSPt = new TH3F("DCAzTanSPt","DCAzTanSPt",40,-2,2, 10,0.3,3, 100, -1,1); + fD1TanSPt->SetXTitle("tan(#theta)"); + fD1TanSPt->SetYTitle("#sqrt{p_{t}(GeV)}"); + fD1TanSPt->SetZTitle("DCA_{z}"); + + fD0TanSPtTPC = new TH3F("DCAyTanSPtTPC","DCAyTanSPt",40,-2,2, 10,0.3,3, 100,-1,1); + fD0TanSPtTPC->SetXTitle("tan(#theta)"); + fD0TanSPtTPC->SetYTitle("#sqrt{p_{t}(GeV)}"); + fD0TanSPtTPC->SetZTitle("DCA_{xy}"); + + fD1TanSPtTPC = new TH3F("DCAzTanSPtTPC","DCAzTanSPt",40,-2,2, 10,0.3,3, 100, -1,1); + fD1TanSPtTPC->SetXTitle("tan(#theta)"); + fD1TanSPtTPC->SetYTitle("#sqrt{p_{t}(GeV)}"); + fD1TanSPtTPC->SetZTitle("DCA_{z}"); + */ + + // init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderDCA","Analysis DCA Folder"); +} + +//_____________________________________________________________________________ +void AliComparisonDCA::ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo * const infoRC) +{ + // Fill DCA comparison information + AliExternalTrackParam *track = 0; + //Double_t field = AliTracker::GetBz(); // nominal Bz field [kG] + Double_t kMaxD = 123456.0; // max distance + + Double_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + + Float_t mcpt = infoMC->GetParticle().Pt(); + Float_t mceta = infoMC->GetParticle().Eta(); + //Float_t spt = TMath::Sqrt(mcpt); + + // distance to Prim. vertex + const Double_t* dv = infoMC->GetVDist(); + + Bool_t isPrim = TMath::Sqrt(dv[0]*dv[0] + dv[1]*dv[1])GetMaxR() && TMath::Abs(dv[2])GetMaxVz(); + + // Check selection cuts + if (fCutsMC->IsPdgParticle(TMath::Abs(infoMC->GetParticle().GetPdgCode())) == kFALSE) return; + if (!isPrim) return; + if (infoRC->GetStatus(1)!=3) return; + if (!infoRC->GetESDtrack()) return; + if (infoRC->GetESDtrack()->GetTPCNcls()GetMinNClustersTPC()) return; + //if (!infoRC->GetESDtrack()->GetConstrainedParam()) return; + + // calculate and set prim. vertex + AliESDVertex vertexMC; + vertexMC.SetXv( infoMC->GetParticle().Vx() - dv[0] ); + vertexMC.SetYv( infoMC->GetParticle().Vy() - dv[1] ); + vertexMC.SetZv( infoMC->GetParticle().Vz() - dv[2] ); + + // calculate track parameters at vertex + if (infoRC->GetESDtrack()->GetTPCInnerParam()) + { + if ((track = new AliExternalTrackParam(*infoRC->GetESDtrack()->GetTPCInnerParam())) != 0 ) + { + + //Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov); + Double_t field[3]; track->GetBxByBz(field); + Bool_t bDCAStatus = track->PropagateToDCABxByBz(&vertexMC,field,kMaxD,dca,cov); + + if(bDCAStatus) { + Double_t vDCAHisto[4]={dca[0],dca[1],mceta,mcpt}; + fDCAHisto->Fill(vDCAHisto); + } + delete track; + } + } +} + +//_____________________________________________________________________________ +void AliComparisonDCA::ProcessTPCITS(AliMCInfo* const infoMC, AliESDRecInfo * const infoRC) +{ + // Fill DCA comparison information + Int_t clusterITS[200]; + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + + Float_t mcpt = infoMC->GetParticle().Pt(); + Float_t mceta = infoMC->GetParticle().Eta(); + //Float_t spt = TMath::Sqrt(mcpt); + + // distance to Prim. vertex + const Double_t* dv = infoMC->GetVDist(); + Bool_t isPrim = TMath::Sqrt(dv[0]*dv[0] + dv[1]*dv[1])GetMaxR() && TMath::Abs(dv[2])GetMaxVz(); + + // Check selection cuts + if (fCutsMC->IsPdgParticle(TMath::Abs(infoMC->GetParticle().GetPdgCode())) == kFALSE) return; + if (!isPrim) return; + if (infoRC->GetStatus(1)!=3) return; + if (!infoRC->GetESDtrack()) return; + if (infoRC->GetESDtrack()->GetTPCNcls()GetMinNClustersTPC()) return; + //if (!infoRC->GetESDtrack()->GetConstrainedParam()) return; + + infoRC->GetESDtrack()->GetImpactParameters(dca,cov); + + // ITS + TPC + if(infoRC->GetESDtrack()->GetITSclusters(clusterITS)>fCutsRC->GetMinNClustersITS()) + { + Double_t vDCAHisto[4]={dca[0],dca[1],mceta,mcpt}; + fDCAHisto->Fill(vDCAHisto); + } +} + +void AliComparisonDCA::ProcessConstrained(AliMCInfo* const /*infoMC*/, AliESDRecInfo * const /*infoRC*/) +{ + // Fill DCA comparison information + + AliDebug(AliLog::kWarning, "Warning: Not implemented"); +} + +//_____________________________________________________________________________ +Long64_t AliComparisonDCA::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliComparisonDCA* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fDCAHisto->Add(entry->fDCAHisto); + /* + fD0TanSPtTPCITS->Add(entry->fD0TanSPtTPCITS); + fD1TanSPtTPCITS->Add(entry->fD1TanSPtTPCITS); + fD0TanSPt->Add(entry->fD0TanSPt); + fD1TanSPt->Add(entry->fD1TanSPt); + fD0TanSPtTPC->Add(entry->fD0TanSPtTPC); + fD1TanSPtTPC->Add(entry->fD1TanSPtTPC); + */ + + count++; + } + +return count; +} + +//_____________________________________________________________________________ +void AliComparisonDCA::Exec(AliMCInfo* const infoMC, AliESDRecInfo * const infoRC) +{ + // Process comparison information + if(GetAnalysisMode() == 0) ProcessTPC(infoMC,infoRC); + else if(GetAnalysisMode() == 1) ProcessTPCITS(infoMC,infoRC); + else if(GetAnalysisMode() == 2) ProcessConstrained(infoMC,infoRC); + else { + printf("ERROR: AnalysisMode %d \n",fAnalysisMode); + return; + } +} + +//_____________________________________________________________________________ +void AliComparisonDCA::Analyse() +{ + // + // Analyse comparison information and store output histograms + // in the analysis folder "folderDCA" + // + + TH1::AddDirectory(kFALSE); + TObjArray *aFolderObj = new TObjArray; + + /* + TGraph * gr[8]= { 0,0,0,0,0,0,0,0 }; + TGraph2D *gr2[8]= { 0,0,0,0,0,0,0,0}; + AliComparisonDCA * comp=this; + + // write results in the folder + // Canvas to draw analysed histograms + TCanvas * c = new TCanvas("canDCA","DCA resolution"); + c->Divide(2,4); + // + // DCA resolution + // + c->cd(1); + gr[0] = AliMathBase::MakeStat1D(comp->fD0TanSPtTPC,2,5); + gr[0]->GetXaxis()->SetTitle("Tan(#theta)"); + gr[0]->GetYaxis()->SetTitle("#sigmaDCA_xy (cm)"); + gr[0]->SetName("DCAXYResolTanTPC"); + gr[0]->SetTitle("resol. DCA_xy (TPC only)"); + gr[0]->Draw("Al*"); + + aFolderObj->Add(gr[0]); + + c->cd(2); + gr[1] = AliMathBase::MakeStat1D(comp->fD1TanSPtTPC,2,5); + gr[1]->GetXaxis()->SetTitle("Tan(#theta)"); + gr[1]->GetYaxis()->SetTitle("#sigmaDCA_z (cm)"); + gr[1]->SetName("DCAZResolTanTPC"); + gr[1]->SetTitle("resol. DCA_z (TPC only)"); + gr[1]->Draw("Al*"); + + aFolderObj->Add(gr[1]); + + c->cd(3); + gr[2] = AliMathBase::MakeStat1D(comp->fD0TanSPtTPCITS,2,5); + gr[2]->GetXaxis()->SetTitle("Tan(#theta)"); + gr[2]->GetYaxis()->SetTitle("#sigmaDCA_xy (cm)"); + gr[2]->SetName("DCAXYResolTanTPCITS"); + gr[2]->SetTitle("resol. DCA_xy (TPC+ITS)"); + gr[2]->Draw("Al*"); + + aFolderObj->Add(gr[2]); + + c->cd(4); + gr[3] = AliMathBase::MakeStat1D(comp->fD1TanSPtTPCITS,2,5); + gr[3]->GetXaxis()->SetTitle("Tan(#theta)"); + gr[3]->GetYaxis()->SetTitle("#sigmaDCA_z (cm)"); + gr[3]->SetName("DCAZResolTanTPCITS"); + gr[3]->SetTitle("resol. DCA_z (TPC+ITS)"); + gr[3]->Draw("Al*"); + + aFolderObj->Add(gr[3]); + + // + // DCA mean value + // + c->cd(5); + gr[4] = AliMathBase::MakeStat1D(comp->fD0TanSPtTPC,2,4); + gr[4]->GetXaxis()->SetTitle("Tan(#theta)"); + gr[4]->GetYaxis()->SetTitle("mean DCA_xy (cm)"); + gr[4]->SetName("DCAXYMeanTanTPC"); + gr[4]->SetTitle("mean DCA_xy (TPC only)"); + gr[4]->Draw("Al*"); + + aFolderObj->Add(gr[4]); + + c->cd(6); + gr[5] = AliMathBase::MakeStat1D(comp->fD1TanSPtTPC,2,4); + gr[5]->GetXaxis()->SetTitle("Tan(#theta)"); + gr[5]->GetYaxis()->SetTitle("mean DCA_z (cm)"); + gr[5]->SetName("DCAZMeanTanTPC"); + gr[5]->SetTitle("mean DCA_z (TPC only)"); + gr[5]->Draw("Al*"); + + aFolderObj->Add(gr[5]); + + c->cd(7); + gr[6] = AliMathBase::MakeStat1D(comp->fD0TanSPtTPCITS,2,4); + gr[6]->GetXaxis()->SetTitle("Tan(#theta)"); + gr[6]->GetYaxis()->SetTitle("mean DCA_xy (cm)"); + gr[6]->SetName("DCAXYMeanTanTPCITS"); + gr[6]->SetTitle("mean DCA_xy (TPC+ITS)"); + gr[6]->Draw("Al*"); + + aFolderObj->Add(gr[6]); + + c->cd(8); + gr[7] = AliMathBase::MakeStat1D(comp->fD1TanSPtTPCITS,2,4); + gr[7]->GetXaxis()->SetTitle("Tan(#theta)"); + gr[7]->GetYaxis()->SetTitle("mean DCA_z (cm)"); + gr[7]->SetName("DCAZMeanTanTPCITS"); + gr[7]->SetTitle("mean DCA_z (TPC+ITS)"); + gr[7]->Draw("Al*"); + + aFolderObj->Add(gr[7]); + + // 2D DCA resolution + TCanvas * c1 = new TCanvas("canDCA1","2D DCA resolution"); + c1->Divide(2,4); + + // TPC only + c1->cd(1); + gr2[0] = AliMathBase::MakeStat2D(comp->fD0TanSPtTPC,4,2,5); + gr2[0]->GetXaxis()->SetTitle("Tan(#theta)"); + gr2[0]->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr2[0]->GetZaxis()->SetTitle("#sigmaDCA_xy (cm)"); + gr2[0]->SetName("DCAXYResolSPTTanTPC"); + gr2[0]->SetTitle("#sigma DCA_xy (TPC only)"); + gr2[0]->GetHistogram()->Draw("colz"); + + gr2[0]->GetHistogram()->SetName("DCAXYResolSPTTanTPC"); + aFolderObj->Add(gr2[0]->GetHistogram()); + + c1->cd(2); + gr2[1] = AliMathBase::MakeStat2D(comp->fD1TanSPtTPC,4,2,5); + gr2[1]->GetXaxis()->SetTitle("Tan(#theta)"); + gr2[1]->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr2[1]->GetZaxis()->SetTitle("#sigmaDCA_z (cm)"); + gr2[1]->SetName("DCAZResolSPTTanTPC"); + gr2[1]->SetTitle("#sigma DCA_z (TPC only)"); + gr2[1]->GetHistogram()->Draw("colz"); + + gr2[1]->GetHistogram()->SetName("DCAZResolSPTTanTPC"); + aFolderObj->Add(gr2[1]->GetHistogram()); + + // TPC+ITS + c1->cd(3); + gr2[2] = AliMathBase::MakeStat2D(comp->fD0TanSPtTPCITS,4,2,5); + gr2[2]->GetXaxis()->SetTitle("Tan(#theta)"); + gr2[2]->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr2[2]->GetZaxis()->SetTitle("#sigmaDCA_xy (cm)"); + gr2[2]->SetName("DCAXYResolSPTTanTPCITS"); + gr2[2]->SetTitle("#sigma DCA_xy (TPC+ITS)"); + gr2[2]->GetHistogram()->Draw("colz"); + + gr2[2]->GetHistogram()->SetName("DCAXYResolSPTTanTPCITS"); + aFolderObj->Add(gr2[2]->GetHistogram()); + + c1->cd(4); + gr2[3] = AliMathBase::MakeStat2D(comp->fD1TanSPtTPCITS,4,2,5); + gr2[3]->GetXaxis()->SetTitle("Tan(#theta)"); + gr2[3]->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr2[3]->GetZaxis()->SetTitle("#sigmaDCA_z (cm)"); + gr2[3]->SetName("DCAZResolSPTTanTPCITS"); + gr2[3]->SetTitle("#sigma DCA_z (TPC+ITS)"); + gr2[3]->GetHistogram()->Draw("colz"); + + gr2[3]->GetHistogram()->SetName("DCAZResolSPTTanTPCITS"); + aFolderObj->Add(gr2[3]->GetHistogram()); + + // 2D DCA mean value + c1->cd(5); + gr2[4] = AliMathBase::MakeStat2D(comp->fD0TanSPtTPC,4,2,4); + gr2[4]->GetXaxis()->SetTitle("Tan(#theta)"); + gr2[4]->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr2[4]->GetZaxis()->SetTitle("mean DCA_xy (cm)"); + gr2[4]->SetName("DCAXYMeanSPTTanTPC"); + gr2[4]->SetTitle("mean DCA_xy (TPC only)"); + gr2[4]->GetHistogram()->Draw("colz"); + + gr2[4]->GetHistogram()->SetName("DCAXYMeanSPTTanTPC"); + aFolderObj->Add(gr2[4]->GetHistogram()); + + c1->cd(6); + gr2[5] = AliMathBase::MakeStat2D(comp->fD1TanSPtTPC,4,2,4); + gr2[5]->GetXaxis()->SetTitle("Tan(#theta)"); + gr2[5]->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr2[5]->GetZaxis()->SetTitle("mean DCA_z (cm)"); + gr2[5]->SetName("DCAZMeanSPTTanTPC"); + gr2[5]->SetTitle("mean DCA_z (TPC only)"); + gr2[5]->GetHistogram()->Draw("colz"); + + gr2[5]->GetHistogram()->SetName("DCAZMeanSPTTanTPC"); + aFolderObj->Add(gr2[5]->GetHistogram()); + + c1->cd(7); + gr2[6] = AliMathBase::MakeStat2D(comp->fD0TanSPtTPCITS,4,2,4); + gr2[6]->GetXaxis()->SetTitle("Tan(#theta)"); + gr2[6]->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr2[6]->GetZaxis()->SetTitle("mean DCA_xy (cm)"); + gr2[6]->SetName("DCAXYMeanSPTTanTPCITS"); + gr2[6]->SetTitle("mean DCA_xy (TPC+ITS)"); + gr2[6]->GetHistogram()->Draw("colz"); + + gr2[6]->GetHistogram()->SetName("DCAXYMeanSPTTanTPCITS"); + aFolderObj->Add(gr2[6]->GetHistogram()); + + c1->cd(8); + gr2[7] = AliMathBase::MakeStat2D(comp->fD1TanSPtTPCITS,4,2,4); + gr2[7]->GetXaxis()->SetTitle("Tan(#theta)"); + gr2[7]->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr2[7]->GetZaxis()->SetTitle("mean DCA_z (cm)"); + gr2[7]->SetName("DCAZMeanSPTTanTPCITS"); + gr2[7]->SetTitle("mean DCA_z (TPC+ITS)"); + gr2[7]->GetHistogram()->Draw("colz"); + + gr2[7]->GetHistogram()->SetName("DCAZMeanSPTTanTPCITS"); + aFolderObj->Add(gr2[7]->GetHistogram()); + + */ + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TFolder* AliComparisonDCA::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliComparisonDCA * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + + +//_____________________________________________________________________________ +TFolder* AliComparisonDCA::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} diff --git a/PWG1/TPC/AliComparisonDCA.h b/PWG1/TPC/AliComparisonDCA.h new file mode 100644 index 00000000000..24d655bd43e --- /dev/null +++ b/PWG1/TPC/AliComparisonDCA.h @@ -0,0 +1,105 @@ +#ifndef ALICOMPARISONDCA_H +#define ALICOMPARISONDCA_H + +//------------------------------------------------------------------------------ +// Class to keep information from comparison of +// reconstructed and MC particle tracks (DCA - Distance of Closest Approach +// to the vertex). +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliRecInfoCuts; +class AliMCInfoCuts; +class AliESDVertex; +class TH3F; +class TH3; +class TString; +class TNamed; + +#include "THnSparse.h" +#include "AliComparisonObject.h" + +class AliComparisonDCA : public AliComparisonObject { +public : + AliComparisonDCA(); + AliComparisonDCA(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + ~AliComparisonDCA(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC); + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderDCA",TString title = "Analysed DCA histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray * array=0); + + // Process events + void ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC); + void ProcessTPCITS(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC); + void ProcessConstrained(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC); // not implemented + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + // getters + /* + TH3F *GetD0TanSPtTPCITS() const {return fD0TanSPtTPCITS;} + TH3F *GetD1TanSPtTPCITS() const {return fD1TanSPtTPCITS;} + TH3F *GetD0TanSPt() const {return fD0TanSPt;} + TH3F *GetD1TanSPt() const {return fD1TanSPt;} + TH3F *GetD0TanSPtTPC() const {return fD0TanSPtTPC;} + TH3F *GetD1TanSPtTPC() const {return fD1TanSPtTPC;} + */ + + // DCA + THnSparse* GetDCAHisto() const {return fDCAHisto;} + +private: + + // DCA histograms + THnSparseF *fDCAHisto; //-> dca_r:dca_z:eta:pt + + /* + TH3F *fD0TanSPtTPCITS; //-> distance to vertex y (TPC+ITS clusters) + TH3F *fD1TanSPtTPCITS; //-> distance to vertex z (TPC+ITS clusters) + TH3F *fD0TanSPt; //-> distance to vertex y + TH3F *fD1TanSPt; //-> distance to vertex z + TH3F *fD0TanSPtTPC; //-> distance to vertex y (only TPC track parameters) + TH3F *fD1TanSPtTPC; //-> distance to vertex z (only TPC track parameters) + */ + + // Global cuts objects + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliComparisonDCA(const AliComparisonDCA&); // not implemented + AliComparisonDCA& operator=(const AliComparisonDCA&); // not implemented + + ClassDef(AliComparisonDCA,1); +}; + +#endif diff --git a/PWG1/TPC/AliComparisonDEdx.cxx b/PWG1/TPC/AliComparisonDEdx.cxx new file mode 100644 index 00000000000..def210e8bda --- /dev/null +++ b/PWG1/TPC/AliComparisonDEdx.cxx @@ -0,0 +1,362 @@ +//------------------------------------------------------------------------------ +// Implementation of AliComparisonDEdx class. It keeps information from +// comparison of reconstructed and MC particle tracks. In addtion, +// it keeps selection cuts used during comparison. The comparison +// information is stored in the ROOT histograms. Analysis of these +// histograms can be done by using Analyse() class function. The result of +// the analysis (histograms/graphs) are stored in the folder which is +// a data of AliComparisonDEdx. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + TFile f("Output.root"); + //AliComparisonDEdx * compObj = (AliComparisonDEdx*)f.Get("AliComparisonDEdx"); + AliComparisonDEdx * compObj = (AliComparisonDEdx*)cOutput->FindObject("AliComparisonDEdx"); + + // Analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderDEdx" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_DEdx.root"."recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include +#include +#include + +#include "AliComparisonDEdx.h" +#include "AliESDEvent.h" +#include "AliESDRecInfo.h" +#include "AliLog.h" +#include "AliMCInfo.h" +#include "AliMCInfoCuts.h" +#include "AliMathBase.h" +#include "AliRecInfoCuts.h" +#include "AliTreeDraw.h" + +using namespace std; + +ClassImp(AliComparisonDEdx) + +//_____________________________________________________________________________ +AliComparisonDEdx::AliComparisonDEdx(): +// TNamed("AliComparisonDEdx","AliComparisonDEdx"), + AliComparisonObject("AliComparisonDEdx"), + + // dEdx + fDeDxHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // default constructor +} + +//_____________________________________________________________________________ +AliComparisonDEdx::AliComparisonDEdx(Char_t* name="AliComparisonDEdx", Char_t* title="AliComparisonDEdx",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE): + AliComparisonObject(name,title), + + // dEdx + fDeDxHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + Init(); +} + + +//_____________________________________________________________________________ +AliComparisonDEdx::~AliComparisonDEdx() +{ + // destructor + if(fDeDxHisto) delete fDeDxHisto; fDeDxHisto=0; + + if(fCutsRC) delete fCutsRC; fCutsRC=0; + if(fCutsMC) delete fCutsMC; fCutsMC=0; + + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; +} + +//_____________________________________________________________________________ +void AliComparisonDEdx::Init() +{ + // Init histograms + + // TPC dEdx + Int_t nPBins = 31; + Double_t binsP[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.}; + Double_t pMin = 0., pMax = 10.; + + if(IsHptGenerator() == kTRUE) { + nPBins = 100; + pMin = 0.; pMax = 100.; + } + + //signal:alpha:y:z:snp:tgl:ncls:pid:p + Int_t binsQA[9] = {600,50, 50, 50, 50, 50, 80, 5, nPBins}; + Double_t xminQA[9] = {0, -4,-20,-250, -1, -2, 0, 0., pMin}; + Double_t xmaxQA[9] = {300, 4, 20, 250, 1, 2, 160, 5., pMax}; + + fDeDxHisto = new THnSparseF("fDeDxHisto","signal:alpha:y:z:snp:tgl:ncls:pid:momentum",9,binsQA,xminQA,xmaxQA); + if(!IsHptGenerator()) fDeDxHisto->SetBinEdges(8,binsP); + + fDeDxHisto->GetAxis(0)->SetTitle("signal"); + fDeDxHisto->GetAxis(1)->SetTitle("alpha (rad)"); + fDeDxHisto->GetAxis(2)->SetTitle("y (cm)"); + fDeDxHisto->GetAxis(3)->SetTitle("z (cm)"); + fDeDxHisto->GetAxis(4)->SetTitle("snp"); + fDeDxHisto->GetAxis(5)->SetTitle("tgl"); + fDeDxHisto->GetAxis(6)->SetTitle("ncls"); + fDeDxHisto->GetAxis(6)->SetTitle("pid"); + fDeDxHisto->GetAxis(7)->SetTitle("p (GeV/c)"); + fDeDxHisto->Sumw2(); + + // Init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderDEdx","Analysis de/dx Folder"); +} + +//_____________________________________________________________________________ +void AliComparisonDEdx::ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC) +{ + // Fill dE/dx comparison information + + // Check selection cuts + if (fCutsMC->IsPdgParticle(TMath::Abs(infoMC->GetParticle().GetPdgCode())) == kFALSE) return; + + Double_t pid = -1; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetEM() ) pid = 0; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetMuM() ) pid = 1; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetPiP() ) pid = 2; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetKP() ) pid = 3; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetProt() ) pid = 4; + + if (!infoRC->GetESDtrack()) return; + if (infoRC->GetESDtrack()->GetTPCNcls()GetMinNClustersTPC()) return; + + Float_t dedx = infoRC->GetESDtrack()->GetTPCsignal(); + Int_t ncls = infoRC->GetESDtrack()->GetTPCNcls(); + + const AliExternalTrackParam *innerParam = 0; + if ((innerParam = infoRC->GetESDtrack()->GetInnerParam()) == 0) return; + + Double_t pt = innerParam->Pt(); + Double_t lam = TMath::ATan2(innerParam->Pz(),innerParam->Pt()); + Double_t p = pt/TMath::Cos(lam); + Double_t alpha = innerParam->GetAlpha(); + Double_t y = innerParam->GetY(); + Double_t z = innerParam->GetZ(); + Double_t snp = innerParam->GetSnp(); + Double_t tgl = innerParam->GetTgl(); + + Double_t vDeDxHisto[9] = {dedx,alpha,y,z,snp,tgl,ncls,pid,p}; + fDeDxHisto->Fill(vDeDxHisto); +} + +//_____________________________________________________________________________ +void AliComparisonDEdx::ProcessTPCITS(AliMCInfo* const /*infoMC*/, AliESDRecInfo *const /*infoRC*/) +{ + // Fill dE/dx comparison information + + AliDebug(AliLog::kWarning, "Warning: Not implemented"); +} + +//_____________________________________________________________________________ +void AliComparisonDEdx::ProcessConstrained(AliMCInfo* const /*infoMC*/, AliESDRecInfo *const /*infoRC*/) +{ + // Fill dE/dx comparison information + + AliDebug(AliLog::kWarning, "Warning: Not implemented"); +} + +//_____________________________________________________________________________ +Long64_t AliComparisonDEdx::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliComparisonDEdx* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fDeDxHisto->Add(entry->fDeDxHisto); + count++; + } + +return count; +} + +//_____________________________________________________________________________ +void AliComparisonDEdx::Exec(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC) +{ + // Process comparison information + + if(GetAnalysisMode() == 0) ProcessTPC(infoMC,infoRC); + else if(GetAnalysisMode() == 1) ProcessTPCITS(infoMC,infoRC); + else if(GetAnalysisMode() == 2) ProcessConstrained(infoMC,infoRC); + else { + printf("ERROR: AnalysisMode %d \n",fAnalysisMode); + return; + } +} + +//_____________________________________________________________________________ +TH1F* AliComparisonDEdx::MakeResol(TH2F * his, Int_t integ, Bool_t type) +{ + // Make resolution histograms + TH1F *hisr, *hism; + if (!gPad) new TCanvas; + hisr = AliTreeDraw::CreateResHistoI(his,&hism,integ); + if (type) return hism; + else + return hisr; +} + +//_____________________________________________________________________________ +void AliComparisonDEdx::Analyse() +{ + // Analyze comparison information and store output histograms + // in the folder "folderDEdx" + // + TH1::AddDirectory(kFALSE); + TObjArray *aFolderObj = new TObjArray; + + /* + TH1F *hiss=0; + TGraph2D * gr=0; + + // write results in the folder + TCanvas * c = new TCanvas("can","TPC dedx"); + c->cd(); + + hiss = comp->MakeResol(comp->fTPCSignalNormTan,4,0); + hiss->SetXTitle("Tan(#theta)"); + hiss->SetYTitle("#sigma_{dEdx}"); + hiss->Draw(); + hiss->SetName("TPCdEdxResolTan"); + + aFolderObj->Add(hiss); + // + hiss = comp->MakeResol(comp->fTPCSignalNormTan,4,1); + hiss->SetXTitle("Tan(#theta)"); + hiss->SetYTitle(""); + hiss->Draw(); + hiss->SetName("TPCdEdxMeanTan"); + + aFolderObj->Add(hiss); + // + gr = AliMathBase::MakeStat2D(comp->fTPCSignalNormTanSPt,3,1,4); + gr->GetXaxis()->SetTitle("Tan(#theta)"); + gr->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr->GetZaxis()->SetTitle(""); + gr->SetName("TPCdEdxMeanTanPt_1"); + gr->GetHistogram()->Draw("colz"); + + gr->GetHistogram()->SetName("TPCdEdxMeanTanPt_1"); + aFolderObj->Add(gr->GetHistogram()); + // + gr = AliMathBase::MakeStat2D(comp->fTPCSignalNormTanSPt,3,1,5); + gr->GetXaxis()->SetTitle("Tan(#theta)"); + gr->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr->GetZaxis()->SetTitle("#sigma_{dEdx}"); + gr->SetName("TPCdEdxMeanTanPt_2"); + gr->GetHistogram()->Draw("colz"); + + gr->GetHistogram()->SetName("TPCdEdxMeanTanPt_2"); + aFolderObj->Add(gr->GetHistogram()); + */ + + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjrArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TFolder* AliComparisonDEdx::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliComparisonDEdx * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + + +//_____________________________________________________________________________ +TFolder* AliComparisonDEdx::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} + diff --git a/PWG1/TPC/AliComparisonDEdx.h b/PWG1/TPC/AliComparisonDEdx.h new file mode 100644 index 00000000000..91c9495b5d2 --- /dev/null +++ b/PWG1/TPC/AliComparisonDEdx.h @@ -0,0 +1,90 @@ +#ifndef ALICOMPARISONDEdx_H +#define ALICOMPARISONDEdx_H + +//------------------------------------------------------------------------------ +// Class to keep information from comparison of +// reconstructed and MC particle tracks (TPC dE/dx). +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +class TCanvas; +class TH1F; +class TH2F; +class TNamed; +class TString; + +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliRecInfoCuts; +class AliMCInfoCuts; + +#include "THnSparse.h" +#include "AliComparisonObject.h" + +class AliComparisonDEdx : public AliComparisonObject { +public : + AliComparisonDEdx(); + AliComparisonDEdx(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + ~AliComparisonDEdx(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC); + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderDEdx",TString title = "Analysed DEdx histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray * array=0); + + // Process events + void ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC); + void ProcessTPCITS(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC); // not implemented + void ProcessConstrained(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC); // not implemented + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + static TH1F* MakeResol(TH2F * his, Int_t integ, Bool_t type); + + // + // TPC dE/dx + // + THnSparse* GetDeDxHisto() const {return fDeDxHisto;} + +private: + + // TPC dE/dx + THnSparseF *fDeDxHisto; //-> signal:alpha:y:z:snp:tgl:ncls:pid:p + + // Selection cuts + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliComparisonDEdx(const AliComparisonDEdx&); // not implemented + AliComparisonDEdx& operator=(const AliComparisonDEdx&); // not implemented + + ClassDef(AliComparisonDEdx,1); +}; + +#endif diff --git a/PWG1/TPC/AliComparisonDraw.cxx b/PWG1/TPC/AliComparisonDraw.cxx new file mode 100644 index 00000000000..002c9672557 --- /dev/null +++ b/PWG1/TPC/AliComparisonDraw.cxx @@ -0,0 +1,678 @@ + + +// +// Comparison draw +// Compare the MC information with the reconstructed +// + +/* + after running analysis, read the file, and get component + gSystem->Load("libPWG1.so"); + TFile f("Output.root"); + AliComparisonDraw * comp = (AliComparisonDraw*)f.Get("AliComparisonDraw"); + TF1 fl("fl","((min(250./(abs(x+0.000001)),250)-90))",0,2); // length function + TF1 fl2("fl2","[0]/((min(250./(abs(x+0.000001)),250)-90))^[1]",0,2); + fl2.SetParameter(1,1); + fl2.SetParameter(0,1); + +*/ + + + + +#include "TFile.h" +#include "TCint.h" +#include "TH3F.h" +#include "TH2F.h" +#include "TF1.h" +#include "TProfile.h" +#include "TProfile2D.h" +#include "TGraph2D.h" +#include "TCanvas.h" +#include "TGraph.h" +// +// +#include "AliESDEvent.h" // new container +#include "AliESD.h" +#include "AliESDfriend.h" +#include "AliESDfriendTrack.h" +// +#include "AliMathBase.h" +#include "AliTreeDraw.h" + +#include "AliMCInfo.h" +#include "AliESDRecInfo.h" +#include "AliComparisonDraw.h" + + +ClassImp(AliComparisonDraw) + +Bool_t AliComparisonDraw::fgBDraw=kFALSE; //option draw temporary results + +AliComparisonDraw::AliComparisonDraw(): + TNamed("ComparisonDraw","ComparisonDraw"), + fEffTPCPt(0), // TPC efficiency as function of Pt (tan+-1) + fEffTPCPtMC(0), // MC -TPC efficiency as function of Pt (tan+-1) + fEffTPCPtF(0), // efficiency for findable tracks + // + fEffTPCTan(0), // TPC efficiency as function of Tan (pt>0.15 + fEffTPCTanMC(0), // MC -TPC efficiency as function of Tan (pt>0.15) + fEffTPCTanF(0), // efficiency for findable tracks Tan (pt>0.15) + // + fEffTPCPtTan(0), // TPC efficiency as function of Pt and tan + fEffTPCPtTanMC(0), // MC -TPC efficiency as function of Pt and tan + fEffTPCPtTanF(0), // TPC efficiency as function of Pt and tan + // + // dEdx resolution + // + fTPCSignalNormTan(0), // tpc signal normalized to the mean signal - MC + fTPCSignalNormSPhi(0), // tpc signal normalized to the mean signal - MC + fTPCSignalNormTPhi(0), // tpc signal normalized to the mean signal - MC + // + fTPCSignalNormTanSPhi(0), // tpc signal normalized to the mean signal - MC + fTPCSignalNormTanTPhi(0), // tpc signal normalized to the mean signal - MC + fTPCSignalNormTanSPt(0), // tpc signal normalized to the mean signal - MC + // + // + fPtResolLPT(0), // pt resolution - low pt + fPtResolHPT(0), // pt resolution - high pt + fPtPullLPT(0), // pt resolution - low pt + fPtPullHPT(0), // pt resolution - high pt + // + // Resolution constrained param + // + fCPhiResolTan(0), // angular resolution - constrained + fCTanResolTan(0), // angular resolution - constrained + fCPtResolTan(0), // pt resolution - constrained + fCPhiPullTan(0), // angular resolution - constrained + fCTanPullTan(0), // angular resolution - constrained + fCPtPullTan(0), // pt resolution - constrained + // + // DCA resolution + // + fD0TanSPtB1(0), // distance to vertex y + fD1TanSPtB1(0), // distance to vertex z + fD0TanSPtL1(0), // distance to vertex y + fD1TanSPtL1(0) // distance to vertex z +{ + InitHisto(); +} + +AliComparisonDraw::AliComparisonDraw(const AliComparisonDraw& draw): + TNamed(draw.GetName(),draw.GetTitle()), + fEffTPCPt(draw.fEffTPCPt), // TPC efficiency as function of Pt (tan+-1) + fEffTPCPtMC(draw.fEffTPCPtMC), // MC -TPC efficiency as function of Pt (tan+-1) + fEffTPCPtF(draw.fEffTPCPtF), // efficiency for findable tracks + // + fEffTPCTan(draw.fEffTPCTan), // TPC efficiency as function of Tan (pt>0.15 + fEffTPCTanMC(draw.fEffTPCTanMC), // MC -TPC efficiency as function of Tan (pt>0.15) + fEffTPCTanF(draw.fEffTPCTanF), // efficiency for findable tracks Tan (pt>0.15) + // + fEffTPCPtTan(draw.fEffTPCPtTan), // TPC efficiency as function of Pt and tan + fEffTPCPtTanMC(draw.fEffTPCPtTanMC), // MC -TPC efficiency as function of Pt and tan + fEffTPCPtTanF(draw.fEffTPCPtTanF), // TPC efficiency as function of Pt and tan + // + // dEdx resolution + // + fTPCSignalNormTan(draw.fTPCSignalNormTan), // tpc signal normalized to the mean signal - MC + fTPCSignalNormSPhi(draw.fTPCSignalNormSPhi), // tpc signal normalized to the mean signal - MC + fTPCSignalNormTPhi(draw.fTPCSignalNormTPhi), // tpc signal normalized to the mean signal - MC + // + fTPCSignalNormTanSPhi(draw.fTPCSignalNormTanSPhi), // tpc signal normalized to the mean signal - MC + fTPCSignalNormTanTPhi(draw.fTPCSignalNormTanTPhi), // tpc signal normalized to the mean signal - MC + fTPCSignalNormTanSPt(draw.fTPCSignalNormTanSPt), // tpc signal normalized to the mean signal - MC + // + // + fPtResolLPT(draw.fPtResolLPT), // pt resolution - low pt + fPtResolHPT(draw.fPtResolHPT), // pt resolution - high pt + fPtPullLPT(draw.fPtPullLPT), // pt resolution - low pt + fPtPullHPT(draw.fPtPullHPT), // pt resolution - high pt + // + // Resolution constrained param + // + fCPhiResolTan(draw.fCPhiResolTan), // angular resolution - constrained + fCTanResolTan(draw.fCTanResolTan), // angular resolution - constrained + fCPtResolTan(draw.fCPtResolTan), // pt resolution - constrained + fCPhiPullTan(draw.fCPhiPullTan), // angular resolution - constrained + fCTanPullTan(draw.fCTanPullTan), // angular resolution - constrained + fCPtPullTan(draw.fCPtPullTan), // pt resolution - constrained + // + // DCA resolution + // + fD0TanSPtB1(draw.fD0TanSPtB1), // distance to vertex y + fD1TanSPtB1(draw.fD1TanSPtB1), // distance to vertex z + fD0TanSPtL1(draw.fD0TanSPtL1), // distance to vertex y + fD1TanSPtL1(draw.fD1TanSPtL1) // distance to vertex z +{ + // + // copy constructor + // +} + +AliComparisonDraw& AliComparisonDraw::operator=(const AliComparisonDraw& info){ + // + // assignment operator + // + delete this; + new (this) AliComparisonDraw(info); + return *this; +} + + + + +AliComparisonDraw::~AliComparisonDraw(){ + // + // + // + delete fEffTPCPt; // TPC efficiency as function of Pt (tan+-1) + delete fEffTPCPtMC; // MC -TPC efficiency as function of Pt (tan+-1) + delete fEffTPCPtF; // efficiency for findable tracks + // + delete fEffTPCTan; // TPC efficiency as function of Tan (pt>0.15 + delete fEffTPCTanMC; // MC -TPC efficiency as function of Tan (pt>0.15) + delete fEffTPCTanF; // efficiency for findable tracks Tan (pt>0.15) + // + delete fEffTPCPtTan; // TPC efficiency as function of Pt and tan + delete fEffTPCPtTanMC; // MC -TPC efficiency as function of Pt and tan + delete fEffTPCPtTanF; // TPC efficiency as function of Pt and tan + // + // dEdx resolution + // + delete fTPCSignalNormTan; // tpc signal normalized to the mean signal - MC + delete fTPCSignalNormSPhi; // tpc signal normalized to the mean signal - MC + delete fTPCSignalNormTPhi; // tpc signal normalized to the mean signal - MC + // + delete fTPCSignalNormTanSPhi; // tpc signal normalized to the mean signal - MC + delete fTPCSignalNormTanTPhi; // tpc signal normalized to the mean signal - MC + delete fTPCSignalNormTanSPt; // tpc signal normalized to the mean signal - MC + // + // + delete fPtResolLPT; // pt resolution - low pt + delete fPtResolHPT; // pt resolution - high pt + delete fPtPullLPT; // pt resolution - low pt + delete fPtPullHPT; // pt resolution - high pt + // + // Resolution constrained param + // + delete fCPhiResolTan; // angular resolution - constrained + delete fCTanResolTan; // angular resolution - constrained + delete fCPtResolTan; // pt resolution - constrained + delete fCPhiPullTan; // angular resolution - constrained + delete fCTanPullTan; // angular resolution - constrained + delete fCPtPullTan; // pt resolution - constrained + // + // DCA resolution + // + delete fD0TanSPtB1; // distance to vertex y + delete fD1TanSPtB1; // distance to vertex z + delete fD0TanSPtL1; // distance to vertex y + delete fD1TanSPtL1; // distance to vertex z + +} + + + + +void AliComparisonDraw::InitHisto(){ + // + // + // EFFICIENCY + // + // Efficiency as function of pt + fEffTPCPt = new TProfile("Eff_pt","Eff_Pt",50,0.1,3); // physical + fEffTPCPtMC = new TProfile("MC_Eff_pt","MC_Eff_Pt",50,0.1,3); // MC - particles make more than 50 rowdigits + fEffTPCPtF = new TProfile("F_Eff_pt","F_Eff_Pt",50,0.1,3); // tracking - under condition more than 50 rdigits + + // Efficiency as function of pt + fEffTPCTan = new TProfile("Eff_tan","Eff_tan",50,-2.5,2.5); // physical + fEffTPCTanMC = new TProfile("MC_Eff_tan","MC_Eff_tan",50,-2.5,2.5); // MC - particles make more than 50 rowdigits + fEffTPCTanF = new TProfile("F_Eff_tan","F_Eff_tan",50,-2.5,2.5); // tracking - under condition more than 50 rdigits + + fEffTPCPtTan = new TProfile2D("Eff_pt","Eff_Pt",10,0.1,3,20,-2.,2.); + fEffTPCPtTanMC = new TProfile2D("MC_Eff_pt","MC Eff Pt",10,0.1,3,20, -2.,2.); + fEffTPCPtTanF = new TProfile2D("MC_Eff_pt","MC Eff Pt",10,0.1,3,20, -2.,2.); + + // + // TPC dEdx + // + fTPCSignalNormTan = new TH2F("CdEdxTan","CdEdxTan",50, -2,2, 40,30,70); // tpc signal normalized to the MC + fTPCSignalNormSPhi = new TH2F("CdEdxSPhi","CdEdxSPhi",10,0.0,1,40,30,70); // tpc signal normalized to the MC + fTPCSignalNormTPhi = new TH2F("CdEdxTPhi","CdEdxTPhi",10,0.0,2,40,30,70); // tpc signal normalized to the MC + + fTPCSignalNormTanSPhi= new TH3F("CdEdxTanSPhi","CdEdxTanSPhi",20, -2,2, 10,0.0 ,1, 40,30,70); // tpc signal normalized to the mean signal - MC + fTPCSignalNormTanTPhi= new TH3F("CdEdxTanTPhi","CdEdxTanTPhi",20, -2,2, 10,0.0 ,1, 40,30,70); // tpc signal normalized to the mean signal - MC + fTPCSignalNormTanSPt= new TH3F("CdEdxTanSPt","CdEdxTanSPt",20, -2,2, 10,0.3 ,3, 40,30,70); // tpc signal normalized to the mean signal - MC + + + + // + // RESOLUTION + // + fCPtResolTan = new TH2F("C Pt resol","C pt resol",50, -2,2,200,-0.2,0.2); + fCPtPullTan = new TH2F("C Pt pull","C pt pull",50, -2,2,200,-5,5); + // + fCPhiResolTan = new TH2F("CPhiResolTan","CPhiResolTan",50, -2,2,200,-0.025,0.025); + // angular resolution - constrained + fCTanResolTan = new TH2F("CTanResolTan","CTanResolTan",50, -2,2,200,-0.025,0.025); + // angular resolution - constrained + fCPtResolTan=new TH2F("CPtResol","CPtResol",50, -2,2,200,-0.2,0.2);; + // pt resolution - constrained + fCPhiPullTan = new TH2F("CPhiPullTan","CPhiPullTan",50, -2,2,200,-5,5); + // angular resolution - constrained + fCTanPullTan = new TH2F("CTanPullTan","CTanPullTan",50, -2,2,200,-5,5); + // angular resolution - constrained + fCPtPullTan=new TH2F("CPtPull","CPtPull",50, -2,2,200,-5,5); + // pt resolution - constrained + // + fPtResolLPT = new TH2F("Pt resol","pt resol",10, 0.1,3,200,-0.2,0.2); + fPtResolHPT = new TH2F("Pt resol","pt resol",10, 2,100,200,-0.3,0.3); + fPtPullLPT = new TH2F("Pt pool","pt pool",10, 0.1,3,200,-6,6); + fPtPullHPT = new TH2F("Pt pool","pt pool",10, 2,100,200,-6,6); + // + fD0TanSPtB1 = new TH3F("DCAyTanSPt","DCAyTanSPt",20,1,2, 10,0.3,2, 100,-4,4); + fD1TanSPtB1 = new TH3F("DCAzTanSPt","DCAzTanSPt",20,1,2, 10,0.3,2, 100,-4,4); + fD0TanSPtL1 = new TH3F("DCAyTanSPt","DCAyTanSPt",20,0,1, 10,0.3,2, 100,-0.1,0.1); + fD1TanSPtL1 = new TH3F("DCAzTanSPt","DCAzTanSPt",20,0,1, 10,0.3,2, 100, -0.1,0.1); + + + +} + +void AliComparisonDraw::ProcessEff(AliMCInfo* infoMC, AliESDRecInfo *infoRC){ + // + // make efficiencies histograms + // + Float_t kptcut = 0.15; + Float_t ktancut=1.; + Int_t kmincl =50; + Float_t mcpt = infoMC->GetParticle().Pt(); + Float_t tantheta = TMath::Tan(infoMC->GetParticle().Theta()-TMath::Pi()*0.5); + Bool_t isPrim = infoMC->GetParticle().R()<0.1 && TMath::Abs(infoMC->GetParticle().Vz())<10; + //z diamond and + + if (!isPrim) return; + + //pt + if (TMath::Abs(tantheta)Fill(mcpt, infoRC->GetStatus(1)==3); + fEffTPCPtMC->Fill(mcpt, infoMC->GetRowsWithDigits()>kmincl); + if (infoMC->GetRowsWithDigits()>kmincl){ + fEffTPCPtF->Fill(mcpt, infoRC->GetStatus(1)==3); + } + } + + //theta + if (TMath::Abs(mcpt)>kptcut){ + fEffTPCTan->Fill(tantheta, infoRC->GetStatus(1)==3); + fEffTPCTanMC->Fill(tantheta, infoMC->GetRowsWithDigits()>kmincl); + if (infoMC->GetRowsWithDigits()>kmincl){ + fEffTPCTanF->Fill(tantheta, infoRC->GetStatus(1)==3); + } + } + // + // pt-theta + // + fEffTPCPtTan->Fill(mcpt,tantheta,infoRC->GetStatus(1)==3); + fEffTPCPtTanMC->Fill(mcpt,tantheta,infoMC->GetRowsWithDigits()>50); + if (infoMC->GetRowsWithDigits()>kmincl){ + fEffTPCPtTanF->Fill(mcpt,tantheta,infoRC->GetStatus(1)==3); + } +} + + +void AliComparisonDraw::ProcessResolConstrained(AliMCInfo* infoMC, AliESDRecInfo *infoRC){ + // + // + // + Float_t mcpt = infoMC->GetParticle().Pt(); + Float_t tantheta = TMath::Tan(infoMC->GetParticle().Theta()-TMath::Pi()*0.5); + Bool_t isPrim = infoMC->GetParticle().R()<0.1 && TMath::Abs(infoMC->GetParticle().Vz())<10; + //z diamond and + + if (!isPrim) return; + if (infoRC->GetStatus(1)!=3) return; + if (!infoRC->GetESDtrack()) return; + if (infoRC->GetESDtrack()->GetTPCNcls()<10) return; + if (!infoRC->GetESDtrack()->GetConstrainedParam()) return; + + // + // constrained parameters resolution + // + const AliExternalTrackParam * cparam = infoRC->GetESDtrack()->GetConstrainedParam(); + Float_t deltaCPt= (mcpt-cparam->Pt())/mcpt; + Float_t pullCPt= (1/mcpt-cparam->OneOverPt())/ + TMath::Sqrt(cparam->GetSigma1Pt2()); + Float_t deltaPhi = TMath::ATan2(cparam->Py(),cparam->Px())- + TMath::ATan2(infoMC->GetParticle().Py(),infoMC->GetParticle().Px()); + Float_t pullPhi = deltaPhi/TMath::Sqrt(cparam->GetSigmaSnp2()); + + Float_t deltaTan = TMath::ATan2(cparam->Pz(),cparam->Pt())- + TMath::ATan2(infoMC->GetParticle().Pz(),infoMC->GetParticle().Pt()); + Float_t pullTan = deltaPhi/TMath::Sqrt(cparam->GetSigmaSnp2()); + + fCPtResolTan->Fill(tantheta,deltaCPt); + fCPtPullTan->Fill(tantheta,pullCPt); + fCPhiResolTan->Fill(tantheta,deltaPhi); + fCPhiPullTan->Fill(tantheta,pullPhi); + fCTanResolTan->Fill(tantheta,deltaTan); + fCTanPullTan->Fill(tantheta,pullTan); + +} + + + +void AliComparisonDraw::ProcessTPCdedx(AliMCInfo* infoMC, AliESDRecInfo *infoRC){ + // + // + // + Float_t mcpt = infoMC->GetParticle().Pt(); + Float_t tantheta = TMath::Tan(infoMC->GetParticle().Theta()-TMath::Pi()*0.5); + Bool_t isPrim = infoMC->GetParticle().R()<0.1 && TMath::Abs(infoMC->GetParticle().Vz())<10; + //z diamond and + + if (!isPrim) return; + if (infoRC->GetStatus(1)!=3) return; + if (!infoRC->GetESDtrack()) return; + if (infoRC->GetESDtrack()->GetTPCNcls()<10) return; + if (!infoRC->GetESDtrack()->GetConstrainedParam()) return; + Float_t mprim = infoMC->GetPrim(); + if (mprim>1.4) return; + if (mprim<0.5) return; + if (infoRC->GetESDtrack()->GetTPCsignalN()<50) return; + // + Float_t ratio = infoRC->GetESDtrack()->GetTPCsignal()/infoMC->GetPrim(); + Float_t sphi = infoRC->GetESDtrack()->GetInnerParam()->GetSnp(); + Float_t tphi = sphi/TMath::Sqrt((1.-sphi)*(1.+sphi)); + + + if (TMath::Abs(infoMC->GetParticle().GetPdgCode())!=211) return; + if (mcpt>0.5){ + fTPCSignalNormTan->Fill(tantheta,ratio); //only subset + } + if (TMath::Abs(tantheta)<0.5){ + fTPCSignalNormSPhi->Fill(sphi,ratio); // only subset + fTPCSignalNormTPhi->Fill(tphi,ratio); // only subset + } + fTPCSignalNormTanSPhi->Fill(tantheta,sphi,ratio); + fTPCSignalNormTanTPhi->Fill(tantheta,tphi,ratio); + fTPCSignalNormTanSPt->Fill(tantheta,TMath::Sqrt(mcpt),ratio); +} + +void AliComparisonDraw::ProcessDCA(AliMCInfo* infoMC, AliESDRecInfo *infoRC){ + // + // + // + Float_t mcpt = infoMC->GetParticle().Pt(); + Float_t tantheta = TMath::Tan(infoMC->GetParticle().Theta()-TMath::Pi()*0.5); + Bool_t isPrim = infoMC->GetParticle().R()<0.1 && TMath::Abs(infoMC->GetParticle().Vz())<10; + //z diamond and + if (!isPrim) return; + if (infoRC->GetStatus(1)!=3) return; + if (!infoRC->GetESDtrack()) return; + if (infoRC->GetESDtrack()->GetTPCNcls()<10) return; + if (!infoRC->GetESDtrack()->GetConstrainedParam()) return; + Float_t spt = TMath::Sqrt(mcpt); + Float_t dca[2],cov[3]; + infoRC->GetESDtrack()->GetImpactParameters(dca,cov); + Int_t clusterITS[100]; + if (infoRC->GetESDtrack()->GetITSclusters(clusterITS)==0){ + fD0TanSPtB1->Fill(tantheta,spt,dca[0]); + fD1TanSPtB1->Fill(tantheta,spt,dca[1]); + } + fD0TanSPtL1->Fill(tantheta,spt,dca[0]); + fD1TanSPtL1->Fill(tantheta,spt,dca[1]); +} + + + + +void AliComparisonDraw::Process(AliMCInfo* infoMC, AliESDRecInfo *infoRC){ + // + // + // + ProcessEff(infoMC,infoRC); + ProcessResolConstrained(infoMC,infoRC); + ProcessTPCdedx(infoMC, infoRC); + ProcessDCA(infoMC, infoRC); + + Float_t mcpt = infoMC->GetParticle().Pt(); + Bool_t isPrim = infoMC->GetParticle().R()<0.1 && TMath::Abs(infoMC->GetParticle().Vz())<10; + //z diamond and + + if (!isPrim) return; + // + // + if (infoRC->GetStatus(1)==0) return; + if (!infoRC->GetESDtrack()) return; + if (infoRC->GetESDtrack()->GetTPCNcls()<10) return; + // printf("Pt\t%f\t%f\n",mcpt, infoRC->GetESDtrack()->Pt()); + + Float_t deltaPt= (mcpt-infoRC->GetESDtrack()->Pt())/mcpt; + Float_t poolPt= (1/mcpt-infoRC->GetESDtrack()->OneOverPt())/ + TMath::Sqrt(infoRC->GetESDtrack()->GetSigma1Pt2()); + + fPtResolLPT->Fill(mcpt,deltaPt); + fPtResolHPT->Fill(mcpt,deltaPt); + fPtPullLPT->Fill(mcpt,poolPt); + fPtPullHPT->Fill(mcpt,poolPt); +} + + + +TH1F* AliComparisonDraw::MakeResol(TH2F * his, Int_t integ, Bool_t type){ + TH1F *hisr, *hism; + if (!gPad) new TCanvas; + hisr = AliTreeDraw::CreateResHistoI(his,&hism,integ); + if (type) return hism; + else + return hisr; +} + + +TGraph2D * AliComparisonDraw::MakeStat2D(TH3 * his, Int_t delta0, Int_t delta1, Int_t type){ + // + // + // + // delta - number of bins to integrate + // type - 0 - mean value + + TAxis * xaxis = his->GetXaxis(); + TAxis * yaxis = his->GetYaxis(); + // TAxis * zaxis = his->GetZaxis(); + Int_t nbinx = xaxis->GetNbins(); + Int_t nbiny = yaxis->GetNbins(); + char name[1000]; + Int_t icount=0; + TGraph2D *graph = new TGraph2D(nbinx*nbiny); + TF1 f1("f1","gaus"); + for (Int_t ix=0; ixGetBinCenter(ix); + Float_t ycenter = yaxis->GetBinCenter(iy); + sprintf(name,"%s_%d_%d",his->GetName(), ix,iy); + TH1 *projection = his->ProjectionZ(name,ix-delta0,ix+delta0,iy-delta1,iy+delta1); + Float_t stat= 0; + if (type==0) stat = projection->GetMean(); + if (type==1) stat = projection->GetRMS(); + if (type==2 || type==3){ + TVectorD vec(3); + AliMathBase::LTM((TH1F*)projection,&vec,0.7); + if (type==2) stat= vec[1]; + if (type==3) stat= vec[0]; + } + if (type==4|| type==5){ + projection->Fit(&f1); + if (type==4) stat= f1.GetParameter(1); + if (type==5) stat= f1.GetParameter(2); + } + //printf("%d\t%f\t%f\t%f\n", icount,xcenter, ycenter, stat); + graph->SetPoint(icount,xcenter, ycenter, stat); + icount++; + } + return graph; +} + +TGraph * AliComparisonDraw::MakeStat1D(TH3 * his, Int_t delta1, Int_t type){ + // + // + // + // delta - number of bins to integrate + // type - 0 - mean value + + TAxis * xaxis = his->GetXaxis(); + TAxis * yaxis = his->GetYaxis(); + // TAxis * zaxis = his->GetZaxis(); + Int_t nbinx = xaxis->GetNbins(); + Int_t nbiny = yaxis->GetNbins(); + char name[1000]; + Int_t icount=0; + TGraph *graph = new TGraph(nbinx); + TF1 f1("f1","gaus"); + for (Int_t ix=0; ixGetBinCenter(ix); + // Float_t ycenter = yaxis->GetBinCenter(iy); + sprintf(name,"%s_%d",his->GetName(), ix); + TH1 *projection = his->ProjectionZ(name,ix-delta1,ix+delta1,0,nbiny); + Float_t stat= 0; + if (type==0) stat = projection->GetMean(); + if (type==1) stat = projection->GetRMS(); + if (type==2 || type==3){ + TVectorD vec(3); + AliMathBase::LTM((TH1F*)projection,&vec,0.7); + if (type==2) stat= vec[1]; + if (type==3) stat= vec[0]; + } + if (type==4|| type==5){ + projection->Fit(&f1); + if (type==4) stat= f1.GetParameter(1); + if (type==5) stat= f1.GetParameter(2); + } + //printf("%d\t%f\t%f\t%f\n", icount,xcenter, ycenter, stat); + graph->SetPoint(icount,xcenter, stat); + icount++; + } + return graph; +} + +// +// Make derived plots +// + +void AliComparisonDraw::MakePlots(){ + // + // + // + AliComparisonDraw * comp=this; + + TFile *fp = new TFile("picutures.root","recreate"); + TH1F *hiss=0; + //TH1F *hism=0; + TGraph2D * gr=0, gr2=0; + TGraph * gr0 = 0; + TCanvas * c = new TCanvas("Phi resol Tan","Phi resol Tan"); + // + // + // + hiss = comp->MakeResol(comp->fCPtResolTan,1,0); + hiss->SetXTitle("Tan(#theta)"); + hiss->SetYTitle("#sigmap_{t}/p_{t}"); + hiss->Draw(); + hiss->Write("CptResolTan"); + // + // + hiss = comp->MakeResol(comp->fCPhiResolTan,1,0); + c->cd(); + hiss->SetXTitle("Tan(#theta)"); + hiss->SetYTitle("#sigma#phi (rad)"); + hiss->Draw(); + fp->cd(); + hiss->Write("PhiResolTan"); + // + hiss = comp->MakeResol(comp->fCTanResolTan,1,0); + c->cd(); + hiss->SetXTitle("Tan(#theta)"); + hiss->SetYTitle("#sigma#theta (rad)"); + hiss->Draw(); + fp->cd(); + hiss->Write("ThetaResolTan"); + // + // + hiss = comp->MakeResol(comp->fCTanResolTan,1,0); + c->cd(); + hiss->SetXTitle("Tan(#theta)"); + hiss->SetYTitle("#sigmap_{t}/p_{t} "); + hiss->Draw(); + fp->cd(); + // + // + // + hiss = comp->MakeResol(comp->fTPCSignalNormTan,4,0); + hiss->SetXTitle("Tan(#theta)"); + hiss->SetYTitle("#sigma_{dEdx}"); + hiss->Draw(); + fp->cd(); + hiss->Write("TPCdEdxResolTan"); + // + // + // + hiss = comp->MakeResol(comp->fTPCSignalNormTan,4,1); + hiss->SetXTitle("Tan(#theta)"); + hiss->SetYTitle(""); + hiss->Draw(); + hiss->Write("TPCdEdxMeanTan"); + // + // + gr = comp->MakeStat2D(comp->fTPCSignalNormTanSPt,3,1,4); + gr->GetXaxis()->SetTitle("Tan(#theta)"); + gr->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr->GetZaxis()->SetTitle(""); + gr->Draw("colz"); + gr->GetHistogram()->Write("TPCdEdxMeanTanPt"); + // + // + gr = comp->MakeStat2D(comp->fTPCSignalNormTanSPt,3,1,5); + gr->GetXaxis()->SetTitle("Tan(#theta)"); + gr->GetYaxis()->SetTitle("#sqrt{p_{t}(GeV)}"); + gr->GetZaxis()->SetTitle("#sigma_{dEdx}"); + gr->Draw("colz"); + gr->GetHistogram()->Write("TPCdEdxMeanTanPt"); + // + // + // + comp->fEffTPCTanF->SetXTitle("Tan(#theta)"); + comp->fEffTPCTanF->SetYTitle("eff_{findable}"); + comp->fEffTPCTanF->Draw(); + comp->fEffTPCTanF->Write("EffTanFindable"); + // + // + comp->fEffTPCTan->SetXTitle("Tan(#theta)"); + comp->fEffTPCTan->SetYTitle("eff_{all}"); + comp->fEffTPCTan->Draw(); + comp->fEffTPCTan->Write("EffTanAll"); + // + //DCA resolution + // + gr0 = comp->MakeStat1D(comp->fD0TanSPtB1,2,5); + gr0->GetXaxis()->SetTitle("Tan(#theta)"); + gr0->GetYaxis()->SetTitle("#sigmaDCA (cm)"); + gPad->Clear(); + gr0->Draw("al*"); + gr->GetHistogram()->Write("DCAResolTan"); + // + // + // + gr = comp->MakeStat2D(comp->fD0TanSPtB1,4,2,5); + gr0->GetXaxis()->SetTitle("Tan(#theta)"); + gr0->GetYaxis()->SetTitle("#sigmaDCA (cm)"); + gPad->Clear(); + gr0->Draw("al*"); + gr->GetHistogram()->Write("DCAResolSPTTan"); + + fp->Close(); + + +} + + + diff --git a/PWG1/TPC/AliComparisonDraw.h b/PWG1/TPC/AliComparisonDraw.h new file mode 100644 index 00000000000..3642d481507 --- /dev/null +++ b/PWG1/TPC/AliComparisonDraw.h @@ -0,0 +1,119 @@ + +#ifndef AliComparisonDraw_h +#define AliComparisonDraw_h + + +class TFile; +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliESD; +class AliESDfriend; +class TH1I; +class TH3F; +class TH3; +class TProfile; +class TProfile2D; +class TGraph2D; +class TGraph; + +#include "TNamed.h" + +class AliComparisonDraw : public TNamed { +public : + AliComparisonDraw(); + // + AliComparisonDraw(const AliComparisonDraw& recinfo); + AliComparisonDraw& operator=(const AliComparisonDraw& info); + + ~AliComparisonDraw(); + virtual Bool_t IsFolder() const {return kTRUE;} + void InitHisto(); + void Process(AliMCInfo* infoMC, AliESDRecInfo *infoRC); + + // + // + void ProcessEff(AliMCInfo* infoMC, AliESDRecInfo *infoRC); + void ProcessResolConstrained(AliMCInfo* infoMC, AliESDRecInfo *infoRC); + void ProcessTPCdedx(AliMCInfo* infoMC, AliESDRecInfo *infoRC); + void ProcessDCA(AliMCInfo* infoMC, AliESDRecInfo *infoRC); + + void MakePlots(); + + + //TH1F GetPtResol(Float_t pt0, Float_t pt1); + static TH1F* MakeResol(TH2F * his, Int_t integ, Bool_t type); + static TGraph2D * MakeStat2D(TH3 * his, Int_t delta0, Int_t delta1, Int_t type); + static TGraph * MakeStat1D(TH3 * his, Int_t delta1, Int_t type); + + +protected: + // + // efficiency + // + static Bool_t fgBDraw; //option draw temporary results + TProfile* fEffTPCPt; //->TPC efficiency as function of Pt (tan+-1) + TProfile* fEffTPCPtMC; //->MC -TPC efficiency as function of Pt (tan+-1) + TProfile* fEffTPCPtF; //->efficiency for findable tracks + // + TProfile* fEffTPCTan; //->TPC efficiency as function of Tan (pt>0.15 + TProfile* fEffTPCTanMC; //->MC -TPC efficiency as function of Tan (pt>0.15) + TProfile* fEffTPCTanF; //->efficiency for findable tracks Tan (pt>0.15) + // + TProfile2D* fEffTPCPtTan; //->TPC efficiency as function of Pt and tan + TProfile2D* fEffTPCPtTanMC; //->MC -TPC efficiency as function of Pt and tan + TProfile2D* fEffTPCPtTanF; //-> TPC efficiency as function of Pt and tan + // + // dEdx resolution + // + TH2F* fTPCSignalNormTan; //-> tpc signal normalized to the mean signal - MC + TH2F* fTPCSignalNormSPhi; //-> tpc signal normalized to the mean signal - MC + TH2F* fTPCSignalNormTPhi; //-> tpc signal normalized to the mean signal - MC + // + TH3F* fTPCSignalNormTanSPhi; //-> tpc signal normalized to the mean signal - MC + TH3F* fTPCSignalNormTanTPhi; //-> tpc signal normalized to the mean signal - MC + TH3F* fTPCSignalNormTanSPt; //->tpc signal normalized to the mean signal - MC + + + // + // + TH2F* fPtResolLPT; //-> pt resolution - low pt + TH2F* fPtResolHPT; //-> pt resolution - high pt + TH2F* fPtPullLPT; //-> pt resolution - low pt + TH2F* fPtPullHPT; //-> pt resolution - high pt + // + // Resolution constrained param + // + TH2F *fCPhiResolTan; //-> angular resolution - constrained + TH2F *fCTanResolTan; //-> angular resolution - constrained + TH2F *fCPtResolTan; //-> pt resolution - constrained + TH2F *fCPhiPullTan; //-> angular resolution - constrained + TH2F *fCTanPullTan; //-> angular resolution - constrained + TH2F *fCPtPullTan; //-> pt resolution - constrained + // + // DCA resolution + // + TH3F *fD0TanSPtB1; //-> distance to vertex y + TH3F *fD1TanSPtB1; //-> distance to vertex z + TH3F *fD0TanSPtL1; //-> distance to vertex y + TH3F *fD1TanSPtL1; //-> distance to vertex z + +protected: + ClassDef(AliComparisonDraw,2); +}; + + + + + + + + + + + + + + + +#endif diff --git a/PWG1/TPC/AliComparisonEff.cxx b/PWG1/TPC/AliComparisonEff.cxx new file mode 100644 index 00000000000..1d034ecb9bb --- /dev/null +++ b/PWG1/TPC/AliComparisonEff.cxx @@ -0,0 +1,561 @@ +//------------------------------------------------------------------------------ +// Implementation of AliComparisonEff class. It keeps information from +// comparison of reconstructed and MC particle tracks. In addtion, +// it keeps selection cuts used during comparison. The comparison +// information is stored in the ROOT histograms. Analysis of these +// histograms can be done by using Analyse() class function. The result of +// the analysis (histograms/graphs) are stored in the folder which is +// a data member of AliComparisonEff. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + TFile f("Output.root"); + //AliComparisonEff * compObj = (AliComparisonEff*)f.Get("AliComparisonEff"); + AliComparisonEff * compObj = (AliComparisonEff*)cOutput->FindObject("AliComparisonEff"); + + // Analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderEff" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_Eff.root","recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include +#include + +// +#include "AliESDtrack.h" +#include "AliRecInfoCuts.h" +#include "AliMCInfoCuts.h" +#include "AliLog.h" +#include "AliESDVertex.h" +#include "AliExternalTrackParam.h" +#include "AliTracker.h" +#include "AliMCInfo.h" +#include "AliESDRecInfo.h" +#include "AliComparisonEff.h" + +using namespace std; + +ClassImp(AliComparisonEff) + +//_____________________________________________________________________________ +AliComparisonEff::AliComparisonEff(): + AliComparisonObject("AliComparisonEff"), + + // histograms + + fEffHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // default consttructor +} + +//_____________________________________________________________________________ +AliComparisonEff::AliComparisonEff(Char_t* name="AliComparisonEff",Char_t*title="AliComparisonEff",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE): + AliComparisonObject(name,title), + + // histograms + fEffHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + // + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + + Init(); +} + + +//_____________________________________________________________________________ +AliComparisonEff::~AliComparisonEff() +{ +// destructor + + if(fEffHisto) delete fEffHisto; fEffHisto=0; + + if(fCutsRC) delete fCutsRC; fCutsRC=0; + if(fCutsMC) delete fCutsMC; fCutsMC=0; + + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; +} + +//_____________________________________________________________________________ +void AliComparisonEff::Init() +{ + // Init histograms + // + Int_t nPtBins = 31; + Double_t binsPt[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.}; + Double_t ptMin = 0., ptMax = 10.; + + if(IsHptGenerator() == kTRUE) { + nPtBins = 100; + ptMin = 0.; ptMax = 100.; + } + + //mceta:mcphi:mcpt:pid:isPrim:recStatus:findable + Int_t binsEffHisto[7]={30,90,nPtBins,5,2,2,2}; + Double_t minEffHisto[7]={-1.5,0.,ptMin,0.,0.,0.,0.}; + Double_t maxEffHisto[7]={ 1.5,2.*TMath::Pi(), ptMax,5.,2.,2.,2.}; + + fEffHisto = new THnSparseF("fEffHisto","mceta:mcphi:mcpt:pid:isPrim:recStatus:findable",7,binsEffHisto,minEffHisto,maxEffHisto); + if(!IsHptGenerator()) fEffHisto->SetBinEdges(2,binsPt); + + fEffHisto->GetAxis(0)->SetTitle("eta"); + fEffHisto->GetAxis(1)->SetTitle("phi (rad)"); + fEffHisto->GetAxis(2)->SetTitle("pt (GeV/c)"); + fEffHisto->GetAxis(3)->SetTitle("pid"); + fEffHisto->GetAxis(4)->SetTitle("isPrim"); + fEffHisto->GetAxis(5)->SetTitle("recStatus"); + fEffHisto->GetAxis(6)->SetTitle("findable"); + fEffHisto->Sumw2(); + + // init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderEff","Analysis Efficiency Folder"); +} + +//_____________________________________________________________________________ +void AliComparisonEff::ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC) +{ + // Fill efficiency comparison information + + AliExternalTrackParam *track = 0; + //Double_t field = AliTracker::GetBz(); // nominal Bz field [kG] + Double_t kMaxD = 123456.0; // max distance + Double_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + AliESDVertex vertexMC; // MC primary vertex + + // distance to Prim. vertex + const Double_t* dv = infoMC->GetVDist(); + + Float_t mcpt = infoMC->GetParticle().Pt(); + Float_t mceta = infoMC->GetParticle().Eta(); + Float_t mcphi = infoMC->GetParticle().Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + + Bool_t isPrim = TMath::Sqrt(dv[0]*dv[0] + dv[1]*dv[1])GetMaxR() && TMath::Abs(dv[2])GetMaxVz(); + Bool_t findable = (infoMC->GetRowsWithDigits()>fCutsMC->GetMinRowsWithDigits()); + Bool_t recStatus = kFALSE; + + // calculate and set prim. vertex + vertexMC.SetXv( infoMC->GetParticle().Vx() - dv[0] ); + vertexMC.SetYv( infoMC->GetParticle().Vy() - dv[1] ); + vertexMC.SetZv( infoMC->GetParticle().Vz() - dv[2] ); + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(infoMC->GetParticle().GetPdgCode())) == kFALSE) return; + + // transform Pdg to Pid + // Pdg convension is different for hadrons and leptons + // (e.g. K+/K- = 321/-321; e+/e- = -11/11 ) + Double_t pid = -1; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetEM() ) pid = 0; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetMuM() ) pid = 1; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetPiP() ) pid = 2; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetKP() ) pid = 3; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetProt() ) pid = 4; + + if (infoRC->GetESDtrack() && infoRC->GetESDtrack()->GetTPCInnerParam()) + { + if ((track = new AliExternalTrackParam(*infoRC->GetESDtrack()->GetTPCInnerParam())) != 0) + { + //Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov); + Double_t field[3]; track->GetBxByBz(field); + Bool_t bDCAStatus = track->PropagateToDCABxByBz(&vertexMC,field,kMaxD,dca,cov); + if(bDCAStatus) { + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + recStatus = kTRUE; + } + } + delete track; + } + } + + // Fill histograms + Double_t vEffHisto[7] = { mceta, mcphi, mcpt, pid, isPrim, recStatus, findable }; + fEffHisto->Fill(vEffHisto); +} + +//_____________________________________________________________________________ +void AliComparisonEff::ProcessTPCITS(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC) +{ + // Fill efficiency comparison information + + Int_t clusterITS[200]; + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + + Float_t mcpt = infoMC->GetParticle().Pt(); + Float_t mceta = infoMC->GetParticle().Eta(); + Float_t mcphi = infoMC->GetParticle().Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + + // distance to Prim. vertex + const Double_t* dv = infoMC->GetVDist(); + + Bool_t isPrim = TMath::Sqrt(dv[0]*dv[0] + dv[1]*dv[1])GetMaxR() && TMath::Abs(dv[2])GetMaxVz(); + Bool_t findable = (infoMC->GetRowsWithDigits()>fCutsMC->GetMinRowsWithDigits()); + Bool_t recStatus =kFALSE; + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(infoMC->GetParticle().GetPdgCode())) == kFALSE) return; + + // transform Pdg to Pid + // Pdg convension is different for hadrons and leptons + // (e.g. K+/K- = 321/-321; e+/e- = -11/11 ) + Double_t pid = -1; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetEM() ) pid = 0; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetMuM() ) pid = 1; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetPiP() ) pid = 2; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetKP() ) pid = 3; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetProt() ) pid = 4; + + if(!infoRC->GetESDtrack()) return; + if(infoRC->GetESDtrack()->GetITSclusters(clusterITS)>fCutsRC->GetMinNClustersITS()) + { + infoRC->GetESDtrack()->GetImpactParameters(dca,cov); + if(TMath::Abs(dca[0]) < fCutsRC->GetMaxDCAToVertexXY() && TMath::Abs(dca[1]) < fCutsRC->GetMaxDCAToVertexZ()) + { + recStatus =(infoRC->GetStatus(1)==3); + } + } + + // fill histograms + Double_t vEffHisto[7] = { mceta, mcphi, mcpt, pid, isPrim, recStatus, findable }; + fEffHisto->Fill(vEffHisto); +} + +//_____________________________________________________________________________ +void AliComparisonEff::ProcessConstrained(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC) +{ + // Fill efficiency comparison information + AliExternalTrackParam *track = 0; + //Double_t field = AliTracker::GetBz(); // nominal Bz field [kG] + Double_t kMaxD = 123456.0; // max distance + Double_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + AliESDVertex vertexMC; // MC primary vertex + + // distance to Prim. vertex + const Double_t* dv = infoMC->GetVDist(); + + Float_t mcpt = infoMC->GetParticle().Pt(); + Float_t mceta = infoMC->GetParticle().Eta(); + Float_t mcphi = infoMC->GetParticle().Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + + Bool_t isPrim = TMath::Sqrt(dv[0]*dv[0] + dv[1]*dv[1])GetMaxR() && TMath::Abs(dv[2])GetMaxVz(); + Bool_t findable = (infoMC->GetRowsWithDigits()>fCutsMC->GetMinRowsWithDigits()); + Bool_t recStatus = kFALSE; + + // calculate and set prim. vertex + vertexMC.SetXv( infoMC->GetParticle().Vx() - dv[0] ); + vertexMC.SetYv( infoMC->GetParticle().Vy() - dv[1] ); + vertexMC.SetZv( infoMC->GetParticle().Vz() - dv[2] ); + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(infoMC->GetParticle().GetPdgCode())) == kFALSE) return; + + // transform Pdg to Pid + // Pdg convension is different for hadrons and leptons + // (e.g. K+/K- = 321/-321; e+/e- = -11/11 ) + Double_t pid = -1; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetEM() ) pid = 0; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetMuM() ) pid = 1; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetPiP() ) pid = 2; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetKP() ) pid = 3; + if( TMath::Abs(infoMC->GetParticle().GetPdgCode())==fCutsMC->GetProt() ) pid = 4; + + // constrained parameters resolution + if (!infoRC->GetESDtrack()) return; + const AliExternalTrackParam * cparam = infoRC->GetESDtrack()->GetConstrainedParam(); + if(!cparam) return; + + if ((track = new AliExternalTrackParam(*cparam)) != 0) + { + //Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov); + Double_t field[3]; track->GetBxByBz(field); + Bool_t bDCAStatus = track->PropagateToDCABxByBz(&vertexMC,field,kMaxD,dca,cov); + if(bDCAStatus) { + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + recStatus = (infoRC->GetStatus(1)!=3); + } + } + delete track; + } + + // Fill histograms + Double_t vEffHisto[7] = { mceta, mcphi, mcpt, pid, isPrim, recStatus, findable }; + fEffHisto->Fill(vEffHisto); +} + +//_____________________________________________________________________________ +void AliComparisonEff::Exec(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC) +{ + // Process comparison information + + if(GetAnalysisMode() == 0) ProcessTPC(infoMC,infoRC); + else if(GetAnalysisMode() == 1) ProcessTPCITS(infoMC,infoRC); + else if(GetAnalysisMode() == 2) ProcessConstrained(infoMC,infoRC); + else { + printf("ERROR: AnalysisMode %d \n",fAnalysisMode); + return; + } +} + +//_____________________________________________________________________________ +Long64_t AliComparisonEff::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliComparisonEff* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fEffHisto->Add(entry->fEffHisto); + count++; + } + +return count; +} + +//_____________________________________________________________________________ +void AliComparisonEff::Analyse() +{ + // Analyse comparison information and store output histograms + // in the folder "folderEff" + // + TH1::AddDirectory(kFALSE); + TObjArray *aFolderObj = new TObjArray; + + // efficiency vs pt + fEffHisto->GetAxis(0)->SetRangeUser(-0.9,0.9); // eta range + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // primary tracks + + // rec efficiency vs pt + TH1D *ptAll = fEffHisto->Projection(2); + + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRec = fEffHisto->Projection(2); + ptRec->Divide(ptAll); + ptRec->SetName("ptRecEff"); + + aFolderObj->Add(ptRec); + + + // rec efficiency vs pid vs pt + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions + TH1D *ptAllPi = fEffHisto->Projection(2); + + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRecPi = fEffHisto->Projection(2); + ptRecPi->Divide(ptAllPi); + ptRecPi->SetName("ptRecEffPi"); + + aFolderObj->Add(ptRecPi); + + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons + TH1D *ptAllK = fEffHisto->Projection(2); + + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRecK = fEffHisto->Projection(2); + ptRecK->Divide(ptAllK); + ptRecK->SetName("ptRecEffK"); + + aFolderObj->Add(ptRecK); + + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons + TH1D *ptAllP = fEffHisto->Projection(2); + + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRecP = fEffHisto->Projection(2); + ptRecP->Divide(ptAllP); + ptRecP->SetName("ptRecEffP"); + + aFolderObj->Add(ptRecP); + + // findable efficiency + fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(6)->SetRangeUser(1.,1.); // findable + TH1D *ptAllF = fEffHisto->Projection(2); + + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); + fEffHisto->GetAxis(6)->SetRangeUser(1.,1.); + TH1D *ptRecF = fEffHisto->Projection(2); // rec findable + ptRecF->Divide(ptAllF); + ptRecF->SetName("ptRecFindableEff"); + + aFolderObj->Add(ptRecF); + + // + // efficiency vs eta + // + + fEffHisto->GetAxis(0)->SetRangeUser(-1.5,1.5); // eta range + fEffHisto->GetAxis(2)->SetRangeUser(0.2,10.); // pt range + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // primary tracks + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); // all + fEffHisto->GetAxis(6)->SetRangeUser(0.,1.); // all + + // rec efficiency vs eta + TH1D *etaAll = fEffHisto->Projection(0); + + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRec = fEffHisto->Projection(0); + etaRec->Divide(etaAll); + etaRec->SetName("etaRecEff"); + + aFolderObj->Add(etaRec); + + // rec efficiency vs pid vs eta + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions + TH1D *etaAllPi = fEffHisto->Projection(0); + + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRecPi = fEffHisto->Projection(0); + etaRecPi->Divide(etaAllPi); + etaRecPi->SetName("etaRecEffPi"); + + aFolderObj->Add(etaRecPi); + + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons + TH1D *etaAllK = fEffHisto->Projection(0); + + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRecK = fEffHisto->Projection(0); + etaRecK->Divide(etaAllK); + etaRecK->SetName("etaRecEffK"); + + aFolderObj->Add(etaRecK); + + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons + TH1D *etaAllP = fEffHisto->Projection(0); + + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRecP = fEffHisto->Projection(0); + etaRecP->Divide(etaAllP); + etaRecP->SetName("etaRecEffP"); + + aFolderObj->Add(etaRecP); + + // + // findable efficiency + // + fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(6)->SetRangeUser(1.,1.); // findable + TH1D *etaAllF = fEffHisto->Projection(0); + + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); + fEffHisto->GetAxis(6)->SetRangeUser(1.,1.); + TH1D *etaRecF = fEffHisto->Projection(0); // rec findable + etaRecF->Divide(etaAllF); + etaRecF->SetName("etaRecFindableEff"); + + aFolderObj->Add(etaRecF); + + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TFolder* AliComparisonEff::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliComparisonEff * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + + +//_____________________________________________________________________________ +TFolder* AliComparisonEff::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +// +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} diff --git a/PWG1/TPC/AliComparisonEff.h b/PWG1/TPC/AliComparisonEff.h new file mode 100644 index 00000000000..c56f4611126 --- /dev/null +++ b/PWG1/TPC/AliComparisonEff.h @@ -0,0 +1,85 @@ +#ifndef ALICOMPARISONEFF_H +#define ALICOMPARISONEFF_H + +//------------------------------------------------------------------------------ +// Class to keep information from comparison of +// reconstructed and MC particle tracks (TPC efficiency). +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +class TFile; +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliESD; +class AliRecInfoCuts; +class AliMCInfoCuts; +class TString; +class AliESDVertex; +class TNamed; + +#include "THnSparse.h" +#include "AliComparisonObject.h" + +class AliComparisonEff : public AliComparisonObject { +public : + AliComparisonEff(); + AliComparisonEff(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + ~AliComparisonEff(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC); + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderEff",TString title = "Analysed Efficiency histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray *array=0); + + // Process events + void ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC); + void ProcessTPCITS(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC); + void ProcessConstrained(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC); + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + // Getters + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + THnSparseF* GetEffHisto() const {return fEffHisto;} + +private: + + // Control histograms + THnSparseF *fEffHisto; //-> mceta:mcphi:mcpt:pid:isPrim:recStatus:findable + + // Global cuts objects + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliComparisonEff(const AliComparisonEff&); // not implemented + AliComparisonEff& operator=(const AliComparisonEff&); // not implemented + + ClassDef(AliComparisonEff,1); +}; + +#endif diff --git a/PWG1/TPC/AliComparisonObject.cxx b/PWG1/TPC/AliComparisonObject.cxx new file mode 100644 index 00000000000..eafe75ecebf --- /dev/null +++ b/PWG1/TPC/AliComparisonObject.cxx @@ -0,0 +1,55 @@ +/************************************************************************** +* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +//------------------------------------------------------------------------------ +// Implementation of abstract AliComparisonObject class. It keeps information from +// comparison of reconstructed and MC particle tracks. +// +// Author: J.Otwinowski 14/04/2008 +//------------------------------------------------------------------------------ + +#include + +#include "AliMCInfo.h" +#include "AliESDRecInfo.h" +#include "AliComparisonObject.h" + +using namespace std; + +ClassImp(AliComparisonObject) + +//_____________________________________________________________________________ +AliComparisonObject::AliComparisonObject(): + TNamed("AliComparisonObject","AliComparisonObject"), + fAnalysisMode(-1), + fHptGenerator(kFALSE) +{ + // constructor +} + +//_____________________________________________________________________________ +AliComparisonObject::AliComparisonObject(const char* name, const char* title): + TNamed(name,title), + fAnalysisMode(-1), + fHptGenerator(kFALSE) +{ + // constructor +} + +//_____________________________________________________________________________ +AliComparisonObject::~AliComparisonObject(){ + // destructor +} + diff --git a/PWG1/TPC/AliComparisonObject.h b/PWG1/TPC/AliComparisonObject.h new file mode 100644 index 00000000000..e2038fa0991 --- /dev/null +++ b/PWG1/TPC/AliComparisonObject.h @@ -0,0 +1,59 @@ +#ifndef ALICOMPARISONOBJECT_H +#define ALICOMPARISONOBJECT_H + +//------------------------------------------------------------------------------ +// Abstract class to keep information from comparison of +// reconstructed and MC particle tracks. +// +// Author: J.Otwinowski 04/14/2008 +//------------------------------------------------------------------------------ + +#include "TNamed.h" +#include "TFolder.h" + +class AliMCInfo; +class AliESDRecInfo; + +class AliComparisonObject : public TNamed { +public : + AliComparisonObject(); + AliComparisonObject(const char* name="AliComparisonObject", const char* title="AliComparisonObject"); + virtual ~AliComparisonObject(); + + // Init data members + // call once before event loop + virtual void Init() = 0; + + // Execute analysis + // call in the event loop + virtual void Exec(AliMCInfo* const infoMC=0, AliESDRecInfo* const infoRC=0) = 0; + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list=0) = 0; + + // Analyse output histograms + virtual void Analyse() = 0; + + // Get output folder for analysed histograms + virtual TFolder* GetAnalysisFolder() const = 0; + + // set and get analysisMode + void SetAnalysisMode(Int_t analysisMode=0) {fAnalysisMode = analysisMode;} + Int_t GetAnalysisMode() {return fAnalysisMode;} + + // set and get hpt generator + void SetHptGenerator(Bool_t hptGenerator=kFALSE) {fHptGenerator = hptGenerator;} + Bool_t IsHptGenerator() {return fHptGenerator;} + +protected: + + // analysis mode + Int_t fAnalysisMode; // 0-TPC, 1-TPCITS, 2-Constrained + + // hpt generator + Bool_t fHptGenerator; // hpt event generator + + ClassDef(AliComparisonObject,1); +}; + +#endif diff --git a/PWG1/TPC/AliComparisonRes.cxx b/PWG1/TPC/AliComparisonRes.cxx new file mode 100644 index 00000000000..dc46243ca6c --- /dev/null +++ b/PWG1/TPC/AliComparisonRes.cxx @@ -0,0 +1,574 @@ +//------------------------------------------------------------------------------ +// Implementation of AliComparisonRes class. It keeps information from +// comparison of reconstructed and MC particle tracks. In addtion, +// it keeps selection cuts used during comparison. The comparison +// information is stored in the ROOT histograms. Analysis of these +// histograms can be done by using Analyse() class function. The result of +// the analysis (histograms/graphs) are stored in the folder which is +// a data member of AliComparisonRes. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + + TFile f("Output.root"); + //AliComparisonRes * compObj = (AliComparisonRes*)f.Get("AliComparisonRes"); + AliComparisonRes * compObj = (AliComparisonRes*)cOutput->FindObject("AliComparisonRes"); + + // analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderRes" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_Res.root","recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include "TCanvas.h" +#include "TH1.h" +#include "TAxis.h" + +#include "AliComparisonRes.h" +#include "AliESDRecInfo.h" +#include "AliESDVertex.h" +#include "AliESDtrack.h" +#include "AliLog.h" +#include "AliMCInfo.h" +#include "AliMCInfoCuts.h" +#include "AliRecInfoCuts.h" +#include "AliTracker.h" +#include "AliTreeDraw.h" + +using namespace std; + +ClassImp(AliComparisonRes) + +//_____________________________________________________________________________ +AliComparisonRes::AliComparisonRes(): + AliComparisonObject("AliComparisonRes"), + fResolHisto(0), + fPullHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + //Init(); +} + +//_____________________________________________________________________________ +AliComparisonRes::AliComparisonRes(Char_t* name="AliComparisonRes", Char_t* title="AliComparisonRes",Int_t analysisMode=0,Bool_t hptGenerator=kFALSE): +//AliComparisonRes::AliComparisonRes(Char_t* name, Char_t* title,Int_t analysisMode,Bool_t hptGenerator): + AliComparisonObject(name,title), + fResolHisto(0), + fPullHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + // + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + + Init(); +} + +//_____________________________________________________________________________ +AliComparisonRes::~AliComparisonRes() +{ + // destructor + + if(fResolHisto) delete fResolHisto; fResolHisto=0; + if(fPullHisto) delete fPullHisto; fPullHisto=0; + + if(fCutsRC) delete fCutsRC; fCutsRC=0; + if(fCutsMC) delete fCutsMC; fCutsMC=0; + + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; +} + +//_____________________________________________________________________________ +void AliComparisonRes::Init(){ + + // + // histogram bining + // + + // set pt bins + Int_t nPtBins = 31; + Double_t binsPt[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.}; + Double_t ptMin = 0., ptMax = 10.; + + + if(IsHptGenerator() == kTRUE) { + nPtBins = 100; + ptMin = 0.; ptMax = 100.; + } + + // res_y:res_z:res_phi,res_lambda:res_1pt:y:z:eta:phi:pt + Int_t binsResolHisto[10]={100,100,100,100,100,50,100,30,90,nPtBins}; + Double_t minResolHisto[10]={-1.,-1.,-0.03,-0.03,-0.2,-0.03,-20.,-1.5,0.,ptMin}; + Double_t maxResolHisto[10]={ 1., 1., 0.03, 0.03, 0.2, 0.03, 20., 1.5,2.*TMath::Pi(), ptMax}; + + + fResolHisto = new THnSparseF("fResolHisto","res_y:res_z:res_phi:res_lambda:res_1pt:y:z:eta:phi:pt",10,binsResolHisto,minResolHisto,maxResolHisto); + if(!IsHptGenerator()) fResolHisto->SetBinEdges(9,binsPt); + + fResolHisto->GetAxis(0)->SetTitle("res_y (cm)"); + fResolHisto->GetAxis(1)->SetTitle("res_z (cm)"); + fResolHisto->GetAxis(2)->SetTitle("res_phi (rad)"); + fResolHisto->GetAxis(3)->SetTitle("res_lambda (rad)"); + fResolHisto->GetAxis(4)->SetTitle("res_1pt (GeV/c)^{-1}"); + fResolHisto->GetAxis(5)->SetTitle("y (cm)"); + fResolHisto->GetAxis(6)->SetTitle("z (cm)"); + fResolHisto->GetAxis(7)->SetTitle("eta"); + fResolHisto->GetAxis(8)->SetTitle("phi (rad)"); + fResolHisto->GetAxis(9)->SetTitle("pt (GeV/c)"); + fResolHisto->Sumw2(); + + //pull_y:pull_z:pull_lambda:pull_phi:pull_1pt:y:z:eta:phi:pt + Int_t binsPullHisto[10]={100,100,100,100,100,50,100,30,90,nPtBins}; + Double_t minPullHisto[10]={-5.,-5.,-5.,-5.,-5.,-0.03, -20.,-1.5, 0., ptMin}; + Double_t maxPullHisto[10]={ 5., 5., 5., 5., 5., 0.03, 20., 1.5, 2.*TMath::Pi(),ptMax}; + + fPullHisto = new THnSparseF("fPullHisto","pull_y:pull_z:pull_phi:pull_lambda:pull_1pt:y:z:eta:phi:pt",10,binsPullHisto,minPullHisto,maxPullHisto); + if(!IsHptGenerator()) fPullHisto->SetBinEdges(9,binsPt); + + fPullHisto->GetAxis(0)->SetTitle("res_y (cm)"); + fPullHisto->GetAxis(1)->SetTitle("res_z (cm)"); + fPullHisto->GetAxis(2)->SetTitle("res_phi (rad)"); + fPullHisto->GetAxis(3)->SetTitle("res_lambda (rad)"); + fPullHisto->GetAxis(4)->SetTitle("res_1pt (GeV/c)^{-1}"); + fPullHisto->GetAxis(5)->SetTitle("y (rad)"); + fPullHisto->GetAxis(6)->SetTitle("z (rad)"); + fPullHisto->GetAxis(7)->SetTitle("eta"); + fPullHisto->GetAxis(8)->SetTitle("phi (rad)"); + fPullHisto->GetAxis(9)->SetTitle("pt (GeV/c)"); + fPullHisto->Sumw2(); + + // Init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderRes","Analysis Resolution Folder"); +} + +//_____________________________________________________________________________ +void AliComparisonRes::ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC) +{ + // Fill resolution comparison information + AliExternalTrackParam *track = 0; + //Double_t field = AliTracker::GetBz(); // nominal Bz field [kG] + Double_t kMaxD = 123456.0; // max distance + AliESDVertex vertexMC; // MC primary vertex + + Double_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + + Float_t delta1PtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC, pullYTPC, pullZTPC, pullPhiTPC, pullLambdaTPC; + //Float_t delta1Pt2TPC, deltaY1PtTPC, deltaZ1PtTPC, deltaPhi1PtTPC, deltaTheta1PtTPC; + + Float_t mceta = infoMC->GetParticle().Eta(); + Float_t mcphi = infoMC->GetParticle().Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = infoMC->GetParticle().Pt(); + + // distance to Prim. vertex + const Double_t* dv = infoMC->GetVDist(); + Bool_t isPrim = TMath::Sqrt(dv[0]*dv[0] + dv[1]*dv[1])GetMaxR() && TMath::Abs(dv[2])GetMaxVz(); + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(infoMC->GetParticle().GetPdgCode())) == kFALSE) return; + if (!isPrim) return; + //if (infoRC->GetStatus(1)!=3) return; // TPC refit + if (!infoRC->GetESDtrack()) return; + if (infoRC->GetESDtrack()->GetTPCNcls()GetMinNClustersTPC()) return; + + // calculate and set prim. vertex + vertexMC.SetXv( infoMC->GetParticle().Vx() - dv[0] ); + vertexMC.SetYv( infoMC->GetParticle().Vy() - dv[1] ); + vertexMC.SetZv( infoMC->GetParticle().Vz() - dv[2] ); + + // calculate track parameters at vertex + const AliExternalTrackParam *innerTPC = 0; + if ((innerTPC = infoRC->GetESDtrack()->GetTPCInnerParam()) != 0) + { + if ((track = new AliExternalTrackParam(*infoRC->GetESDtrack()->GetTPCInnerParam())) != 0 ) + { + //Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov); + Double_t field[3]; track->GetBxByBz(field); + Bool_t bDCAStatus = track->PropagateToDCABxByBz(&vertexMC,field,kMaxD,dca,cov); + + // Fill parametrisation histograms (only TPC track) + if(bDCAStatus) + { + // select primaries + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + + deltaYTPC= track->GetY()-infoMC->GetParticle().Vy(); + deltaZTPC = track->GetZ()-infoMC->GetParticle().Vz(); + deltaLambdaTPC = TMath::ATan2(track->Pz(),track->Pt())-TMath::ATan2(infoMC->GetParticle().Pz(),infoMC->GetParticle().Pt()); + deltaPhiTPC = TMath::ATan2(track->Py(),track->Px())-TMath::ATan2(infoMC->GetParticle().Py(),infoMC->GetParticle().Px()); + delta1PtTPC = (track->OneOverPt()-1./mcpt)*mcpt; + + pullYTPC= (track->GetY()-infoMC->GetParticle().Vy()) / TMath::Sqrt(track->GetSigmaY2()); + pullZTPC = (track->GetZ()-infoMC->GetParticle().Vz()) / TMath::Sqrt(track->GetSigmaZ2()); + pullLambdaTPC = deltaLambdaTPC / TMath::Sqrt(track->GetSigmaTgl2()); + pullPhiTPC = deltaPhiTPC / TMath::Sqrt(track->GetSigmaSnp2()); + pull1PtTPC = (track->OneOverPt()-1./mcpt) / TMath::Sqrt(track->GetSigma1Pt2()); + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,delta1PtTPC,infoMC->GetParticle().Vy(),infoMC->GetParticle().Vz(),mceta,mcphi,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,infoMC->GetParticle().Vy(),infoMC->GetParticle().Vz(),mceta,mcphi,mcpt}; + fPullHisto->Fill(vPullHisto); + } + + /* + delta1Pt2TPC = (1/mcpt-innerTPC->OneOverPt())/TMath::Power(1+1/mcpt,2); + deltaY1PtTPC= (infoMC->GetParticle().Vy()-innerTPC->GetY()) / (0.2+1/mcpt); + deltaZ1PtTPC = (infoMC->GetParticle().Vz()-innerTPC->GetZ()) / (0.2+1/mcpt); + deltaPhi1PtTPC = deltaPhiTPC / (0.1+1/mcpt); + deltaTheta1PtTPC = deltaLambdaTPC / (0.1+1/mcpt); + + fPhiEtaPtTPC->Fill(TMath::ATan2(innerTPC->Py(),innerTPC->Px()), innerTPC->Eta(), innerTPC->Pt()); + + f1Pt2ResolS1PtTPC->Fill(s1mcpt,delta1Pt2TPC); + fYResolS1PtTPC->Fill(s1mcpt,deltaY1PtTPC); + fZResolS1PtTPC->Fill(s1mcpt,deltaZ1PtTPC); + fPhiResolS1PtTPC->Fill(s1mcpt,deltaPhi1PtTPC); + fThetaResolS1PtTPC->Fill(s1mcpt,deltaTheta1PtTPC); + + fPtResolPtTPC->Fill(mcpt,deltaPtTPC); + fPtPullPtTPC->Fill(mcpt,pullPtTPC); + fPhiResolEtaTPC->Fill(eta,deltaPhiTPC); + fPhiPullEtaTPC->Fill(eta,pullPhiTPC); + fLambdaResolEtaTPC->Fill(eta,deltaLambdaTPC); + fLambdaPullEtaTPC->Fill(eta,pullLambdaTPC); + */ + } + delete track; + } + } +} + +//_____________________________________________________________________________ +void AliComparisonRes::ProcessTPCITS(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC) +{ + Int_t clusterITS[200]; + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + + Float_t delta1PtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC, pullYTPC, pullZTPC, pullPhiTPC, pullLambdaTPC; + + Float_t mceta = infoMC->GetParticle().Eta(); + Float_t mcphi = infoMC->GetParticle().Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = infoMC->GetParticle().Pt(); + + // distance to Prim. vertex + const Double_t* dv = infoMC->GetVDist(); + Bool_t isPrim = TMath::Sqrt(dv[0]*dv[0] + dv[1]*dv[1])GetMaxR() && TMath::Abs(dv[2])GetMaxVz(); + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(infoMC->GetParticle().GetPdgCode())) == kFALSE) return; + if (!isPrim) return; + if (infoRC->GetStatus(1)!=3) return; // TPC refit + if (!infoRC->GetESDtrack()) return; + if (infoRC->GetESDtrack()->GetTPCNcls()GetMinNClustersTPC()) return; + + infoRC->GetESDtrack()->GetImpactParameters(dca,cov); + + // select primaries + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + deltaYTPC= infoRC->GetESDtrack()->GetY()-infoMC->GetParticle().Vy(); + deltaZTPC = infoRC->GetESDtrack()->GetZ()-infoMC->GetParticle().Vz(); + deltaLambdaTPC = TMath::ATan2(infoRC->GetESDtrack()->Pz(),infoRC->GetESDtrack()->Pt())-TMath::ATan2(infoMC->GetParticle().Pz(),infoMC->GetParticle().Pt()); + deltaPhiTPC = TMath::ATan2(infoRC->GetESDtrack()->Py(),infoRC->GetESDtrack()->Px())-TMath::ATan2(infoMC->GetParticle().Py(),infoMC->GetParticle().Px()); + delta1PtTPC = (infoRC->GetESDtrack()->OneOverPt()-1./mcpt)*mcpt; + + pullYTPC= (infoRC->GetESDtrack()->GetY()-infoMC->GetParticle().Vy()) / TMath::Sqrt(infoRC->GetESDtrack()->GetSigmaY2()); + pullZTPC = (infoRC->GetESDtrack()->GetZ()-infoMC->GetParticle().Vz()) / TMath::Sqrt(infoRC->GetESDtrack()->GetSigmaZ2()); + pullLambdaTPC = deltaLambdaTPC / TMath::Sqrt(infoRC->GetESDtrack()->GetSigmaTgl2()); + pullPhiTPC = deltaPhiTPC / TMath::Sqrt(infoRC->GetESDtrack()->GetSigmaSnp2()); + pull1PtTPC = (infoRC->GetESDtrack()->OneOverPt()-1./mcpt) / TMath::Sqrt(infoRC->GetESDtrack()->GetSigma1Pt2()); + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,delta1PtTPC,infoMC->GetParticle().Vy(),infoMC->GetParticle().Vz(),mceta,mcphi,mcpt}; + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,infoMC->GetParticle().Vy(),infoMC->GetParticle().Vz(),mceta,mcphi,mcpt}; + + // TPC and ITS clusters in the system + if(infoRC->GetESDtrack()->GetITSclusters(clusterITS)>fCutsRC->GetMinNClustersITS()) + { + fResolHisto->Fill(vResolHisto); + fPullHisto->Fill(vPullHisto); + } + } +} + +//_____________________________________________________________________________ +void AliComparisonRes::ProcessConstrained(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC) +{ + // Fill resolution comparison information (constarained parameters) + // + AliExternalTrackParam *track = 0; + //Double_t field = AliTracker::GetBz(); // nominal Bz field [kG] + Double_t kMaxD = 123456.0; // max distance + AliESDVertex vertexMC; // MC primary vertex + + Double_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + + Float_t delta1PtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC, pullYTPC, pullZTPC, pullPhiTPC, pullLambdaTPC; + + Float_t mceta = infoMC->GetParticle().Eta(); + Float_t mcphi = infoMC->GetParticle().Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = infoMC->GetParticle().Pt(); + + // distance to Prim. vertex + const Double_t* dv = infoMC->GetVDist(); + Bool_t isPrim = TMath::Sqrt(dv[0]*dv[0] + dv[1]*dv[1])GetMaxR() && TMath::Abs(dv[2])GetMaxVz(); + + // calculate and set prim. vertex + vertexMC.SetXv( infoMC->GetParticle().Vx() - dv[0] ); + vertexMC.SetYv( infoMC->GetParticle().Vy() - dv[1] ); + vertexMC.SetZv( infoMC->GetParticle().Vz() - dv[2] ); + + // Check selection cuts + if (fCutsMC->IsPdgParticle(TMath::Abs(infoMC->GetParticle().GetPdgCode())) == kFALSE) return; + if (!isPrim) return; + if (infoRC->GetStatus(1)!=3) return; // TPC refit + if (!infoRC->GetESDtrack()) return; + if (infoRC->GetESDtrack()->GetTPCNcls()GetMinNClustersTPC()) return; + + // constrained parameters resolution + const AliExternalTrackParam * cparam = infoRC->GetESDtrack()->GetConstrainedParam(); + if(!cparam) return; + + if ((track = new AliExternalTrackParam(*cparam)) != 0) + { + //Bool_t bDCAStatus = track->PropagateToDCA(&vertexMC,field,kMaxD,dca,cov); + Double_t field[3]; track->GetBxByBz(field); + Bool_t bDCAStatus = track->PropagateToDCABxByBz(&vertexMC,field,kMaxD,dca,cov); + if(bDCAStatus) { + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + deltaYTPC= track->GetY()-infoMC->GetParticle().Vy(); + deltaZTPC = track->GetZ()-infoMC->GetParticle().Vz(); + deltaLambdaTPC = TMath::ATan2(track->Pz(),track->Pt())-TMath::ATan2(infoMC->GetParticle().Pz(),infoMC->GetParticle().Pt()); + deltaPhiTPC = TMath::ATan2(track->Py(),track->Px())-TMath::ATan2(infoMC->GetParticle().Py(),infoMC->GetParticle().Px()); + delta1PtTPC = (track->OneOverPt()-1./mcpt)*mcpt; + + pullYTPC= (track->GetY()-infoMC->GetParticle().Vy()) / TMath::Sqrt(track->GetSigmaY2()); + pullZTPC = (track->GetZ()-infoMC->GetParticle().Vz()) / TMath::Sqrt(track->GetSigmaZ2()); + pullLambdaTPC = deltaLambdaTPC / TMath::Sqrt(track->GetSigmaTgl2()); + pullPhiTPC = deltaPhiTPC / TMath::Sqrt(track->GetSigmaSnp2()); + pull1PtTPC = (track->OneOverPt()-1./mcpt) / TMath::Sqrt(track->GetSigma1Pt2()); + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,delta1PtTPC,infoMC->GetParticle().Vy(),infoMC->GetParticle().Vz(),mceta,mcphi,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,infoMC->GetParticle().Vy(),infoMC->GetParticle().Vz(),mceta,mcphi,mcpt}; + fPullHisto->Fill(vPullHisto); + } + } + delete track; + } +} + +//_____________________________________________________________________________ +void AliComparisonRes::Exec(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC){ + + // Process comparison information + if(GetAnalysisMode() == 0) ProcessTPC(infoMC,infoRC); + else if(GetAnalysisMode() == 1) ProcessTPCITS(infoMC,infoRC); + else if(GetAnalysisMode() == 2) ProcessConstrained(infoMC,infoRC); + else { + printf("ERROR: AnalysisMode %d \n",fAnalysisMode); + return; + } +} + +//_____________________________________________________________________________ +TH1F* AliComparisonRes::MakeResol(TH2F * his, Int_t integ, Bool_t type){ + // Create resolution histograms + + TH1F *hisr, *hism; + if (!gPad) new TCanvas; + hisr = AliTreeDraw::CreateResHistoI(his,&hism,integ); + if (type) return hism; + else + return hisr; +} + +//_____________________________________________________________________________ +void AliComparisonRes::Analyse(){ + // Analyse comparison information and store output histograms + // in the folder "folderRes" + // + TH1::AddDirectory(kFALSE); + TH1F *h=0; + TH2F *h2D=0; + TObjArray *aFolderObj = new TObjArray; + + // write results in the folder + TCanvas * c = new TCanvas("Phi resol Tan","Phi resol Tan"); + c->cd(); + + char name[256]; + char res_title[256] = {"res_y:res_z:res_lambda:res_phi:res_1pt:y:z:eta:phi:pt"} ; + char pull_title[256] = {"pull_y:pull_z:pull_lambda:pull_phi:pull_1pt:y:z:eta:phi:pt"}; + + for(Int_t i=0; i<5; i++) + { + for(Int_t j=5; j<10; j++) + { + if(j==7) fResolHisto->GetAxis(9)->SetRangeUser(0.2,10.); // pt threshold + if(j==9) fResolHisto->GetAxis(7)->SetRangeUser(-0.9,0.9); // eta window + + h2D = (TH2F*)fResolHisto->Projection(i,j); + h = AliComparisonRes::MakeResol(h2D,1,0); + sprintf(name,"h_res_%d_vs_%d",i,j); + h->SetName(name); + h->SetTitle(res_title); + + aFolderObj->Add(h); + + h = AliComparisonRes::MakeResol(h2D,1,1); + sprintf(name,"h_mean_res_%d_vs_%d",i,j); + h->SetName(name); + h->SetTitle(res_title); + + aFolderObj->Add(h); + + if(j==7) fResolHisto->GetAxis(9)->SetRangeUser(0.0,10.); + if(j==9) fResolHisto->GetAxis(7)->SetRangeUser(-1.5,1.5); + + // + if(j==7) fPullHisto->GetAxis(9)->SetRangeUser(0.2,10.); + if(j==9) fPullHisto->GetAxis(7)->SetRangeUser(-0.9,0.9); + + h2D = (TH2F*)fPullHisto->Projection(i,j); + h = AliComparisonRes::MakeResol(h2D,1,0); + sprintf(name,"h_pull_%d_vs_%d",i,j); + h->SetName(name); + h->SetTitle(pull_title); + + aFolderObj->Add(h); + + h = AliComparisonRes::MakeResol(h2D,1,1); + sprintf(name,"h_mean_pull_%d_vs_%d",i,j); + h->SetName(name); + h->SetTitle(pull_title); + + aFolderObj->Add(h); + + if(j==7) fPullHisto->GetAxis(9)->SetRangeUser(0.0,10.); + if(j==9) fPullHisto->GetAxis(7)->SetRangeUser(-1.5,1.5); + } + } + + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TFolder* AliComparisonRes::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliComparisonRes * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + +//_____________________________________________________________________________ +Long64_t AliComparisonRes::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliComparisonRes* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fResolHisto->Add(entry->fResolHisto); + fPullHisto->Add(entry->fPullHisto); + + count++; + } + +return count; +} + +//_____________________________________________________________________________ +TFolder* AliComparisonRes::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +// +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} diff --git a/PWG1/TPC/AliComparisonRes.h b/PWG1/TPC/AliComparisonRes.h new file mode 100644 index 00000000000..78ece0e183f --- /dev/null +++ b/PWG1/TPC/AliComparisonRes.h @@ -0,0 +1,99 @@ +#ifndef ALICOMPARISONRES_H +#define ALICOMPARISONRES_H + +//------------------------------------------------------------------------------ +// Class to keep information from comparison of +// reconstructed and MC particle tracks (TPC resolution). +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +class TString; +class TNamed; +class TCanvas; +class TH1F; +class TH2F; + +class AliESDVertex; +class AliESDtrack; +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliMCInfoCuts; +class AliRecInfoCuts; + +#include "THnSparse.h" +#include "AliComparisonObject.h" + +class AliComparisonRes : public AliComparisonObject { +public : + AliComparisonRes(); + AliComparisonRes(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + virtual ~AliComparisonRes(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCInfo* const infoMC, AliESDRecInfo *const infoRC); + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Process events + void ProcessConstrained(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC); + void ProcessTPC(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC); + void ProcessTPCITS(AliMCInfo* const infoMC, AliESDRecInfo* const infoRC); + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderRes",TString title = "Analysed Resolution histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray * array=0); + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + static TH1F* MakeResol(TH2F * his, Int_t integ, Bool_t type); + + // getters + // + THnSparse *GetResolHisto() const { return fResolHisto; } + THnSparse *GetPullHisto() const { return fPullHisto; } + +private: + // + // Control histograms + // 5 track parameters (details in STEER/AliExternalTrackParam.h) + // + + // resolution histogram + THnSparseF *fResolHisto; //-> res_y:res_z:res_phi:res_lambda:res_1pt:y:z:eta:phi:pt + + // pull histogram + THnSparseF *fPullHisto; //-> pull_y:pull_z:pull_phi:pull_lambda:pull_1pt:y:z:eta:phi:pt + + // Global cuts objects + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliComparisonRes(const AliComparisonRes&); // not implemented + AliComparisonRes& operator=(const AliComparisonRes&); // not implemented + + ClassDef(AliComparisonRes,1); +}; + +#endif diff --git a/PWG1/TPC/AliComparisonTask.cxx b/PWG1/TPC/AliComparisonTask.cxx new file mode 100644 index 00000000000..eb3bb4381b8 --- /dev/null +++ b/PWG1/TPC/AliComparisonTask.cxx @@ -0,0 +1,213 @@ +/************************************************************************** +* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +//------------------------------------------------------------------------------ +// Implementation of the AliComparisonTask class. It compares properties of the +// reconstructed and MC particle tracks under several conditions. +// As the input it requires the tree with AliRecInfo and AliMCInfo branches. Such +// tree can be prepared in advance by runing AliGenInfoMaker and then AliRecInfoMaker +// (details in description of these classes). +// +// The comparison output objects deriving from AliComparisonObject +// (e.g. AliComparisonRes, AliComparisonEff, AliComparisonDEdxA, AliComparisonDCA ...) +// are stored in the output file (details in description of these classes). +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +#include "iostream" + +#include "TChain.h" +#include "TTree.h" +#include "TH1F.h" +#include "TCanvas.h" +#include "TList.h" +#include "TFile.h" + +#include "AliAnalysisTask.h" +#include "AliAnalysisManager.h" +#include "AliESDEvent.h" +#include "AliESDInputHandler.h" +#include "AliESDVertex.h" +#include "AliMagF.h" +#include "AliTracker.h" +#include "AliGeomManager.h" + +#include "AliMCInfo.h" +#include "AliESDRecInfo.h" +#include "AliMCInfoCuts.h" +#include "AliRecInfoCuts.h" +#include "AliComparisonRes.h" +#include "AliComparisonEff.h" +#include "AliComparisonDEdx.h" +#include "AliComparisonDCA.h" +#include "AliComparisonObject.h" +#include "AliComparisonTask.h" + +using namespace std; + +ClassImp(AliComparisonTask) + +Int_t AliComparisonTask::fEvtNumber = 0; + +//_____________________________________________________________________________ +AliComparisonTask::AliComparisonTask(const char *name) + : AliAnalysisTask(name, "") + , fTree(0) + , fInfoMC(0) + , fInfoRC(0) + , fOutput(0) + , fPitList(0) + , fCompList(0) +{ + // Constructor + + // Define input and output slots here + DefineInput(0, TChain::Class()); + DefineOutput(0, TList::Class()); + + // create the list for comparison objects + fCompList = new TList; +} + +//_____________________________________________________________________________ +AliComparisonTask::~AliComparisonTask() +{ + if(fOutput) delete fOutput; fOutput =0; + if(fCompList) delete fCompList; fCompList =0; +} + +//_____________________________________________________________________________ +void AliComparisonTask::ConnectInputData(Option_t *) +{ + // Connect input data + // Called once + + fTree = dynamic_cast (GetInputData(0)); + if (!fTree) { + Printf("ERROR: Could not read chain from input slot 0"); + } else { + fTree->SetBranchStatus("*",1); + } + + if(fTree->GetBranch("MC") && fTree->GetBranch("RC")) { + fTree->GetBranch("MC")->SetAddress(&fInfoMC); + fTree->GetBranch("RC")->SetAddress(&fInfoRC); + } else { + Printf("ERROR: Could not get MC and RC branches"); + } +} + +//_____________________________________________________________________________ +Bool_t AliComparisonTask::AddComparisonObject(AliComparisonObject *pObj) +{ + // add comparison object to the list + if(pObj == 0) { + Printf("ERROR: Could not add comparison object"); + return kFALSE; + } + + // add object to the list + fCompList->AddLast(pObj); + +return kTRUE; +} + +//_____________________________________________________________________________ +void AliComparisonTask::CreateOutputObjects() +{ + // Create histograms + // Called once + + // create output list + fOutput = new TList; + fOutput->SetOwner(); + fPitList = fOutput->MakeIterator(); + + AliComparisonObject *pObj=0; + Int_t count=0; + + // add comparison objects to the output + TIterator *pitCompList = fCompList->MakeIterator(); + pitCompList->Reset(); + while(( pObj = (AliComparisonObject *)pitCompList->Next()) != NULL) { + fOutput->Add(pObj); + count++; + } + Printf("CreateOutputObjects(): Number of output comparison objects: %d \n", count); +} + +//_____________________________________________________________________________ +Bool_t AliComparisonTask::ReadEntry(Int_t evt) +{ +// Read entry from the tree + Long64_t centry = fTree->LoadTree(evt); + if(centry < 0) return kFALSE; + + if(fTree->GetBranch("MC") && fTree->GetBranch("RC")) { + fTree->GetBranch("MC")->SetAddress(&fInfoMC); + fTree->GetBranch("RC")->SetAddress(&fInfoRC); + } else { + Printf("ERROR: Could not get MC and RC branches"); + return kFALSE; + } + fTree->GetEntry(evt); + +return kTRUE; +} +//_____________________________________________________________________________ +void AliComparisonTask::Exec(Option_t *) +{ + // Main loop + // Called for each event + + AliComparisonObject *pObj=0; + + if (!fInfoMC && !fInfoRC) { + Printf("ERROR: fInfoMC && fInfoRC not available"); + return; + } + + // Process comparison + Bool_t status = ReadEntry(fEvtNumber); + if(status == kTRUE) + { + fPitList->Reset(); + while(( pObj = (AliComparisonObject *)fPitList->Next()) != NULL) { + pObj->Exec(fInfoMC,fInfoRC); + } + } + + if( !( fEvtNumber % 10000) ) { + cout << fEvtNumber << endl; + } + fEvtNumber++; + + // Post output data. + PostData(0, fOutput); +} + +//_____________________________________________________________________________ +void AliComparisonTask::Terminate(Option_t *) +{ + // Called one at the end + + // check output data + fOutput = dynamic_cast (GetOutputData(0)); + if (!fOutput) { + Printf("ERROR: AliComparisonTask::Terminate(): Output data not avaiable GetOutputData(0)==0x0 ..." ); + return; + } +} diff --git a/PWG1/TPC/AliComparisonTask.h b/PWG1/TPC/AliComparisonTask.h new file mode 100644 index 00000000000..1c2ed35c2f7 --- /dev/null +++ b/PWG1/TPC/AliComparisonTask.h @@ -0,0 +1,48 @@ +#ifndef ALICOMPARISONRESTASK_H +#define ALICOMPARISONRESTASK_H + +//------------------------------------------------------------------------------ +// Class to compare properties of reconstructed and MC particle tracks. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +class AliComparisonObject; +class AliMagF; +class TList; + +#include "AliAnalysisTask.h" + +class AliComparisonTask : public AliAnalysisTask { + public: + AliComparisonTask(const char *name = "AliComparisonTask"); + virtual ~AliComparisonTask(); + + virtual void ConnectInputData(Option_t *); + virtual void CreateOutputObjects(); + virtual void Exec(Option_t *option); + virtual void Terminate(Option_t *); + + // Read TTree entry (event by event) + Bool_t ReadEntry(Int_t evt); + + // Set comparison objects + Bool_t AddComparisonObject(AliComparisonObject* comp); + + private: + TTree* fTree; //! input tree + AliMCInfo *fInfoMC; //! AliMCInfo object + AliESDRecInfo *fInfoRC; //! AliESDRecInfo object + + TList* fOutput; //! list send on output slot 0 + static Int_t fEvtNumber; //! event number + TIterator *fPitList; //! iterator over the output objetcs + TList *fCompList; // list of comparison objects + + AliComparisonTask(const AliComparisonTask&); // not implemented + AliComparisonTask& operator=(const AliComparisonTask&); // not implemented + + ClassDef(AliComparisonTask, 1); // example of analysis +}; + +#endif diff --git a/PWG1/TPC/AliESDRecInfo.cxx b/PWG1/TPC/AliESDRecInfo.cxx new file mode 100644 index 00000000000..71c38299799 --- /dev/null +++ b/PWG1/TPC/AliESDRecInfo.cxx @@ -0,0 +1,530 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////////// +// // +// Time Projection Chamber // +// Comparison macro for reconstructed tracks // +// responsible: +// marian.ivanov@cern.ch // +// +// + + + + + +//ROOT includes +#include "Rtypes.h" +// +//ALIROOT includes +// +#include "AliESDtrack.h" +#include "AliTracker.h" +#include "AliTPCParam.h" +#include "AliTrackReference.h" +#include "AliTPCParamSR.h" +#include "AliESDfriend.h" +#include "AliESDtrack.h" +#include "AliTPCseed.h" +#include "AliITStrackMI.h" +#include "AliTRDtrackV1.h" +#include "AliMCInfo.h" +#include "AliESDRecInfo.h" + + + +ClassImp(AliESDRecInfo) + + + + +AliTPCParam * GetTPCParam(){ + AliTPCParamSR * par = new AliTPCParamSR; + par->Update(); + return par; +} + + + + +AliESDRecInfo::AliESDRecInfo(): + fITSOn(0), // ITS refitted inward + fTRDOn(0), // ITS refitted inward + fDeltaP(0), //delta of momenta + fSign(0), // sign + fReconstructed(0), //flag if track was reconstructed + fFake(0), // fake track + fMultiple(0), // number of reconstructions + fTPCOn(0), // TPC refitted inward + fBestTOFmatch(0), //best matching between times + fESDtrack(0), // esd track + fTrackF(0), // friend track + fTPCtrack(0), // tpc track + fITStrack(0), // its track + fTRDtrack(0), // trd track + fTracks(0) // array of tracks with the same label +{ + // + // default constructor + // +} + + +AliESDRecInfo::AliESDRecInfo(const AliESDRecInfo& recinfo): + TObject(), + fITSOn(0), // ITS refitted inward + fTRDOn(0), // ITS refitted inward + fDeltaP(0), //delta of momenta + fSign(0), // sign + fReconstructed(0), //flag if track was reconstructed + fFake(0), // fake track + fMultiple(0), // number of reconstructions + fTPCOn(0), // TPC refitted inward + fBestTOFmatch(0), //best matching between times + fESDtrack(0), // esd track + fTrackF(0), // friend track + fTPCtrack(0), // tpc track + fITStrack(0), // its track + fTRDtrack(0), // trd track + fTracks(0) // array of tracks with the same label +{ + // + // + // + memcpy(this,&recinfo, sizeof(recinfo)); + fESDtrack=0; fTrackF=0; fTPCtrack=0;fITStrack=0;fTRDtrack=0; + fTracks=0; + SetESDtrack(recinfo.GetESDtrack()); +} + + +AliESDRecInfo& AliESDRecInfo::operator=(const AliESDRecInfo& info) { + // + // Assignment operator + // + this->~AliESDRecInfo(); + new (this) AliESDRecInfo(info); + return *this; +} + + + +AliESDRecInfo::~AliESDRecInfo() + +{ + // + // destructor + // + if (fESDtrack) { delete fESDtrack; fESDtrack=0;} + if (fTrackF) { fTrackF=0;} + if (fTPCtrack) { delete fTPCtrack; fTPCtrack=0;} + if (fITStrack) { delete fITStrack; fITStrack=0;} + if (fTRDtrack) { delete fTRDtrack; fTRDtrack=0;} + if (fTracks) { + delete fTracks; fTracks=0; + } +} + + + +void AliESDRecInfo::Reset() +{ + // + // reset info + // + fMultiple =0; + fFake =0; + fReconstructed=0; + if (fESDtrack) { delete fESDtrack; fESDtrack=0;} + if (fTrackF) { fTrackF=0;} + if (fTPCtrack) { delete fTPCtrack; fTPCtrack=0;} + if (fITStrack) { delete fITStrack; fITStrack=0;} + if (fTRDtrack) { delete fTRDtrack; fTRDtrack=0;} + if (fTracks) { delete fTracks; fTracks=0;} +} + +void AliESDRecInfo::SetESDtrack(const AliESDtrack *track){ + // + // + // + + if (fESDtrack) delete fESDtrack; + fESDtrack = (AliESDtrack*)track->Clone(); + //AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(fESDtrack->GetID()); + + + if (track->GetFriendTrack()){ + fTrackF = (AliESDfriendTrack*)track->GetFriendTrack(); + Int_t icalib=0; + TObject *cobject=0; + // + while (fTrackF->GetCalibObject(icalib)){ + cobject=fTrackF->GetCalibObject(icalib); + if (dynamic_cast(cobject)){ + if (fTPCtrack) delete fTPCtrack; + fTPCtrack = (AliTPCseed*)(dynamic_cast(cobject))->Clone(); + } else if (dynamic_cast(cobject)){ + if (fTRDtrack) delete fTRDtrack; + fTRDtrack = (AliTRDtrackV1*)(dynamic_cast(cobject))->Clone(); + } + icalib++; + } + } + if (!fTPCtrack) fTPCtrack = new AliTPCseed; // add dummy track +} + + + +void AliESDRecInfo::AddESDtrack(const AliESDtrack *track, AliMCInfo* info){ + // + // Add ESDtrack + // + AliESDtrack *nctrack = (AliESDtrack*) track; + fMultiple++; + if (!fESDtrack) { + SetESDtrack(track); + Update(info,0,kTRUE); + return; + } + if (!fTracks) fTracks = new TClonesArray("AliESDtrack",10); + Int_t ntracks = fTracks->GetEntriesFast(); + new ((*fTracks)[ntracks]) AliESDtrack(*track); + if (nctrack->GetKinkIndex(0)>0) return; + // + // + // + if (!nctrack->IsOn(AliESDtrack::kTPCrefit) && fStatus[1]==2) return; + if (!nctrack->IsOn(AliESDtrack::kITSin) && fStatus[0]>0) return; + if ( nctrack->GetParameter()[4]*info->GetCharge()<0) return; //returning track + + Float_t dtheta = TMath::ATan(nctrack->GetTgl())-info->GetParticle().Theta()-TMath::Pi()-2; + if (TMath::Abs(dtheta)>0.1) return; + + SetESDtrack(track); + Update(info,0,kTRUE); +} + + + +void AliESDRecInfo::UpdatePoints(AliESDtrack*track) +{ + // + // + Int_t iclusters[200]; + Float_t density[160]; + for (Int_t i=0;i<160;i++) density[i]=-1.; + fTPCPoints[0]= 160; + fTPCPoints[1] = -1; + // + if (fTPCPoints[0]GetTPCclusters(iclusters); + + Int_t ngood=0; + Int_t undeff=0; + Int_t nall =0; + Int_t range=20; + for (Int_t i=0;i<160;i++){ + Int_t last = i-range; + if (nall=0){ + if (iclusters[last]>0&& (iclusters[last]&0x8000)==0) ngood--; + if (iclusters[last]==-1) undeff--; + } + if (iclusters[i]>0&& (iclusters[i]&0x8000)==0) ngood++; + if (iclusters[i]==-1) undeff++; + if (nall==range &&undeffmaxdens){ + maxdens=density[i]; + indexmax=i; + } + } + // + //max dens point + fTPCPoints[3] = maxdens; + fTPCPoints[1] = indexmax; + // + // last point + for (Int_t i=indexmax;i<160;i++){ + if (density[i]<0) continue; + if (density[i]0;i--){ + if (density[i]<0) continue; + if (density[i]0;i--){ + if (iclusters[i]==-1) continue; //dead zone + nall++; + if (iclusters[i]>0) ngood++; + if (nall>20) break; + } + fTPCPoints[4] = Float_t(ngood)/Float_t(nall); + // + if ((track->GetStatus()&AliESDtrack::kITSrefit)>0) fTPCPoints[0]=-1; + + +} + +// +// +void AliESDRecInfo::Update(AliMCInfo* info,AliTPCParam * /*par*/, Bool_t reconstructed) +{ + // + //calculates derived variables + // + UpdatePoints(fESDtrack); + UpdateStatus(info,reconstructed); + UpdateITS(info); + UpdateTPC(info); + UpdateTOF(info); +} + + +void AliESDRecInfo::UpdateStatus(AliMCInfo* info, Bool_t reconstructed){ + // + // Interpret bit mask flags + // + for (Int_t i=0;i<4;i++) fStatus[i] =0; + fReconstructed = kFALSE; + fTPCOn = kFALSE; + fITSOn = kFALSE; + fTRDOn = kFALSE; + if (reconstructed==kFALSE) return; + + fLabels[0] = info->fLabel; + fLabels[1] = info->fPrimPart; + fReconstructed = kTRUE; + fTPCOn = ((fESDtrack->GetStatus()&AliESDtrack::kTPCrefit)>0) ? kTRUE : kFALSE; + fITSOn = ((fESDtrack->GetStatus()&AliESDtrack::kITSrefit)>0) ? kTRUE : kFALSE; + fTRDOn = ((fESDtrack->GetStatus()&AliESDtrack::kTRDrefit)>0) ? kTRUE : kFALSE; + // + // + if ((fESDtrack->GetStatus()&AliESDtrack::kTPCrefit)>0){ + fStatus[1] =3; + } + else{ + if ((fESDtrack->GetStatus()&AliESDtrack::kTPCout)>0){ + fStatus[1] =2; + } + else{ + if ((fESDtrack->GetStatus()&AliESDtrack::kTPCin)>0) + fStatus[1]=1; + } + } + // + if ((fESDtrack->GetStatus()&AliESDtrack::kITSout)>0){ + fStatus[0] =2; + } + else{ + if ((fESDtrack->GetStatus()&AliESDtrack::kITSrefit)>0){ + fStatus[0] =1; + } + else{ + fStatus[0]=0; + } + } + // + // + if ((fESDtrack->GetStatus()&AliESDtrack::kTRDrefit)>0){ + fStatus[2] =2; + } + else{ + if ((fESDtrack->GetStatus()&AliESDtrack::kTRDout)>0){ + fStatus[2] =1; + } + } + if ((fESDtrack->GetStatus()&AliESDtrack::kTRDStop)>0){ + fStatus[2] =10; + } +} + +void AliESDRecInfo::UpdateTOF(AliMCInfo* info){ + // + // Update TOF related comparison information + // + fBestTOFmatch=1000; + if (((fESDtrack->GetStatus()&AliESDtrack::kTOFout)>0)){ + // + // best tof match + Double_t times[5]; + fESDtrack->GetIntegratedTimes(times); + for (Int_t i=0;i<5;i++){ + if ( TMath::Abs(fESDtrack->GetTOFsignal()-times[i]) GetTOFsignal()-times[i]; + } + } + Int_t toflabel[3]; + fESDtrack->GetTOFLabel(toflabel); + Bool_t toffake=kTRUE; + Bool_t tofdaughter=kFALSE; + for (Int_t i=0;i<3;i++){ + if (toflabel[i]<0) continue; + if (toflabel[i]== TMath::Abs(fESDtrack->GetLabel())) toffake=kFALSE; + if (toflabel[i]==info->fParticle.GetDaughter(0) || (toflabel[i]==info->fParticle.GetDaughter(1))) tofdaughter=kTRUE; // decay product of original particle + fStatus[3]=1; + } + if (toffake) fStatus[3] =3; //total fake + if (tofdaughter) fStatus[3]=2; //fake because of decay + }else{ + fStatus[3]=0; + } +} + + + +void AliESDRecInfo::UpdateITS(AliMCInfo* info){ + // + // Update ITS related comparison information + // + fITSinP0[0]=info->fParticle.Px(); + fITSinP0[1]=info->fParticle.Py(); + fITSinP0[2]=info->fParticle.Pz(); + fITSinP0[3]=info->fParticle.Pt(); + // + fITSinR0[0]=info->fParticle.Vx(); + fITSinR0[1]=info->fParticle.Vy(); + fITSinR0[2]=info->fParticle.Vz(); + fITSinR0[3] = TMath::Sqrt(fITSinR0[0]*fITSinR0[0]+fITSinR0[1]*fITSinR0[1]); + fITSinR0[4] = TMath::ATan2(fITSinR0[1],fITSinR0[0]); + // + // + if (fITSinP0[3]>0.0000001){ + fITSAngle0[0] = TMath::ATan2(fITSinP0[1],fITSinP0[0]); + fITSAngle0[1] = TMath::ATan(fITSinP0[2]/fITSinP0[3]); + } + if (fITSOn){ + // ITS + Double_t param[5],x; + fESDtrack->GetExternalParameters(x,param); + // fESDtrack->GetConstrainedExternalParameters(x,param); + Double_t cov[15]; + fESDtrack->GetExternalCovariance(cov); + //fESDtrack->GetConstrainedExternalCovariance(cov); + if (TMath::Abs(param[4])<0.0000000001) return; + + fESDtrack->GetXYZ(fITSinR1); + fESDtrack->GetPxPyPz(fITSinP1); + fITSinP1[3] = TMath::Sqrt(fITSinP1[0]*fITSinP1[0]+fITSinP1[1]*fITSinP1[1]); + // + fITSinR1[3] = TMath::Sqrt(fITSinR1[0]*fITSinR1[0]+fITSinR1[1]*fITSinR1[1]); + fITSinR1[4] = TMath::ATan2(fITSinR1[1],fITSinR1[0]); + // + // + if (fITSinP1[3]>0.0000001){ + fITSAngle1[0] = TMath::ATan2(fITSinP1[1],fITSinP1[0]); + fITSAngle1[1] = TMath::ATan(fITSinP1[2]/fITSinP1[3]); + } + // + // + fITSDelta[0] = (fITSinR0[4]-fITSinR1[4])*fITSinR1[3]; //delta rfi + fITSPools[0] = fITSDelta[0]/TMath::Sqrt(cov[0]); + fITSDelta[1] = (fITSinR0[2]-fITSinR1[2]); //delta z + fITSPools[1] = fITSDelta[1]/TMath::Sqrt(cov[2]); + fITSDelta[2] = (fITSAngle0[0]-fITSAngle1[0]); + fITSPools[2] = fITSDelta[2]/TMath::Sqrt(cov[5]); + fITSDelta[3] = (TMath::Tan(fITSAngle0[1])-TMath::Tan(fITSAngle1[1])); + fITSPools[3] = fITSDelta[3]/TMath::Sqrt(cov[9]); + fITSDelta[4] = (fITSinP0[3]-fITSinP1[3]); + Double_t sign = (param[4]>0) ? 1:-1; + fSign = sign; + fITSPools[4] = sign*(1./fITSinP0[3]-1./fITSinP1[3])/TMath::Sqrt(cov[14]); + } +} + +void AliESDRecInfo::UpdateTPC(AliMCInfo* info){ + // + // + // Update TPC related information + // + AliTrackReference * ref = &(info->fTrackRef); + fTPCinR0[0] = info->fTrackRef.X(); + fTPCinR0[1] = info->fTrackRef.Y(); + fTPCinR0[2] = info->fTrackRef.Z(); + fTPCinR0[3] = TMath::Sqrt(fTPCinR0[0]*fTPCinR0[0]+fTPCinR0[1]*fTPCinR0[1]); + fTPCinR0[4] = TMath::ATan2(fTPCinR0[1],fTPCinR0[0]); + // + fTPCinP0[0] = ref->Px(); + fTPCinP0[1] = ref->Py(); + fTPCinP0[2] = ref->Pz(); + fTPCinP0[3] = ref->Pt(); + fTPCinP0[4] = ref->P(); + fDeltaP = (ref->P()-info->fParticle.P())/info->fParticle.P(); + // + // + if (fTPCinP0[3]>0.0000001){ + // + fTPCAngle0[0] = TMath::ATan2(fTPCinP0[1],fTPCinP0[0]); + fTPCAngle0[1] = TMath::ATan(fTPCinP0[2]/fTPCinP0[3]); + } + // + if (fStatus[1]>0 &&info->fNTPCRef>0&&TMath::Abs(fTPCinP0[3])>0.0001){ + //TPC + fESDtrack->GetInnerXYZ(fTPCinR1); + fTPCinR1[3] = TMath::Sqrt(fTPCinR1[0]*fTPCinR1[0]+fTPCinR1[1]*fTPCinR1[1]); + fTPCinR1[4] = TMath::ATan2(fTPCinR1[1],fTPCinR1[0]); + fESDtrack->GetInnerPxPyPz(fTPCinP1); + fTPCinP1[3] = TMath::Sqrt(fTPCinP1[0]*fTPCinP1[0]+fTPCinP1[1]*fTPCinP1[1]); + fTPCinP1[4] = TMath::Sqrt(fTPCinP1[3]*fTPCinP1[3]+fTPCinP1[2]*fTPCinP1[2]); + // + // + if (fTPCinP1[3]>0.000000000000001){ + fTPCAngle1[0] = TMath::ATan2(fTPCinP1[1],fTPCinP1[0]); + fTPCAngle1[1] = TMath::ATan(fTPCinP1[2]/fTPCinP1[3]); + } + Double_t cov[15], param[5],x, alpha; + fESDtrack->GetInnerExternalCovariance(cov); + fESDtrack->GetInnerExternalParameters(alpha, x,param); + if (x<50) return ; + // + fTPCDelta[0] = (fTPCinR0[4]-fTPCinR1[4])*fTPCinR1[3]; //delta rfi + fTPCPools[0] = fTPCDelta[0]/TMath::Sqrt(cov[0]); + fTPCDelta[1] = (fTPCinR0[2]-fTPCinR1[2]); //delta z + fTPCPools[1] = fTPCDelta[1]/TMath::Sqrt(cov[2]); + fTPCDelta[2] = (fTPCAngle0[0]-fTPCAngle1[0]); + fTPCPools[2] = fTPCDelta[2]/TMath::Sqrt(cov[5]); + fTPCDelta[3] = (TMath::Tan(fTPCAngle0[1])-TMath::Tan(fTPCAngle1[1])); + fTPCPools[3] = fTPCDelta[3]/TMath::Sqrt(cov[9]); + fTPCDelta[4] = (fTPCinP0[3]-fTPCinP1[3]); + Double_t sign = (param[4]>0)? 1.:-1; + fSign =sign; + fTPCPools[4] = sign*(1./fTPCinP0[3]-1./fTPCinP1[3])/TMath::Sqrt(TMath::Abs(cov[14])); + } +} + + + + + diff --git a/PWG1/TPC/AliESDRecInfo.h b/PWG1/TPC/AliESDRecInfo.h new file mode 100644 index 00000000000..6af2ee73ebf --- /dev/null +++ b/PWG1/TPC/AliESDRecInfo.h @@ -0,0 +1,100 @@ +#ifndef ALIESDRECINFO_H +#define ALIESDRECINFO_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + + + +////////////////////////////////////////////////////////////////////////////// +// Class AliRecInfo // +// collect together MC info and Rec info for comparison purposes +// - effieciency studies and so on// // +// marian.ivanov@cern.ch // +////////////////////////////////////////////////////////////////////////////// + + +#include "TObject.h" +#include "AliESDkink.h" +class AliESDEvent; +class AliESDtrack; +class AliV0; +class AliESDkink; +class AliESDfriendTrack; +class AliITStrackMI; +class AliTRDtrackV1; +class AliTPCParam; +class AliTPCseed; + +///////////////////////////////////////////////////////////////////////// +class AliESDRecInfo: public TObject { + friend class AliRecInfoMaker; + friend class AliESDRecV0Info; + friend class AliESDRecKinkInfo; + +public: + AliESDRecInfo(); + AliESDRecInfo(const AliESDRecInfo& recinfo); + AliESDRecInfo& operator=(const AliESDRecInfo& info); + ~AliESDRecInfo(); + void Update(AliMCInfo* info,AliTPCParam * par, Bool_t reconstructed); + void UpdateStatus(AliMCInfo* info, Bool_t reconstructed); + void UpdatePoints(AliESDtrack* track); + void UpdateTPC(AliMCInfo* info); + void UpdateITS(AliMCInfo* info); + void UpdateTOF(AliMCInfo* info); + // + void Reset(); + // + void AddESDtrack(const AliESDtrack *track, AliMCInfo* info); + void SetESDtrack(const AliESDtrack *track); + AliESDtrack *GetESDtrack() const { return fESDtrack;} + AliESDfriendTrack *GetTrackF() const { return fTrackF;} + AliTPCseed *GetTPCtrack() const { return fTPCtrack;} + AliITStrackMI *GetITStrack() const { return fITStrack;} + AliTRDtrackV1 *GetTRDtrack() const { return fTRDtrack;} + Int_t GetStatus(Int_t i) { return fStatus[i];} +protected: + // + Float_t fTPCPoints[10]; //start , biggest end points,max density .. density at the last 30 pad-rows + Double_t fTPCinR0[5]; //generated position of the track at inner tpc - radius [3] and fi [4] + Double_t fTPCinR1[5]; //reconstructed postion of the track - radius [3] and fi [ + Double_t fTPCinP0[5]; //generated position of the track at inner tpc + Double_t fTPCinP1[5]; //reconstructed postion of the track + Double_t fTPCAngle0[2]; // generated angle + Double_t fTPCAngle1[2]; //refconstructed angle + Double_t fTPCDelta[5]; // deltas + Double_t fTPCPools[5]; // pools + Double_t fITSinR0[5]; //generated position of the track at inner tpc + Double_t fITSinR1[5]; //reconstructed postion of the track + Double_t fITSinP0[5]; //generated position of the track at inner tpc + Double_t fITSinP1[5]; //reconstructed postion of the track + Double_t fITSAngle0[2]; // generated angle + Double_t fITSAngle1[2]; //refconstructed angle + Double_t fITSDelta[5]; // deltas + Double_t fITSPools[5]; // pools + Float_t fTRLocalCoord[3]; //local coordinates of the track ref. + Int_t fStatus[4]; // status -0 not found - 1 -only in - 2 -in-out -3 -in -out-refit + Int_t fLabels[2]; // labels + + Bool_t fITSOn; // ITS refitted inward + Bool_t fTRDOn; // ITS refitted inward + Float_t fDeltaP; //delta of momenta + Double_t fSign; // sign + Int_t fReconstructed; //flag if track was reconstructed + Int_t fFake; // fake track + Int_t fMultiple; // number of reconstructions + Bool_t fTPCOn; // TPC refitted inward + Float_t fBestTOFmatch; //best matching between times + +private: + AliESDtrack *fESDtrack; // esd track + AliESDfriendTrack *fTrackF; // friend track + AliTPCseed *fTPCtrack; // tpc track + AliITStrackMI *fITStrack; // its track + AliTRDtrackV1 *fTRDtrack; // trd track + TClonesArray *fTracks; // esd tracks array + ClassDef(AliESDRecInfo,2) // container for +}; + + +#endif diff --git a/PWG1/TPC/AliESDRecKinkInfo.cxx b/PWG1/TPC/AliESDRecKinkInfo.cxx new file mode 100644 index 00000000000..1f6819d803a --- /dev/null +++ b/PWG1/TPC/AliESDRecKinkInfo.cxx @@ -0,0 +1,216 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////////// +// // +// Time Projection Chamber // +// Comparison macro for reconstructed tracks - ESDs V0s // +// responsible: +// marian.ivanov@cern.ch // +// +// + + + + + +#include +#include +//ROOT includes +#include "Rtypes.h" +// +//ALIROOT includes +// +#include "AliESDtrack.h" +#include "AliTPCParam.h" +#include "AliTrackReference.h" +#include "AliTPCParamSR.h" +#include "AliESD.h" +#include "AliESDfriend.h" +#include "AliESDtrack.h" +#include "AliTPCseed.h" +#include "AliITStrackMI.h" +#include "AliTRDtrack.h" +#include "AliHelix.h" +#include "AliESDVertex.h" +#include "AliExternalTrackParam.h" +#include "AliESDkink.h" +#include "AliESDv0.h" +#include "AliV0.h" +// +#include "AliTreeDraw.h" +#include "AliMCInfo.h" +#include "AliGenKinkInfo.h" +#include "AliGenV0Info.h" +#include "AliESDRecKinkInfo.h" + + + +ClassImp(AliESDRecKinkInfo) + + + +AliESDRecKinkInfo::AliESDRecKinkInfo(): + fT1(), //track1 + fT2(), //track2 + fKink(), //kink + fDist1(0), //info about closest distance according closest MC - linear DCA + fDist2(0), //info about closest distance parabolic DCA + fInvMass(0), //reconstructed invariant mass - + // + fRr(0), // rec position of the vertex + fMinR(0), // minimum radius in rphi intersection + fDistMinR(0), // distance at minimal radius + fPointAngleFi(0), //point angle fi + fPointAngleTh(0), //point angle theta + fPointAngle(0), //point angle full + fStatus(0), //status -tracks + fRecStatus(0), //kink -status- 0 - not found 1-good - fake + fMultiple(0), // how many times was kink reconstructed + fKinkMultiple(0) // how many times was kink reconstructed +{ + // + // Default constructor + // +} + +//// +void AliESDRecKinkInfo::Update() +{ + + if ( (fT1.fTPCOn)&& (fT2.fTPCOn)){ + // + // IF BOTH RECONSTRUCTED + Float_t distance1,distance2; + Double_t xx[3],pp[3]; + // + Double_t xd[3],pd[3],signd; + Double_t xm[3],pm[3],signm; + for (Int_t i=0;i<3;i++){ + xd[i] = fT2.fTPCinR1[i]; + pd[i] = fT2.fTPCinP1[i]; + xm[i] = fT1.fTPCinR1[i]; + pm[i] = fT1.fTPCinP1[i]; + } + signd = fT2.fSign<0 ? -1:1; + signm = fT1.fSign<0 ? -1:1; + + AliHelix dhelix1(xd,pd,signd); + dhelix1.GetMomentum(0,pp,0); + dhelix1.Evaluate(0,xx); + // + // Double_t x2[3],p2[3]; + // + AliHelix mhelix(xm,pm,signm); + // + //find intersection linear + // + Double_t phase[2][2],radius[2]; + Int_t points = dhelix1.GetRPHIintersections(mhelix, phase, radius,200); + Double_t delta1=10000,delta2=10000; + + if (points==1){ + fMinR = TMath::Sqrt(radius[0]); + } + if (points==2){ + fMinR =TMath::Min(TMath::Sqrt(radius[0]),TMath::Sqrt(radius[1])); + } + + if (points>0){ + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + } + if (points==2){ + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + } + if (points==1){ + fMinR = TMath::Sqrt(radius[0]); + fDistMinR = delta1; + } + if (points==2){ + if (radius[0]0){ + dhelix1.ParabolicDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + } + if (points==2){ + dhelix1.ParabolicDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + } + + distance2 = TMath::Min(delta1,delta2); + if (delta1GetInnerExternalParameters(alpha,x,param); + fT1.GetESDtrack()->GetInnerExternalCovariance(cov); + AliExternalTrackParam paramm(x,alpha,param,cov); + // + fT2.GetESDtrack()->GetInnerExternalParameters(alpha,x,param); + fT2.GetESDtrack()->GetInnerExternalCovariance(cov); + AliExternalTrackParam paramd(x,alpha,param,cov); + /* + AliESDkink kink; + kink.Update(¶mm,¶md); + // kink.Dump(); + Double_t diff = kink.fRr-fRr; + Double_t diff2 = kink.fDist2-fDist2; + printf("Diff\t%f\t%f\n",diff,diff2); + */ + } + + // + // + } + +} + diff --git a/PWG1/TPC/AliESDRecKinkInfo.h b/PWG1/TPC/AliESDRecKinkInfo.h new file mode 100644 index 00000000000..bff45a9b920 --- /dev/null +++ b/PWG1/TPC/AliESDRecKinkInfo.h @@ -0,0 +1,53 @@ +#ifndef ALIESDRECKINKINFO_H +#define ALIESDRECKINKINFO_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + + + +////////////////////////////////////////////////////////////////////////////// +// Class AliRecInfo // +// collect together MC info and Rec info for comparison purposes +// - effieciency studies and so on// // +// marian.ivanov@cern.ch // +////////////////////////////////////////////////////////////////////////////// + + +#include "TObject.h" +#include "AliESDRecInfo.h" + + + +class AliESDRecKinkInfo: public TObject { +friend class AliRecInfoMaker; +public: + AliESDRecKinkInfo(); + void Update(); +protected: + AliESDRecInfo fT1; //track1 + AliESDRecInfo fT2; //track2 + AliESDkink fKink; //kink + Double_t fDist1; //info about closest distance according closest MC - linear DCA + Double_t fDist2; //info about closest distance parabolic DCA + Double_t fInvMass; //reconstructed invariant mass - + // + Double_t fPdr[3]; //momentum at vertex daughter - according approx at DCA + Double_t fXr[3]; //rec. position according helix + // + Double_t fPm[3]; //momentum at the vertex mother + Double_t fAngle[3]; //three angles + Double_t fRr; // rec position of the vertex + Double_t fMinR; // minimum radius in rphi intersection + Double_t fDistMinR; // distance at minimal radius + Int_t fLab[2]; //MC label of the partecle + Float_t fPointAngleFi; //point angle fi + Float_t fPointAngleTh; //point angle theta + Float_t fPointAngle; //point angle full + Int_t fStatus; //status -tracks + Int_t fRecStatus; //kink -status- 0 - not found 1-good - fake + Int_t fMultiple; // how many times was kink reconstructed + Int_t fKinkMultiple; // how many times was kink reconstructed + ClassDef(AliESDRecKinkInfo,1) // container for +}; + +#endif diff --git a/PWG1/TPC/AliESDRecV0Info.cxx b/PWG1/TPC/AliESDRecV0Info.cxx new file mode 100644 index 00000000000..968c1c552fb --- /dev/null +++ b/PWG1/TPC/AliESDRecV0Info.cxx @@ -0,0 +1,392 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////////// +// // +// // +// Comparison class for V0 information // +// responsible: +// marian.ivanov@cern.ch // +// +// + + + + + +#include +#include +//ROOT includes +#include "Rtypes.h" +// +//ALIROOT includes +// +#include "AliESDtrack.h" +#include "AliTPCParam.h" +#include "AliTrackReference.h" +#include "AliTPCParamSR.h" +#include "AliESD.h" +#include "AliESDfriend.h" +#include "AliESDtrack.h" +#include "AliTPCseed.h" +#include "AliITStrackMI.h" +#include "AliTRDtrack.h" +#include "AliHelix.h" +#include "AliESDVertex.h" +#include "AliExternalTrackParam.h" +#include "AliESDkink.h" +#include "AliESDv0.h" +#include "AliV0.h" +#include "AliKFParticle.h" +#include "AliKFVertex.h" +// +#include "AliTreeDraw.h" +#include "AliMCInfo.h" +#include "AliGenKinkInfo.h" +#include "AliGenV0Info.h" + + +#include "AliESDRecV0Info.h" + + + +ClassImp(AliESDRecV0Info) + + +AliESDRecV0Info:: AliESDRecV0Info(): + TObject(), + fT1(), //track1 + fT2(), //track2 + fDist1(0), //info about closest distance according closest MC - linear DCA + fDist2(0), //info about closest distance parabolic DCA + fInvMass(0), //reconstructed invariant mass - + // + fDistMinR(0), // distance at minimal radius + fRr(0), // rec position of the vertex + fPointAngleFi(0), //point angle fi + fPointAngleTh(0), //point angle theta + fPointAngle(0), //point angle full + fV0Status(0), // status of the kink + fV0tpc(0), // Vo information from reconsturction according TPC + fV0its(0), // Vo information from reconsturction according ITS + fV0rec(0), // V0 information form the reconstruction + fV0recOff(0), // V0 information form the reconstruction - OFFLINE + fMultiple(0), // how man times V0 was recostructed + fRecStatus(0), // status form the reconstuction + fV0MultipleOn(0), // how man times was V0 reconstucted + fV0MultipleOff(0), // how man times was V0 reconstucted + // + fKFrecChi2NC(0), // ONLINE V0 finder non constrained chi2 + fKFrecChi2C(0), // ONLINE V0 finder constrained chi2 - prim vertex + fKFrecChi2CM(0), // ONLINE V0 finder constrained chi2 - prim vertex+mass + fKFRecNC(0), // non constrained + fKFRecC(0), // constrained vertex + fKFRecCM(0), // constrained vertex+mass + fKFrecOffChi2NC(0), // OFFLINE V0 finder - non constrained chi2 + fKFrecOffChi2C(0), // OFFLINE V0 finder - constrained chi2 - prim vertex + fKFrecOffChi2CM(0), // OFFLINE V0 finder - constrained chi2 - prim vertex+mass + fKFOffRecNC(0), // non constrained + fKFOffRecC(0), // constrained vertex + fKFOffRecCM(0) // constrained vertex+mass +{ + // + // default constructor + // + fV0tpc = new AliV0(); + fV0its = new AliV0(); + fV0rec = new AliV0(); + fV0recOff = new AliV0(); +} + + +void AliESDRecV0Info::Update(Float_t vertex[3]) +{ + + if ( (fT1.fStatus[1]>0)&& (fT2.fStatus[1]>0)){ + Float_t distance1,distance2; + Double_t xx[3],pp[3]; + // + Double_t xd[3],pd[3],signd; + Double_t xm[3],pm[3],signm; + // + // + if (fT1.fITSOn&&fT2.fITSOn){ + for (Int_t i=0;i<3;i++){ + xd[i] = fT2.fITSinR1[i]; + pd[i] = fT2.fITSinP1[i]; + xm[i] = fT1.fITSinR1[i]; + pm[i] = fT1.fITSinP1[i]; + } + } + else{ + + for (Int_t i=0;i<3;i++){ + xd[i] = fT2.fTPCinR1[i]; + pd[i] = fT2.fTPCinP1[i]; + xm[i] = fT1.fTPCinR1[i]; + pm[i] = fT1.fTPCinP1[i]; + } + } + // + // + signd = fT2.fSign<0 ? -1:1; + signm = fT1.fSign<0 ? -1:1; + + AliHelix dhelix1(xd,pd,signd); + dhelix1.GetMomentum(0,pp,0); + dhelix1.Evaluate(0,xx); + // + // Double_t x2[3],p2[3]; + // + AliHelix mhelix(xm,pm,signm); + // + //find intersection linear + // + Double_t phase[2][2],radius[2]; + Int_t points = dhelix1.GetRPHIintersections(mhelix, phase, radius,200); + Double_t delta1=10000,delta2=10000; + + if (points==1){ + fRs[0] = TMath::Sqrt(radius[0]); + fRs[1] = TMath::Sqrt(radius[0]); + } + if (points==2){ + fRs[0] =TMath::Min(TMath::Sqrt(radius[0]),TMath::Sqrt(radius[1])); + fRs[1] =TMath::Max(TMath::Sqrt(radius[0]),TMath::Sqrt(radius[1])); + } + + if (points>0){ + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + } + if (points==2){ + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + } + if (points==1){ + fRs[0] = TMath::Sqrt(radius[0]); + fRs[1] = TMath::Sqrt(radius[0]); + fDistMinR = delta1; + } + if (points==2){ + if (radius[0]0){ + dhelix1.ParabolicDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + } + if (points==2){ + dhelix1.ParabolicDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + } + + distance2 = TMath::Min(delta1,delta2); + if (distance2>100) fDist2 =100; + return; + if (delta1GetInnerExternalParameters(alpha,x,param); + fT1.GetESDtrack()->GetInnerExternalCovariance(cov); + AliExternalTrackParam paramm(x,alpha,param,cov); + // + fT2.GetESDtrack()->GetInnerExternalParameters(alpha,x,param); + fT2.GetESDtrack()->GetInnerExternalCovariance(cov); + AliExternalTrackParam paramd(x,alpha,param,cov); + } + // + // + + Float_t v[3] = {fXr[0]-vertex[0],fXr[1]-vertex[1],fXr[2]-vertex[2]}; + Float_t p[3] = {fPdr[0]+fPm[0], fPdr[1]+fPm[1],fPdr[2]+fPm[2]}; + + Float_t vnorm2 = v[0]*v[0]+v[1]*v[1]; + Float_t vnorm3 = TMath::Sqrt(v[2]*v[2]+vnorm2); + vnorm2 = TMath::Sqrt(vnorm2); + Float_t pnorm2 = p[0]*p[0]+p[1]*p[1]; + Float_t pnorm3 = TMath::Sqrt(p[2]*p[2]+pnorm2); + pnorm2 = TMath::Sqrt(pnorm2); + + fPointAngleFi = (v[0]*p[0]+v[1]*p[1])/(vnorm2*pnorm2); + fPointAngleTh = (v[2]*p[2]+vnorm2*pnorm2)/(vnorm3*pnorm3); + fPointAngle = (v[0]*p[0]+v[1]*p[1]+v[2]*p[2])/(vnorm3*pnorm3); + } +} + +void AliESDRecV0Info::Reset(){ + // + // Reset status and all counters + // + fDist1=-1; //info about closest distance according closest MC - linear DCA + fDist2=-1; //info about closest distance parabolic DCA + fInvMass=-1; //reconstructed invariant mass - + // + fDistMinR=-1; // distance at minimal radius + fRr=-1; // rec position of the vertex + fLab[0]=-20; //MC label of the partecle + fLab[1]=-10; //MC label of the partecle + fPointAngleFi=0; //point angle fi + fPointAngleTh=0; //point angle theta + fPointAngle=0; //point angle full + // + fV0Status= -100; // status of the V0 + fMultiple=0; // how man times V0 was recostructed + fRecStatus=0; // status form the reconstuction - 1 reconstructed - -1 fake + fV0MultipleOn=0; // how man times was V0 reconstucted - onfly + fV0MultipleOff=0; // how man times was V0 reconstucted - offline + // + // AliKF variables - variables to make a selection + resoluton study + // + fKFrecChi2NC=0; // ONLINE V0 finder non constrained chi2 + fKFrecChi2C=0; // ONLINE V0 finder constrained chi2 - prim vertex + fKFrecChi2CM=0; // ONLINE V0 finder constrained chi2 - prim vertex+mass + // + fKFrecOffChi2NC=0; // OFFLINE V0 finder - non constrained chi2 + fKFrecOffChi2C=0; // OFFLINE V0 finder - constrained chi2 - prim vertex + fKFrecOffChi2CM=0; // OFFLINE V0 finder - constrained chi2 - prim vertex+mass +} + + + +void AliESDRecV0Info::UpdateKF(const AliESDVertex &vertex, Int_t pdg0, Int_t pdg1, Float_t mass){ + // + // Calculate properties of V0 vertex using different type of constraints + // + fKFrecChi2NC=0; // ONLINE V0 finder non constrained chi2 + fKFrecChi2C=0; // ONLINE V0 finder constrained chi2 - prim vertex + fKFrecChi2CM=0; // ONLINE V0 finder constrained chi2 - prim vertex+mass + if (fKFRecNC) {delete fKFRecNC; fKFRecNC=0;} + if (fKFRecC) {delete fKFRecC; fKFRecC=0;} + if (fKFRecCM) {delete fKFRecCM; fKFRecCM=0;} + // + fKFrecOffChi2NC=0; // OFFLINE V0 finder - non constrained chi2 + fKFrecOffChi2C=0; // OFFLINE V0 finder - constrained chi2 - prim vertex + fKFrecOffChi2CM=0; // OFFLINE V0 finder - constrained chi2 - prim vertex+mass + if (fKFOffRecNC) {delete fKFOffRecNC; fKFOffRecNC=0;} + if (fKFOffRecC) {delete fKFOffRecC; fKFOffRecC=0;} + if (fKFOffRecCM) {delete fKFOffRecCM; fKFOffRecCM=0;} + if (fV0Status==0) return; // + // + AliKFVertex primVtx(vertex); + // + if (fV0rec && + TMath::Abs(fV0rec->GetParamN()->GetSigmaY2())>0.000000001&& + TMath::Abs(fV0rec->GetParamP()->GetSigmaY2())>0.000000001 + ){ + // + Double_t x, y, z; + AliKFParticle p1( *(fV0rec->GetParamN()), pdg0 ); + AliKFParticle p2( *(fV0rec->GetParamP()), pdg1 ); + // + fKFRecNC = new AliKFParticle; + fV0rec->GetXYZ(x,y,z); + fKFRecNC->SetVtxGuess(x,y,z); + *(fKFRecNC)+=p1; + *(fKFRecNC)+=p2; + fKFrecChi2NC =fKFRecNC->GetChi2() ; + // + fKFRecC = new AliKFParticle; + fV0rec->GetXYZ(x,y,z); + fKFRecC->SetVtxGuess(x,y,z); + *(fKFRecC)+=p1; + *(fKFRecC)+=p2; + fKFRecC->SetProductionVertex(primVtx); + fKFrecChi2C =fKFRecC->GetChi2(); + // + fKFRecCM = new AliKFParticle; + fV0rec->GetXYZ(x,y,z); + fKFRecCM->SetVtxGuess(x,y,z); + *(fKFRecCM)+=p1; + *(fKFRecCM)+=p2; + fKFRecCM->SetProductionVertex(primVtx); + fKFRecCM->SetMassConstraint(mass); + fKFrecChi2CM =fKFRecCM->GetChi2(); + } + + if (fV0recOff && + TMath::Abs(fV0recOff->GetParamN()->GetSigmaY2())>0.000000001&& + TMath::Abs(fV0recOff->GetParamP()->GetSigmaY2())>0.000000001 + ){ + // + Double_t x, y, z; + AliKFParticle p1( *(fV0recOff->GetParamN()), pdg0 ); + AliKFParticle p2( *(fV0recOff->GetParamP()), pdg1 ); + // + fKFOffRecNC = new AliKFParticle; + fV0recOff->GetXYZ(x,y,z); + fKFOffRecNC->SetVtxGuess(x,y,z); + *(fKFOffRecNC)+=p1; + *(fKFOffRecNC)+=p2; + fKFrecOffChi2NC =fKFOffRecNC->GetChi2() ; + // + fKFOffRecC = new AliKFParticle; + fV0recOff->GetXYZ(x,y,z); + fKFOffRecC->SetVtxGuess(x,y,z); + *(fKFOffRecC)+=p1; + *(fKFOffRecC)+=p2; + fKFOffRecC->SetProductionVertex(primVtx); + fKFrecOffChi2C =fKFOffRecC->GetChi2(); + // + fKFOffRecCM = new AliKFParticle; + fV0recOff->GetXYZ(x,y,z); + fKFOffRecCM->SetVtxGuess(x,y,z); + *(fKFOffRecCM)+=p1; + *(fKFOffRecCM)+=p2; + fKFOffRecCM->SetProductionVertex(primVtx); + fKFOffRecCM->SetMassConstraint(mass); + fKFrecOffChi2CM =fKFOffRecCM->GetChi2(); + } + + +} + + diff --git a/PWG1/TPC/AliESDRecV0Info.h b/PWG1/TPC/AliESDRecV0Info.h new file mode 100644 index 00000000000..d97c106f290 --- /dev/null +++ b/PWG1/TPC/AliESDRecV0Info.h @@ -0,0 +1,83 @@ +#ifndef ALIESDRECV0INFO_H +#define ALIESDRECV0INFO_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + + + +#include "TObject.h" +#include "AliESDRecInfo.h" +class AliESDVertex; +class AliKFParticle; + + + +///////////////////////////////////////////////////////// +///////////////////////////////////////////////////////// +///////////////////////////////////////////////////////// + + +class AliESDRecV0Info: public TObject { + friend class AliRecInfoMaker; +public: + AliESDRecV0Info(); + void Reset(); + void Update(Float_t vertex[3]); + void UpdateKF(const AliESDVertex &vertex, Int_t pdg0, Int_t pdg1, Float_t mass); +protected: + AliESDRecInfo fT1; //track1 + AliESDRecInfo fT2; //track2 + Double_t fDist1; //info about closest distance according closest MC - linear DCA + Double_t fDist2; //info about closest distance parabolic DCA + Double_t fInvMass; //reconstructed invariant mass - + // + Double_t fPdr[3]; //momentum at vertex daughter - according approx at DCA + Double_t fXr[3]; //rec. position according helix + // + Double_t fRs[2]; // minimum radius in rphi intersection + Double_t fDistMinR; // distance at minimal radius + Double_t fPm[3]; //momentum at the vertex mother + Double_t fAngle[3]; //three angles + Double_t fRr; // rec position of the vertex + Int_t fLab[2]; //MC label of the partecle + Float_t fPointAngleFi; //point angle fi + Float_t fPointAngleTh; //point angle theta + Float_t fPointAngle; //point angle full + // + Int_t fV0Status; // status of the V0 + AliV0* fV0tpc; // Vo information from reconsturction according TPC + AliV0* fV0its; // Vo information from reconsturction according ITS + AliV0* fV0rec; // V0 information form the reconstruction + AliV0* fV0recOff; // V0 information form the reconstruction - OFFLINE + Int_t fMultiple; // how man times V0 was recostructed + Int_t fRecStatus; // status form the reconstuction - 1 reconstructed - -1 fake + Int_t fV0MultipleOn; // how man times was V0 reconstucted - onfly + Int_t fV0MultipleOff; // how man times was V0 reconstucted - offline + // + // AliKF variables - variables to make a selection + resoluton study + // + Float_t fKFrecChi2NC; // ONLINE V0 finder non constrained chi2 + Float_t fKFrecChi2C; // ONLINE V0 finder constrained chi2 - prim vertex + Float_t fKFrecChi2CM; // ONLINE V0 finder constrained chi2 - prim vertex+mass + AliKFParticle* fKFRecNC; // non constrained + AliKFParticle* fKFRecC; // constrained vertex + AliKFParticle* fKFRecCM; // constrained vertex+mass + // + Float_t fKFrecOffChi2NC; // OFFLINE V0 finder - non constrained chi2 + Float_t fKFrecOffChi2C; // OFFLINE V0 finder - constrained chi2 - prim vertex + Float_t fKFrecOffChi2CM; // OFFLINE V0 finder - constrained chi2 - prim vertex+mass + AliKFParticle* fKFOffRecNC; // non constrained + AliKFParticle* fKFOffRecC; // constrained vertex + AliKFParticle* fKFOffRecCM; // constrained vertex+mass + + private: + AliESDRecV0Info(const AliESDRecV0Info&); // Not implemented + AliESDRecV0Info& operator=(const AliESDRecV0Info&); // Not implemented + + + ClassDef(AliESDRecV0Info,2) // container for +}; + + + +#endif diff --git a/PWG1/TPC/AliESDresolMakerFast.cxx b/PWG1/TPC/AliESDresolMakerFast.cxx new file mode 100644 index 00000000000..8f45120938d --- /dev/null +++ b/PWG1/TPC/AliESDresolMakerFast.cxx @@ -0,0 +1,223 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + +//************************************************************************ +// +// ESD track and V0 fast resolution parameterization +// Fast algorithm to make parameterization +// Track covariance used +// +// +// Origin: Marian Ivanov marian.ivanov@cern.ch +//------------------------------------------------------------------------- + +/* + EXAMPLE USAGE: + // + // Make esd chain + // + .x ~/rootlogon.C + gSystem->AddIncludePath("-I$ALICE_ROOT/TPC/macros"); + gROOT->LoadMacro("$ALICE_ROOT/TPC/macros/AliXRDPROOFtoolkit.cxx+"); + AliXRDPROOFtoolkit tool; + TChain * tree = tool.MakeChain("esd.txt","esdTree",0,1000); + tree->Lookup(); + // + // Load macros + // + gSystem->Load("libSTAT.so"); + .L $ALICE_ROOT/PWG1/AliESDresolParams.cxx+ + .L $ALICE_ROOT/PWG1/AliESDresolMakerFast.cxx+ + TCut cutDCA="Tracks[].fCchi2<100&&abs(Tracks[].fP[4])<8&&abs(Tracks[].fP[3])<1&&sqrt(Tracks[].fC[0])/(0.2+abs(Tracks[].fP[4]))<0.02&&abs(Tracks[].fX)<3&&Tracks[].fITSncls>4&&Tracks.fTPCncls>40" + // + // Create resolution + // + TObjArray * array = AliESDresolMakerFast::MakeParamPrimFast(tree,cutDCA,0.95,2000); + AliESDresolParams params; + params.SetResolPrimFast(array); + params.SetInstance(¶ms); + TFile f("resolParams.root","recreate"); + param.Write("resolParams"); + // + // + TF2 f2sy("f2sy","AliESDresolParams::SGetResolPrimFast(0,x,y)",0,10,0,2); + TF1 f1sy("f1sy","AliESDresolParams::SGetResolPrimFast(0,x,0)",0,10); + f2sy->Draw("surf2") + f1sy->Draw(); + +*/ + + + +#include "TVectorD.h" +#include "../STAT/TStatToolkit.h" +#include "TMath.h" +#include "TCut.h" +#include "TTree.h" + +#include "AliESDresolParams.h" +#include "AliESDresolMakerFast.h" + + +ClassImp(AliESDresolMakerFast) + + + + +AliESDresolMakerFast::AliESDresolMakerFast() : + TObject() +{ + // + // Default constructor + // +} + + +TObjArray * AliESDresolMakerFast::MakeParamPrimFast(TTree * tree, TCut & cutDCA, Float_t fraction, Int_t entries){ + // + // DCA resolution linear parameterization + // Only valid in ITS acceptance + // Arguments: + // tree - esdTree or chain + // cutDCA - track selection criteria + // fraction - robust fitter fraction + // entries - total number of entries (tracks) used + + /* Example + // its adjusted cuts + + TCut cut1pt= "sqrt(Tracks[].fC[14])/(1+abs(Tracks[].fP[4]))^2.5<0.01"; + TCut cutsy = "sqrt(Tracks[].fC[0])/(0.2+abs(Tracks[].fP[4]))<0.02"; + + TCut cutDCA="Tracks[].fCchi2<100&&abs(Tracks[].fP[4])<8&&abs(Tracks[].fP[3])<1&&abs(Tracks[].fX)<3&&Tracks[].fITSncls>4&&Tracks.fTPCncls>40"+cut1pt+cutsy; + fraction =0.90; + entries = 1000; + */ + + TObjArray *array = new TObjArray(); + Double_t chi2=0; + Int_t npoints=0; + TVectorD fitParam; + TMatrixD covMatrix; + // + // y param + // + TString * dcayParam= TStatToolkit::FitPlane(tree,"sqrt(Tracks[].fC[0])/(0.2+abs(Tracks[].fP[4]))","(abs(Tracks[].fP[4]))++(abs(Tracks[].fP[4]))^2++(abs(Tracks[].fP[3]))++(abs(Tracks[].fP[3]))^2++(abs(Tracks[].fP[4]))*(abs(Tracks[].fP[3]))", cutDCA, chi2,npoints,fitParam,covMatrix,fraction, 0, entries); + tree->SetAlias("dcayParam",dcayParam->Data()); + array->AddAt(new TVectorD(fitParam),0); + printf("Y resol\t%s\n",dcayParam->Data()); + // + // z param + // + TString * dcazParam= TStatToolkit::FitPlane(tree, "sqrt(Tracks[].fC[2])/(0.2+abs(Tracks[].fP[4]))", "(abs(Tracks[].fP[4]))++(abs(Tracks[].fP[4]))^2++(abs(Tracks[].fP[3]))++(abs(Tracks[].fP[3]))^2++(abs(Tracks[].fP[4]))*(abs(Tracks[].fP[3]))", cutDCA, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + printf("Z resol\t%s\n",dcazParam->Data()); + tree->SetAlias("dcazParam",dcazParam->Data()); + array->AddAt(new TVectorD(fitParam),1); + // + // Phi param + // + TString * dcaphiParam= TStatToolkit::FitPlane(tree, "sqrt(Tracks[].fC[5])/(0.1+abs(Tracks[].fP[4]))", "(abs(Tracks[].fP[4]))++(abs(Tracks[].fP[4]))^2++(abs(Tracks[].fP[3]))++(abs(Tracks[].fP[3]))^2++(abs(Tracks[].fP[4]))*(abs(Tracks[].fP[3]))", cutDCA, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + printf("Phi resol\t%s\n",dcaphiParam->Data()); + tree->SetAlias("dcaphiParam",dcaphiParam->Data()); + array->AddAt(new TVectorD(fitParam),2); + // + // theta param + // + TString * dcathParam= TStatToolkit::FitPlane(tree, "sqrt(Tracks[].fC[9])/((0.1+abs(Tracks[].fP[4])*(1+abs(Tracks[].fParamP.fP[3]^2))))", "(abs(Tracks[].fP[4]))++(abs(Tracks[].fP[4]))^2++(abs(Tracks[].fP[3]))++(abs(Tracks[].fP[3]))^2++(abs(Tracks[].fP[4]))*(abs(Tracks[].fP[3]))", cutDCA, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + printf("Theta resol\t%s\n",dcathParam->Data()); + tree->SetAlias("dcathParam",dcathParam->Data()); + array->AddAt(new TVectorD(fitParam),3); + // + // 1pt param + // + TString * dca1ptParam= TStatToolkit::FitPlane(tree, "sqrt(Tracks[].fC[14])/(1+abs(Tracks[].fP[4]))^2", "(abs(Tracks[].fP[4]))++(abs(Tracks[].fP[4]))^2++(abs(Tracks[].fP[3]))++(abs(Tracks[].fP[3]))^2++(abs(Tracks[].fP[4]))*(abs(Tracks[].fP[3]))", cutDCA, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + printf("1pt resol\t%s\n",dca1ptParam->Data()); + tree->SetAlias("dca1ptParam",dca1ptParam->Data()); + array->AddAt(new TVectorD(fitParam),4); + return array; +} + +/* +void scalePt(){ + // + TString * dca1ptParamS4= TStatToolkit::FitPlane(tree, "(Tracks[].fC[14])", "abs(Tracks[].fP[4])^4", cutDCA, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + printf("1pt resol\t%s\n",dca1ptParamS4->Data()); + tree->SetAlias("dca1ptParam4",dca1ptParamS4->Data()); + // + TString * dca1ptParamS34= TStatToolkit::FitPlane(tree, "(Tracks[].fC[14])", "abs(Tracks[].fP[4])^4++abs(Tracks[].fP[4])^3", cutDCA, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + printf("1pt resol\t%s\n",dca1ptParamS34->Data()); + tree->SetAlias("dca1ptParam34",dca1ptParamS34->Data()); + // + TString * dca1ptParamS234= TStatToolkit::FitPlane(tree, "(Tracks[].fC[14])", "abs(Tracks[].fP[4])^4++abs(Tracks[].fP[4])^3++abs(Tracks[].fP[4])^2", cutDCA, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + printf("1pt resol\t%s\n",dca1ptParamS234->Data()); + tree->SetAlias("dca1ptParam234",dca1ptParamS234->Data()); +} + +*/ + + + + + + +TObjArray * AliESDresolMakerFast::MakeParamRFast(TTree * tree, TCut &cutV0, Float_t fraction, Int_t entries){ + // + // + // + TObjArray *array = new TObjArray; + + Double_t chi2=0; + Int_t npoints=0; + TVectorD fitParam; + TMatrixD covMatrix; + // + // + /* + //TCut cutGood="abs(V0s[].GetEffMass(0,0))<0.05||abs(V0s[].GetEffMass(2,2)-0.5)<0.05" + TCut cutV0 = "abs((V0s[].fParamP.fC[0]))<3&&abs(V0s[].fParamP.fP[3])<1&&abs(V0s[].fParamP.fP[4])<8";// + */ + // + // + // + TString * v0sigmaY= TStatToolkit::FitPlane(tree,"sqrt(sqrt((V0s[].fParamP.fC[0]))/(0.2+abs(V0s[].fParamP.fP[4])))","abs(V0s[].fParamP.fP[4])++V0s[].fParamP.fX++abs(V0s[].fParamP.fP[4])^2++V0s[].fParamP.fX^2++abs(V0s[].fParamP.fP[4])*V0s[].fParamP.fX++abs(V0s[].fParamP.fP[4])*V0s[].fParamP.fX^2", cutV0, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + tree->SetAlias("v0sigmaY",v0sigmaY->Data()); + array->AddAt(new TVectorD(fitParam),0); + // + // + // + TString * v0sigmaZ= TStatToolkit::FitPlane(tree,"sqrt(sqrt((V0s[].fParamP.fC[2])))","abs(V0s[].fParamP.fP[4])++V0s[].fParamP.fX++abs(V0s[].fParamP.fP[4])^2++V0s[].fParamP.fX^2++abs(V0s[].fParamP.fP[4])*V0s[].fParamP.fX++abs(V0s[].fParamP.fP[4])*V0s[].fParamP.fX^2", cutV0, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + tree->SetAlias("v0sigmaZ",v0sigmaZ->Data()); + array->AddLast(new TVectorD(fitParam)); + // + // + // + TString * v0sigmaPhi= TStatToolkit::FitPlane(tree,"sqrt(sqrt((V0s[].fParamP.fC[5]))/(0.1+abs(V0s[].fParamP.fP[4])))","abs(V0s[].fParamP.fP[4])++V0s[].fParamP.fX++abs(V0s[].fParamP.fP[4])^2++abs(V0s[].fParamP.fP[4])*V0s[].fParamP.fX", cutV0, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + tree->SetAlias("v0sigmaPhi",v0sigmaPhi->Data()); + array->AddAt(new TVectorD(fitParam),2); + // + // + // + TString * v0sigmaTh= TStatToolkit::FitPlane(tree,"sqrt(sqrt((V0s[].fParamP.fC[9]))/((0.1+abs(V0s[].fParamP.fP[4])*(1+abs(V0s[].fParamP.fP[3])^2))))","abs(V0s[].fParamP.fP[4])++V0s[].fParamP.fX++abs(V0s[].fParamP.fP[4])^2++abs(V0s[].fParamP.fP[4])*V0s[].fParamP.fX", cutV0, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + tree->SetAlias("v0sigmaTh",v0sigmaTh->Data()); + array->AddAt(new TVectorD(fitParam),3); + // + // + // + TString * v0sigma1pt= TStatToolkit::FitPlane(tree,"sqrt(sqrt((V0s[].fParamP.fC[14])))","abs(V0s[].fParamP.fP[4])++V0s[].fParamP.fX++abs(V0s[].fParamP.fP[4])^2++V0s[].fParamP.fX^2++abs(V0s[].fParamP.fP[4])*V0s[].fParamP.fX++abs(V0s[].fParamP.fP[4])*V0s[].fParamP.fX^2", cutV0, chi2,npoints,fitParam,covMatrix,fraction,0,entries); + tree->SetAlias("v0sigma1pt",v0sigma1pt->Data()); + array->AddAt(new TVectorD(fitParam),4); + return array; + +} diff --git a/PWG1/TPC/AliESDresolMakerFast.h b/PWG1/TPC/AliESDresolMakerFast.h new file mode 100644 index 00000000000..34983001c9d --- /dev/null +++ b/PWG1/TPC/AliESDresolMakerFast.h @@ -0,0 +1,33 @@ +#ifndef ALIESDRESOLMAKERFAST_H +#define ALIESDRESOLMAKERFAST_H + +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +//------------------------------------------------------------------------- +// ESD tracks and V0 resolution parameterization maker +// +// Origin: Marian Ivanov marian.ivanov@cern.ch +//------------------------------------------------------------------------- + +#include "TObject.h" +#include +class TTree; +class TObjArray; +class TCut; +// +class AliESDresolMakerFast : public TObject{ + public: + AliESDresolMakerFast(); + // + static TObjArray * MakeParamPrimFast(TTree * tree, TCut &cutDCA, Float_t fraction=-1, Int_t entries=100000); + static TObjArray * MakeParamRFast(TTree * tree, TCut &cutV0, Float_t fraction=-1, Int_t entries=100000); + // protected: + public: + // + ClassDef(AliESDresolMakerFast,1) // ESD resolution parametereization +}; + + + +#endif diff --git a/PWG1/TPC/AliESDresolParams.cxx b/PWG1/TPC/AliESDresolParams.cxx new file mode 100644 index 00000000000..5ed9ab484e2 --- /dev/null +++ b/PWG1/TPC/AliESDresolParams.cxx @@ -0,0 +1,174 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + +//************************************************************************ +// +// ESD track and V0 resolution parameterization +// +// +// Origin: Marian Ivanov marian.ivanov@cern.ch +//------------------------------------------------------------------------- + +/* + The track parameter resolution is determined by the intrinsic detector + resolution and by the multiple scattering and fluctuation of the energy + loss in the material. + + The contribution from the intrinsic detector resolution is independent of + the particle momenta and the mass of particle. In the limit limit of infinite + momenta - zero curvature, the intrinsic detector resolution can be obtained. + + Multiple effect scaling: + + SCATERING ANGLE - fi, theta + sigma A += sqrt(14.1*14.1/(beta2*p2*1e6)*TMath::Abs(xOverX0)); + sigma A ~ 1/p + sigma sfi += sigma A * sqrt((1-sfi^2) * (1+ tth^2)) + sigma tth += sigma A * (1+tth^2) + + MOMENTUM Pt: + sigma 1/pt = sigma A * 1/pt * tth + sigma 1/pt ~ (1/pt)^2 + + POSITION y, z: + sigma y +~ sigma A * eff length (between update measurements) ~ 1/pt + sigma z +~ sigma A * eff length (between update measurements) ~ 1/pt + Example usage: + + +*/ + + +#include "TVectorD.h" +#include "TMath.h" +#include "TObjArray.h" +#include "AliESDresolParams.h" + + +ClassImp(AliESDresolParams) + + + AliESDresolParams* AliESDresolParams::fgInstance = 0x0; //! Instance of this class (singleton implementation) + + +AliESDresolParams::AliESDresolParams() : + TObject(), + fResolDCAyy(0), // resolution Y parameterization + fResolDCAzz(0), // resolution Z parameterization + fResolDCAphi(0), // resolution phi parameterization - pt-theta + fResolDCAth(0), // resolution theta parameterization -pt-theta + fResolDCA1pt(0), // resolution 1/pt parameterization - pt-theta + // + fResolCyy(0), // DCA resolution Y parameterization - r-pt + fResolCzz(0), // DCA resolution Z parameterization - r-pt + fResolCphi(0), // DCA resolution phi parameterization - r-pt + fResolCth(0), // DCA resolution theta parameterization - r-pt + fResolC1pt(0) // DCA resolution 1/pt parameterization - r-pt +{ + // + // Default constructor + // +} + +Double_t AliESDresolParams::GetResolPrimFast(Int_t param, Float_t onept, Float_t tanth) const { + // + // Resolution at primary vertex + // simple Resolution parameterization + // polynom of second order in 2D + // + if (!fResolDCAyy) return 0; + TVectorD * pvec = fResolDCAyy; + if (param==1) pvec = fResolDCAzz; + if (param==2) pvec = fResolDCAphi; + if (param==3) pvec = fResolDCAth; + if (param==4) pvec = fResolDCA1pt; + TVectorD &vec = *pvec; + // + Float_t val = vec[0]; + val+= vec[1]*TMath::Abs(onept); + val+= vec[2]*TMath::Abs(onept*onept); + val+= vec[3]*TMath::Abs(tanth); + val+= vec[4]*TMath::Abs(tanth*tanth); + val+= vec[5]*TMath::Abs(onept*tanth); + Float_t shift1pt=0; + if (param==0 || param==1) shift1pt=0.2; + if (param==2 || param==3) shift1pt=0.1; + if (param==4) shift1pt=1.; + val*= (onept+shift1pt); + if (param==4) val*=(onept+shift1pt); + return val; +} + +Double_t AliESDresolParams::GetResolRFast(Int_t param, Float_t onept, Float_t radius) const { + // + // simple DCA resolution parameterization + // polynom of second order in 2D + // + if (!fResolCyy) return 0; + TVectorD * pvec = fResolCyy; + if (param==1) pvec = fResolCzz; + if (param==2) pvec = fResolCphi; + if (param==3) pvec = fResolCth; + if (param==4) pvec = fResolC1pt; + TVectorD &vec = *pvec; + // + Float_t val = vec[0]; + val+= vec[1]*TMath::Abs(onept); + val+= vec[2]*TMath::Abs(radius); + val+= vec[3]*TMath::Abs(onept*onept); + val+= vec[4]*TMath::Abs(radius*radius); + val+= vec[5]*TMath::Abs(radius*onept); + val+= vec[6]*TMath::Abs(radius*radius*onept); + val*=val; + return val; +} + +void AliESDresolParams::SetResolPrimFast(TObjArray* array){ + // + // Set parameters - resolution at prim vertex + // + if (!array) return; + if (array->At(0)) + fResolDCAyy = new TVectorD(*((TVectorD*)array->At(0))); + if (array->At(1)) + fResolDCAzz = new TVectorD(*((TVectorD*)array->At(1))); + if (array->At(2)) + fResolDCAphi = new TVectorD(*((TVectorD*)array->At(2))); + if (array->At(3)) + fResolDCAth = new TVectorD(*((TVectorD*)array->At(3))); + if (array->At(4)) + fResolDCA1pt = new TVectorD(*((TVectorD*)array->At(4))); +} + +void AliESDresolParams::SetResolRFast(TObjArray* array){ + // + // Set parameters - resolution at prim vertex + // + if (!array) return; + if (array->At(0)) + fResolCyy = new TVectorD(*((TVectorD*)array->At(0))); + if (array->At(1)) + fResolCzz = new TVectorD(*((TVectorD*)array->At(1))); + if (array->At(2)) + fResolCphi = new TVectorD(*((TVectorD*)array->At(2))); + if (array->At(3)) + fResolCth = new TVectorD(*((TVectorD*)array->At(3))); + if (array->At(4)) + fResolC1pt = new TVectorD(*((TVectorD*)array->At(4))); +} + + + + diff --git a/PWG1/TPC/AliESDresolParams.h b/PWG1/TPC/AliESDresolParams.h new file mode 100644 index 00000000000..c86bd9e6344 --- /dev/null +++ b/PWG1/TPC/AliESDresolParams.h @@ -0,0 +1,52 @@ +#ifndef ALIESDRESOLPARAMS_H +#define ALIESDRESOLPARAMS_H + +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +//------------------------------------------------------------------------- +// ESD tracks and V0 resolution parameterization +// +// Origin: Marian Ivanov marian.ivanov@cern.ch +//------------------------------------------------------------------------- + +#include "TObject.h" +#include +class TTree; + +class AliESDresolParams : public TObject{ + public: + AliESDresolParams(); + void SetInstance(AliESDresolParams *param){fgInstance = param;} + // + Double_t GetResolPrimFast(Int_t param, Float_t onept, Float_t tanth) const; + Double_t GetResolRFast(Int_t param, Float_t onept, Float_t radius) const; + // + static Double_t SGetResolPrimFast(Int_t sdim, Float_t onept, Float_t tanth){ return fgInstance->GetResolPrimFast(sdim,onept,tanth);} + static Double_t SGetResolRFast(Int_t param, Float_t onept, Float_t radius){ return fgInstance->GetResolRFast(param,onept,radius);} + void SetResolPrimFast(TObjArray* array); + void SetResolRFast(TObjArray* array); + // protected: + public: + //Resolution at prim vertex + TVectorD *fResolDCAyy; // resolution Y parameterization + TVectorD *fResolDCAzz; // resolution Z parameterization + TVectorD *fResolDCAphi; // resolution phi parameterization - pt-theta + TVectorD *fResolDCAth; // resolution theta parameterization -pt-theta + TVectorD *fResolDCA1pt; // resolution 1/pt parameterization - pt-theta + // + // Resolution at V0 - radial dependent + // + TVectorD *fResolCyy; // resolution Y parameterization - r-pt + TVectorD *fResolCzz; // resolution Z parameterization - r-pt + TVectorD *fResolCphi; // resolution phi parameterization - r-pt + TVectorD *fResolCth; // resolution theta parameterization - r-pt + TVectorD *fResolC1pt; // resolution 1/pt parameterization - r-pt + // + static AliESDresolParams* fgInstance; //! Instance of this class (singleton implementation) + ClassDef(AliESDresolParams,1) // ESD resolution parametereization +}; + + + +#endif diff --git a/PWG1/TPC/AliGenInfoMaker.cxx b/PWG1/TPC/AliGenInfoMaker.cxx new file mode 100644 index 00000000000..1ba1572c7e1 --- /dev/null +++ b/PWG1/TPC/AliGenInfoMaker.cxx @@ -0,0 +1,813 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////// +/* + +Origin: marian.ivanov@cern.ch + +Generate complex MC information - used for Comparison later on +How to use it? + + +---Usage outside of the analysis framework + +gSystem->Load("libANALYSIS.so") +gSystem->Load("libPWG1.so") +AliGenInfoMaker *t = new AliGenInfoMaker("galice.root","genTracks.root",0,0) +t->Exec(); + +*/ + +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +#include +//ROOT includes +#include "TROOT.h" +#include "Rtypes.h" +#include "TFile.h" +#include "TTree.h" +#include "TStopwatch.h" +#include "TParticle.h" +#include "TDatabasePDG.h" + +//ALIROOT includes +#include "AliMCEvent.h" +#include "AliMCEventHandler.h" + +#include "AliRun.h" +#include "AliStack.h" +#include "AliSimDigits.h" +#include "AliTPCParam.h" +#include "AliTPC.h" +#include "AliTPCLoader.h" +#include "AliTrackReference.h" +#include "AliTPCParamSR.h" +#include "AliTrackPointArray.h" + +#endif +#include "AliMCInfo.h" +#include "AliGenV0Info.h" +#include "AliGenKinkInfo.h" +#include "AliGenInfoMaker.h" +// +// + +ClassImp(AliGenInfoMaker) + + + + + + + +//////////////////////////////////////////////////////////////////////// +AliGenInfoMaker::AliGenInfoMaker(): + fGenTracksArray(0), //clones array with filtered particles + fGenKinkArray(0), //clones array with filtered Kinks + fGenV0Array(0), //clones array with filtered V0s + fDebug(0), //! debug flag + fEventNr(0), //! current event number + fLabel(0), //! track label + fNEvents(0), //! number of events to process + fFirstEventNr(0), //! first event to process + fNParticles(0), //! number of particles in TreeK + fTreeGenTracks(0), //! output tree with generated tracks + fTreeKinks(0), //! output tree with Kinks + fTreeV0(0), //! output tree with V0 + fFileGenTracks(0), //! output file with stored fTreeGenTracks + fLoader(0), //! pointer to the run loader + fTreeD(0), //! current tree with digits + fTreeTR(0), //! current tree with TR + fStack(0), //! current stack + fGenInfo(0), //! array with pointers to gen info + fNInfos(0), //! number of tracks with infos + fParamTPC(0), //! AliTPCParam + fTPCPtCut(0.1), // TPC pt cut + fITSPtCut(0.1), // ITS pt cut + fTRDPtCut(0.1), // TRD pt cut + fTOFPtCut(0.1) // TOF pt cut +{ + sprintf(fFnRes,"%s","genTracks.root"); +} + + + + +//////////////////////////////////////////////////////////////////////// +AliGenInfoMaker::AliGenInfoMaker(const char * fnGalice, const char* fnRes, + Int_t nEvents, Int_t firstEvent): + fGenTracksArray(0), //clones array with filtered particles + fGenKinkArray(0), //clones array with filtered Kinks + fGenV0Array(0), //clones array with filtered V0s + fDebug(0), //! debug flag + fEventNr(0), //! current event number + fLabel(0), //! track label + fNEvents(0), //! number of events to process + fFirstEventNr(0), //! first event to process + fNParticles(0), //! number of particles in TreeK + fTreeGenTracks(0), //! output tree with generated tracks + fTreeKinks(0), //! output tree with Kinks + fTreeV0(0), //! output tree with V0 + fFileGenTracks(0), //! output file with stored fTreeGenTracks + fLoader(0), //! pointer to the run loader + fTreeD(0), //! current tree with digits + fTreeTR(0), //! current tree with TR + fStack(0), //! current stack + fGenInfo(0), //! array with pointers to gen info + fNInfos(0), //! number of tracks with infos + fParamTPC(0), //! AliTPCParam + fTPCPtCut(0.1), + fITSPtCut(0.1), + fTRDPtCut(0.1), + fTOFPtCut(0.1) +{ + // + // + // + fFirstEventNr = firstEvent; + fEventNr = firstEvent; + fNEvents = nEvents; + sprintf(fFnRes,"%s",fnRes); + // + // + // + fLoader = AliRunLoader::Open(fnGalice); + if (gAlice){ + delete AliRunLoader::Instance(); + delete gAlice; + gAlice = 0x0; + } + if (fLoader->LoadgAlice()){ + cerr<<"Error occured while l"<GetNumberOfEvents(); + if (nEvents==0) { + nEvents =nall; + fNEvents=nall; + fFirstEventNr=0; + } + + if (nall<=0){ + cerr<<"no events available"<nall) { + fEventNr = nall-firstEvent; + cerr<<"restricted number of events availaible"<UnloadgAlice(); + gAlice = 0; + delete fLoader; + } +} + + +AliMCInfo * AliGenInfoMaker::MakeInfo(UInt_t i) +{ + // + // Make info structure for given particle index + // + if (iMCEvent()->Stack(); + fTreeTR = mcinfo->TreeTR(); + fTreeD = 0; + // array with preprocessedprocessed information + fGenTracksArray = new TObjArray; + fGenKinkArray = new TObjArray; + fGenV0Array = new TObjArray; + // + ProcessEvent(); + fEventNr++; + return 0; +} + + + +Int_t AliGenInfoMaker::ProcessEvent(){ + // + // Process Event + // + fNParticles = fStack->GetNtrack(); + // + fGenInfo = new AliMCInfo*[fNParticles]; + for (UInt_t i = 0; i0) return 1; + // + if (fDebug>2) cout<<"\n\n\n\tStart loop over TreeD"<0) return 1; + // + if (fDebug>2) cout<<"\n\n\n\tStart loop over TreeK"<0) return 1; + if (fDebug>2) cout<<"\tEnd loop over TreeK"<0) return 1; + if (BuildV0Info()>0) return 1; + if (fDebug>2) cout<<"\tEnd loop over TreeK"<SetEventNumber(eventNr); + // + fLoader->LoadHeader(); + fLoader->LoadKinematics(); + fStack = fLoader->Stack(); + // + fLoader->LoadTrackRefs(); + fLoader->LoadHits(); + fTreeTR = fLoader->TreeTR(); + // + AliTPCLoader * tpcl = (AliTPCLoader*)fLoader->GetLoader("TPCLoader"); + tpcl->LoadDigits(); + fTreeD = tpcl->TreeD(); + return 0; +} + +Int_t AliGenInfoMaker::CloseIOEvent() +{ + // + // Close IO for current event + // + fLoader->UnloadHeader(); + fLoader->UnloadKinematics(); + fLoader->UnloadTrackRefs(); + AliTPCLoader * tpcl = (AliTPCLoader*)fLoader->GetLoader("TPCLoader"); + tpcl->UnloadDigits(); + return 0; +} + +Int_t AliGenInfoMaker::CloseIO() +{ + fLoader->UnloadgAlice(); + return 0; +} + + + +//////////////////////////////////////////////////////////////////////// +Int_t AliGenInfoMaker::Exec() +{ + // + // Make a comparision MC tree + // Connect MC information -TPArticle - AliTrackRefernces ... + // + TStopwatch timer; + timer.Start(); + Int_t status =SetIO(); + if (status>0) return status; + // + for (fEventNr = fFirstEventNr; fEventNr < fFirstEventNr+fNEvents; + fEventNr++) { + SetIO(fEventNr); + ProcessEvent(); + CloseIOEvent(); + } + // + CloseIO(); + CloseOutputFile(); + cerr<<"Exec finished"<Branch("MC","AliMCInfo",&info); + delete info; + // + AliGenKinkInfo *kinkinfo = new AliGenKinkInfo; + fTreeKinks = new TTree("genKinksTree","genKinksTree"); + fTreeKinks->Branch("MC","AliGenKinkInfo",&kinkinfo); + delete kinkinfo; + // + AliGenV0Info *v0info = new AliGenV0Info; + fTreeV0 = new TTree("genV0Tree","genV0Tree"); + fTreeV0->Branch("MC","AliGenV0Info",&v0info); + delete v0info; + // + // + // + fTreeGenTracks->AutoSave(); + fTreeKinks->AutoSave(); + fTreeV0->AutoSave(); +} + + + +//////////////////////////////////////////////////////////////////////// +void AliGenInfoMaker::CloseOutputFile() +{ + // + // Close Output files + // + if (!fFileGenTracks) { + cerr<<"File "<cd(); + fTreeGenTracks->Write(); + delete fTreeGenTracks; + fTreeKinks->Write(); + delete fTreeKinks; + fTreeV0->Write(); + delete fTreeV0; + + fFileGenTracks->Close(); + delete fFileGenTracks; + return; +} + +//////////////////////////////////////////////////////////////////////// +Int_t AliGenInfoMaker::TreeKLoop() +{ +// +// open the file with treeK +// loop over all entries there and save information about some tracks +// + + AliStack * stack = fStack; + if (!stack) {cerr<<"Stack was not found!\n"; return 1;} + + if (fDebug > 0) { + cout<<"There are "<ParticleFromTreeK(0); + fVPrim[0] = particle->Vx(); + fVPrim[1] = particle->Vy(); + fVPrim[2] = particle->Vz(); + Int_t accepted =0; + for (UInt_t iParticle = 0; iParticle < fNParticles; iParticle++) { + // load only particles with TR + AliMCInfo * info = GetInfo(iParticle); + if (!info) continue; + ////////////////////////////////////////////////////////////////////// + info->fLabel = iParticle; + // + info->fParticle = *(stack->Particle(iParticle)); + info->fVDist[0] = info->fParticle.Vx()-fVPrim[0]; + info->fVDist[1] = info->fParticle.Vy()-fVPrim[1]; + info->fVDist[2] = info->fParticle.Vz()-fVPrim[2]; + info->fVDist[3] = TMath::Sqrt(info->fVDist[0]*info->fVDist[0]+ + info->fVDist[1]*info->fVDist[1]+info->fVDist[2]*info->fVDist[2]); + // + // + ipdg = info->fParticle.GetPdgCode(); + info->fPdg = ipdg; + ppdg = pdg.GetParticle(ipdg); + info->fEventNr = fEventNr; + info->Update(); + if (fGenTracksArray){ + fGenTracksArray->AddLast(info->Clone()); + } + accepted++; + } + // + // write the results to the tree - if specified + // + TBranch * br = fTreeGenTracks->GetBranch("MC"); + for (UInt_t iParticle = 0; iParticle < fNParticles; iParticle++) { + // load only particles with TR + AliMCInfo * info = GetInfo(iParticle); + if (!info) continue; + ////////////////////////////////////////////////////////////////////// + br->SetAddress(&info); + fTreeGenTracks->Fill(); + } + fTreeGenTracks->AutoSave(); + // + // + if (fDebug > 2) cerr<<"end of TreeKLoop"< 0) { + cout<<"There are "<GetBranch("MC"); + // + AliGenKinkInfo * kinkinfo = new AliGenKinkInfo; + // + for (UInt_t iParticle = 0; iParticle < fNParticles; iParticle++) { + // load only particles with TR + AliMCInfo * info = GetInfo(iParticle); + if (!info) continue; + if (info->fCharge==0) continue; + if (info->fTRdecay.R()>500) continue; //R cut - decay outside barrel + TParticle & particle = info->fParticle; + Int_t first = particle.GetDaughter(0); + if (first ==0) continue; + + Int_t last = particle.GetDaughter(1); + if (last ==0) last=first; + AliMCInfo * info2 = 0; + AliMCInfo * dinfo = 0; + + for (Int_t id2=first;id2<=last;id2++){ + info2 = GetInfo(id2); + if (!info2) continue; + TParticle &p2 = info2->fParticle; + Double_t r = TMath::Sqrt(p2.Vx()*p2.Vx()+p2.Vy()*p2.Vy()); + if ( TMath::Abs(info->fTRdecay.R()-r)>0.01) continue; + if (!(p2.GetPDG())) continue; + dinfo =info2; + + kinkinfo->SetInfoMother(*info); + kinkinfo->SetInfoDaughter(*dinfo); + if (kinkinfo->GetMinus().GetParticle().GetPDG()==0 || kinkinfo->GetPlus().GetParticle().GetPDG()==0) continue; + kinkinfo->Update(); + br->SetAddress(&kinkinfo); + fTreeKinks->Fill(); + } + } + fTreeKinks->AutoSave(); + if (fDebug > 2) cerr<<"end of Kink Loop"< 0) { + cout<<"There are "<GetBranch("MC"); + // + AliGenV0Info * v0info = new AliGenV0Info; + // + // + for (UInt_t iParticle = 0; iParticle < fNParticles; iParticle++) { + TParticle * mParticle = fStack->Particle(iParticle); + if (!mParticle) continue; + if (mParticle->GetPDG()==0) continue; + if (mParticle->GetPDG()->Charge()!=0) continue; //only neutral particle + // + Int_t first = mParticle->GetDaughter(0); + Int_t last = mParticle->GetDaughter(1); + if (first-last==0) continue; + // + AliMCInfo * info0 = GetInfo(first); + AliMCInfo * info1 = GetInfo(first+1); + if (info0 && info1){ + if (info0->GetPdg()==0) continue; + if (info1->GetPdg()==0) continue; + v0info->SetInfoP(*info0); + v0info->SetInfoM(*info1); + v0info->SetMother(*mParticle); + v0info->Update(fVPrim); + if (fGenV0Array) fGenV0Array->AddLast(v0info); + br->SetAddress(&v0info); + fTreeV0->Fill(); + } + } + fTreeV0->AutoSave(); + if (fDebug > 2) cerr<<"end of V0 Loop"<GetNInnerSector(); + Int_t rowShift = 0; + Int_t zero=fParamTPC->GetZeroSup()+6; + // + // + AliSimDigits digitsAddress, *digits=&digitsAddress; + fTreeD->GetBranch("Segment")->SetAddress(&digits); + + Int_t sectorsByRows=(Int_t)fTreeD->GetEntries(); + if (fDebug > 1) cout<<"\tsectorsByRows = "<GetEvent(i)) continue; + Int_t sec,row; + fParamTPC->AdjustSectorRow(digits->GetID(),sec,row); + if (fDebug > 1) cout< nInnerSector) rowShift = fParamTPC->GetNRowLow(); + // + digits->ExpandTrackBuffer(); + digits->First(); + do { + Int_t iRow=digits->CurrentRow(); + Int_t iColumn=digits->CurrentColumn(); + Short_t digitValue = digits->CurrentDigit(); + if (digitValue >= zero) { + Int_t label; + for (Int_t j = 0; j<3; j++) { + // label = digits->GetTrackID(iRow,iColumn,j); + label = digits->GetTrackIDFast(iRow,iColumn,j)-2; + if (label >= (Int_t)fNParticles) { //don't label from bakground event + continue; + } + if (label >= 0 && label <= (Int_t)fNParticles) { + if (fDebug > 6 ) { + cout<<"Inner loop: sector, iRow, iColumn, label, value, row " + <fTPCRow.SetRow(row+rowShift); + } + } + } + } + } while (digits->Next()); + } + + if (fDebug > 2) cerr<<"end of TreeDLoop"<GetEntries(); + if (fDebug > 1) cout<<"There are "<GetBranch("TrackReferences")) treeTR->GetBranch("TrackReferences")->SetAddress(&runArrayTR); + // + // + // + for (Int_t ipart = 0; ipartGetNtrack(); ipart++) { + TParticle * part = fStack->Particle(ipart); + if (!part) continue; + if (part->GetPDG()==0) continue; + if (part->GetPDG()->Charge()==0) continue; + + if (part->Pt()R()>250.) continue; + if (TMath::Abs(part->Vz())>250.) continue; + if (TMath::Abs(part->Pz()/part->Pt())>2.5) continue; + //AliMCInfo * info = ; + MakeInfo(ipart); + } + // + // + + for (Int_t iPrimPart = 0; iPrimPartGetEntry(iPrimPart); + // + // gettrack references + // + for (Int_t iTrackRef = 0; iTrackRef < runArrayTR->GetEntriesFast(); iTrackRef++) { + AliTrackReference *trackRef = (AliTrackReference*)runArrayTR->At(iTrackRef); + // + Int_t label = trackRef->GetTrack(); + AliMCInfo * cinfo = GetInfo(label); + if (cinfo) cinfo->CalcTPCrows(runArrayTR); + // + // TPC + // + if (trackRef->DetectorId()== AliTrackReference::kTPC){ + // + Int_t label1 = trackRef->GetTrack(); + AliMCInfo * info = GetInfo(label1); + if (!info && trackRef->Pt()fPrimPart = iPrimPart; + TClonesArray & arr = *(info->fTPCReferences); + new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef); + } + // + // ITS + // + if (trackRef->DetectorId()== AliTrackReference::kITS){ + // + Int_t label1 = trackRef->GetTrack(); + AliMCInfo * info = GetInfo(label1); + if (!info && trackRef->Pt()fPrimPart = iPrimPart; + TClonesArray & arr = *(info->fITSReferences); + new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef); + } + // + // TRD + // + if (trackRef->DetectorId()== AliTrackReference::kTRD){ + // + Int_t label1 = trackRef->GetTrack(); + AliMCInfo * info = GetInfo(label1); + if (!info&&trackRef->P()fPrimPart = iPrimPart; + TClonesArray & arr = *(info->fTRDReferences); + new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef); + } + // + // TOF + // + if (trackRef->DetectorId()== AliTrackReference::kTOF){ + // + Int_t label1 = trackRef->GetTrack(); + AliMCInfo * info = GetInfo(label1); + if (!info&&trackRef->P()fPrimPart = iPrimPart; + TClonesArray & arr = *(info->fTOFReferences); + new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef); + } + // + // decay case + // + if (trackRef->DetectorId()== AliTrackReference::kDisappeared){ + // + AliMCInfo * info = GetInfo(label); + if (!info) continue; + info->fTRdecay = *trackRef; + } + } + } + // + // + return 0; +} + +//////////////////////////////////////////////////////////////////////// +Float_t AliGenInfoMaker::TR2LocalX(AliTrackReference *trackRef, + AliTPCParam *paramTPC) const { + + // + // Transformation from Gloabal to local tacking system + // + Float_t x[3] = { trackRef->X(),trackRef->Y(),trackRef->Z()}; + Int_t index[4]; + paramTPC->Transform0to1(x,index); + paramTPC->Transform1to2(x,index); + return x[0]; +} +//////////////////////////////////////////////////////////////////////// + + + +AliTPCParam * AliGenInfoMaker::GetTPCParam(){ + // + // create default TPC parameters + // + AliTPCParamSR * par = new AliTPCParamSR; + par->Update(); + return par; +} + + diff --git a/PWG1/TPC/AliGenInfoMaker.h b/PWG1/TPC/AliGenInfoMaker.h new file mode 100644 index 00000000000..2325e2e5f62 --- /dev/null +++ b/PWG1/TPC/AliGenInfoMaker.h @@ -0,0 +1,116 @@ +#ifndef ALIGENINFOMAKER_H +#define ALIGENINFOMAKER_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + + + +////////////////////////////////////////////////////////////////////////////// +// Class AliGenInfoMaker // +// collect together MC info for comparison purposes - effieciency studies and so on// // +// marian.ivanov@cern.ch // +////////////////////////////////////////////////////////////////////////////// + + + + +#include +#include "AliAnalysisTask.h" +#include "AliTrackReference.h" + +class TFile; +class AliRunLoader; +class AliStack; +class AliTPCParam; +class AliMCEventHandler; +class AliMCInfo; + +//////////////////////////////////////////////////////////////////////// +// +// Start of implementation of the class AliGenInfoMaker +// +//////////////////////////////////////////////////////////////////////// + +class AliGenInfoMaker : public TObject { + +public: + AliGenInfoMaker(); + virtual ~AliGenInfoMaker(); + // + // + AliGenInfoMaker(const char * fnGalice, const char* fnRes, + Int_t nEvents=1, Int_t firstEvent=0); + //event by event function - used in the analysis task + Int_t ProcessEvent(AliMCEventHandler* mcinfo); + + Int_t ProcessEvent(); // process event + Int_t TreeKLoop(); // process kinamatics + Int_t TreeTRLoop(); // process track refereces + Int_t TreeDLoop(); // process digits tree + Int_t BuildKinkInfo(); // build information about MC kinks + Int_t BuildV0Info(); // build information about MC kinks + // + // + Int_t Exec(); + void CreateTreeGenTracks(); + void CloseOutputFile(); + void SetFirstEventNr(Int_t i) {fFirstEventNr = i;} + void SetNEvents(Int_t i) {fNEvents = i;} + void SetDebug(Int_t level) {fDebug = level;} + Int_t SetIO(Int_t eventNr); + Int_t CloseIOEvent(); + Int_t CloseIO(); + Int_t SetIO(); + +protected: + AliGenInfoMaker(const AliGenInfoMaker& /*info*/); + AliGenInfoMaker& operator=(const AliGenInfoMaker& /*info*/) { return *this;} + + AliMCInfo * MakeInfo(UInt_t i); + AliMCInfo * GetInfo(UInt_t i) const {return (i +#include + +// ALIROOT includes +#include +#include +#include +#include "AliStack.h" +#include "AliMCEvent.h" +#include "AliMCEventHandler.h" + +#include +#include "AliGenInfoTask.h" +#include "AliGenInfoMaker.h" +#include "AliHelix.h" + +// +#include "AliMCInfo.h" +#include "AliComparisonObject.h" +#include "AliESDRecInfo.h" +#include "AliTPCParamSR.h" +#include "TSystem.h" +#include "TTimeStamp.h" +#include "TFile.h" +#include "AliTPCseed.h" + +// STL includes +#include + +using namespace std; + +ClassImp(AliGenInfoTask) + +//________________________________________________________________________ +AliGenInfoTask::AliGenInfoTask() : + AliAnalysisTask(), + fMCinfo(0), //! MC event handler + fESD(0), + fESDfriend(0), + fCompList(0), //array of comparison objects + fGenTracksArray(0), //clones array with filtered particles + fGenKinkArray(0), //clones array with filtered Kinks + fGenV0Array(0), //clones array with filtered V0s + fRecTracksArray(0), //clones array with filtered particles + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(0), + fDebugOutputPath() +{ + // + // Default constructor (should not be used) + // +} + +AliGenInfoTask::AliGenInfoTask(const AliGenInfoTask& /*info*/) : + AliAnalysisTask(), + fMCinfo(0), //! MC event handler + fESD(0), + fESDfriend(0), + fCompList(0), + fGenTracksArray(0), //clones array with filtered particles + fGenKinkArray(0), //clones array with filtered Kinks + fGenV0Array(0), //clones array with filtered V0s + fRecTracksArray(0), //clones array with filtered particles + // + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(), + fDebugOutputPath() +{ + // + // Default constructor + // +} + + + +//________________________________________________________________________ +AliGenInfoTask::AliGenInfoTask(const char *name) : + AliAnalysisTask(name, "AliGenInfoTask"), + fMCinfo(0), //! MC event handler + fESD(0), + fESDfriend(0), + fCompList(0), + fGenTracksArray(0), //clones array with filtered particles + fGenKinkArray(0), //clones array with filtered Kinks + fGenV0Array(0), //clones array with filtered V0s + fRecTracksArray(0), //clones array with filtered particles + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(0), + fDebugOutputPath() +{ + // + // Normal constructor + // + // Input slot #0 works with a TChain + DefineInput(0, TChain::Class()); + // Output slot #0 writes into a TList + DefineOutput(0, TObjArray::Class()); + // + // + fCompList = new TObjArray; +} + +AliGenInfoTask::~AliGenInfoTask(){ + // + // + // + if (fDebugLevel>0) printf("AliGenInfoTask::~AliGenInfoTask\n"); + if (fDebugStreamer) delete fDebugStreamer; + fDebugStreamer=0; + if(fCompList) delete fCompList; + fCompList =0; +} + + +//________________________________________________________________________ +void AliGenInfoTask::ConnectInputData(Option_t *) +{ + // + // Connect the input data + // + if(fDebugLevel>3) + cout << "AnalysisTaskTPCCluster::ConnectInputData()" << endl; + + TTree* tree=dynamic_cast(GetInputData(0)); + if (!tree) { + //Printf("ERROR: Could not read chain from input slot 0"); + } + else { + AliESDInputHandler *esdH = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if (!esdH) { + //Printf("ERROR: Could not get ESDInputHandler"); + } + else { + fESD = esdH->GetEvent(); + fESDfriend=static_cast(fESD->FindListObject("AliESDfriend")); + fESD->SetESDfriend(fESDfriend); + //Printf("*** CONNECTED NEW EVENT ****"); + } + } + AliMCEventHandler* mcinfo = (AliMCEventHandler*) (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); + mcinfo->SetReadTR(kTRUE); + + fMCinfo = mcinfo->MCEvent(); + + +} + + +//_____________________________________________________________________________ +Bool_t AliGenInfoTask::AddComparisonObject(AliComparisonObject *pObj) +{ + // add comparison object to the list + if(pObj == 0) { + Printf("ERROR: Could not add comparison object"); + return kFALSE; + } + // add object to the list + fCompList->AddLast(pObj); + return kTRUE; +} + + + + +//________________________________________________________________________ +void AliGenInfoTask::CreateOutputObjects() +{ + // + // Connect the output objects + // + if(fDebugLevel>3) + cout << "AnalysisTaskTPCCluster::CreateOutputObjects()" << endl; + +} + + +//________________________________________________________________________ +void AliGenInfoTask::Exec(Option_t *) { + // + // Execute analysis for current event + // + + if(fDebugLevel>3) + cout << "AliGenInfoTask::Exec()" << endl; + + + // If MC has been connected + if (fGenTracksArray) fGenTracksArray->Delete(); + if (fRecTracksArray) fRecTracksArray->Delete(); + + if (!fMCinfo){ + cout << "Not MC info\n" << endl; + }else{ + //mcinfo->Print(); + ProcessMCInfo(); + ProcessESDInfo(); + DumpInfo(); + ProcessComparison(); + } + // +} + + + + +//________________________________________________________________________ +void AliGenInfoTask::Terminate(Option_t *) { + // + // Terminate loop + // + if(fDebugLevel>3) + printf("AliGenInfoTask: Terminate() \n"); + // + if (fDebugLevel>0) printf("AliTPCcalibBase::Terminate\n"); + if (fDebugStreamer) delete fDebugStreamer; + fDebugStreamer = 0; + return; +} + + + + + +TTreeSRedirector *AliGenInfoTask::GetDebugStreamer(){ + // + // Get Debug streamer + // In case debug streamer not yet initialized and StreamLevel>0 create new one + // + if (fStreamLevel==0) return 0; + if (fDebugStreamer) return fDebugStreamer; + TString dsName; + dsName=GetName(); + dsName+="Debug.root"; + dsName.ReplaceAll(" ",""); + fDebugStreamer = new TTreeSRedirector(dsName.Data()); + return fDebugStreamer; +} + + + +AliMCInfo* AliGenInfoTask::GetTrack(Int_t index, Bool_t force){ + // + // Get the MC info for given track + // + if (!fGenTracksArray) fGenTracksArray = new TClonesArray("AliMCInfo",1000); + if (index>fGenTracksArray->GetEntriesFast()) fGenTracksArray->Expand(index*2+10); + AliMCInfo * info = (AliMCInfo*)fGenTracksArray->At(index); + if (!force) return info; + if (!info){ + info = new ((*fGenTracksArray)[index]) AliMCInfo; + } + return info; +} + +AliESDRecInfo* AliGenInfoTask::GetRecTrack(Int_t index, Bool_t force){ + // + // Get the MC info for given track + // + if (!fRecTracksArray) fRecTracksArray = new TClonesArray("AliESDRecInfo",1000); + if (index>fRecTracksArray->GetEntriesFast()) fRecTracksArray->Expand(index*2+10); + AliESDRecInfo * info = (AliESDRecInfo*)fRecTracksArray->At(index); + if (!force) return info; + if (!info){ + info = new ((*fRecTracksArray)[index]) AliESDRecInfo; + } + return info; +} + + + + +void AliGenInfoTask::ProcessMCInfo(){ + // + // Dump information from MC to the array + // + // + TParticle * particle= new TParticle; + TClonesArray * trefs = new TClonesArray("AliTrackReference"); + // + // + // Process tracks + // + Int_t npart = fMCinfo->GetNumberOfTracks(); + if (npart==0) return; + Double_t vertex[4]={0,0,0,0}; + fMCinfo->GetParticleAndTR(0, particle, trefs); + if (particle){ + vertex[0]=particle->Vx(); + vertex[1]=particle->Vy(); + vertex[2]=particle->Vz(); + vertex[3]=particle->R(); + } + + for (Int_t ipart=0;ipartGetParticleAndTR(ipart, particle, trefs); + if (status<0) continue; + if (!particle) continue; + if (!trefs) continue; + if (!AcceptParticle(particle)) continue; + //if (trefs->GetEntries()<1) continue; + AliMCInfo * mcinfo = GetTrack(ipart,kTRUE); + mcinfo->Update(particle,trefs,vertex,ipart); + // + TTreeSRedirector *pcstream = GetDebugStreamer(); + if (pcstream){ + (*pcstream)<<"MC"<< + "p.="<(fESD->FindListObject("AliESDfriend")); + if (!fESDfriend) { + //Printf("ERROR: fESDfriend not available"); + return; + } + fESD->SetESDfriend(fESDfriend); + // + // + if (!fESD) return; + Int_t ntracks = fESD->GetNumberOfTracks(); + for (Int_t itrack=0; itrackGetTrack(itrack); + Int_t label = TMath::Abs(track->GetLabel()); + AliMCInfo * mcinfo = GetTrack(label,kFALSE); + if (!mcinfo) continue; + AliESDRecInfo *recInfo= GetRecTrack(label,kTRUE); + recInfo->AddESDtrack(track,mcinfo); + recInfo->Update(mcinfo,¶m,kTRUE); + } + // + + +} + + +void AliGenInfoTask::ProcessComparison(){ + // + // + // + static AliESDRecInfo dummy; + Int_t npart = fMCinfo->GetNumberOfTracks(); + for (Int_t ipart=0;ipartGetEntries(); icomp++){ + AliComparisonObject *pObj= (AliComparisonObject *)fCompList->At(icomp); + if (pObj){ + pObj->Exec(mcinfo,recInfo); + } + } + } + PostData(0, fCompList); +} + +void AliGenInfoTask::DumpInfo(){ + // + // + // + TParticle * particle= new TParticle; + TClonesArray * trefs = new TClonesArray("AliTrackReference"); + // + + static AliESDRecInfo dummy; + Int_t npart = fMCinfo->GetNumberOfTracks(); + for (Int_t ipart=0;ipartGetParticleAndTR(ipart, particle, trefs); + Int_t counter=0; + Float_t length=0; + if (trefs!=0 && particle!=0){ + length = GetTPCTrackLength(*trefs, particle , fESD->GetMagneticField(), counter, 3.0); + } + + if (pcstream){ + (*pcstream)<<"RC"<< + "MC.="<0.1"); + TCut cutZ("abs(p.Vz())<250"); + TCut cutR("abs(p.R())<250"); + // + */ + // + // + if (part->Pt()<0.1) return kFALSE; + if (TMath::Abs(part->Vz())>250) return kFALSE; + if (part->R()>360) return kFALSE; + if (part->GetPDG()){ + if (part->GetPDG()->Charge()==0) return kFALSE; + } + return kTRUE; +} + + + +void AliGenInfoTask::FinishTaskOutput() +{ + // + // According description in AliAnalisysTask this method is call + // on the slaves before sending data + // + Terminate("slave"); + RegisterDebugOutput(fDebugOutputPath.Data()); + +} + + + +void AliGenInfoTask::RegisterDebugOutput(const char */*path*/){ + // + // store - copy debug output to the destination position + // currently ONLY for local copy + TString dsName; + dsName=GetName(); + dsName+="Debug.root"; + dsName.ReplaceAll(" ",""); + TString dsName2=fDebugOutputPath.Data(); + gSystem->MakeDirectory(dsName2.Data()); + dsName2+="/";; + dsName2+=gSystem->HostName(); + gSystem->MakeDirectory(dsName2.Data()); + dsName2+="/"; + dsName2+=gSystem->BaseName(gSystem->pwd()); + dsName2+="/"; + gSystem->MakeDirectory(dsName2.Data()); + dsName2+=dsName; + AliInfo(Form("copy %s\t%s\n",dsName.Data(),dsName2.Data())); + printf("copy %s\t%s\n",dsName.Data(),dsName2.Data()); + TFile::Cp(dsName.Data(),dsName2.Data()); +} + + +Float_t AliGenInfoTask::GetTPCTrackLength(const TClonesArray& trackRefs, TParticle*part, Float_t bz, Int_t &counter, Float_t deadWidth){ + // + // return track length in geometrically active volume of TPC. + // z nad rphi acceptance is included + // doesn't take into account dead channel and ExB + // Intput: + // trackRefs + // bz - magnetic field + // deadWidth - dead zone in r-phi + // Additional output: + // counter - number of circles + const Float_t kRMin = 90; + const Float_t kRMax = 245; + const Float_t kZMax = 250; + const Float_t kMinPt= 0.01; + Float_t length =0; + Int_t nrefs = trackRefs.GetEntriesFast(); + AliExternalTrackParam param; + Double_t cv[21]; + for (Int_t i=0; i<21;i++) cv[i]=0; + counter=0; + // + // + AliTrackReference *ref0 = (AliTrackReference*)trackRefs.At(0); + Float_t direction = 0; + // + for (Int_t iref=1; irefDetectorId()!= AliTrackReference::kTPC){ + ref0 = ref; + direction = ((ref0->X()*ref0->Px()+ref0->Y()*ref0->Py())>0)? 1.:-1.; + continue; + } + Float_t newdirection = ((ref->X()*ref->Px()+ref->Y()*ref->Py())>0)? 1.:-1.; + if (newdirection*direction<0) { + counter++; //circle counter + direction = newdirection; + continue; + } + if (counter>0) continue; + if (ref0->Pt()R(),kRMax),kRMin);; + Float_t radius1 = TMath::Max(TMath::Min(ref->R(),kRMax),kRMin); + Double_t xyz[3]={ref0->X(),ref0->Y(),ref0->Z()}; + Double_t pxyz[3]={ref0->Px(),ref0->Py(),ref0->Pz()}; + Double_t alpha; + param.Set(xyz,pxyz,cv,TMath::Nint(part->GetPDG()->Charge()/3.)); + + for (Float_t radius = radius0; radiuskZMax) continue; + Float_t gradius = TMath::Sqrt(xyz[1]*xyz[1]+xyz[0]*xyz[0]); + if (gradius>kRMax) continue; + alpha = TMath::ATan2(xyz[1],xyz[0]); + if (alpha<0) alpha+=TMath::TwoPi(); + // + Int_t sector = Int_t(9*alpha/TMath::Pi()); + Float_t lalpha = alpha-((sector+0.5)*TMath::Pi()/9.); + Float_t dedge = (TMath::Tan(TMath::Pi()/18.)-TMath::Abs(TMath::Tan(lalpha)))*gradius; + if (dedge>deadWidth) length++; + } + if (ref->DetectorId()!= AliTrackReference::kTPC) break; + ref0 = ref; + } + return length; +} diff --git a/PWG1/TPC/AliGenInfoTask.h b/PWG1/TPC/AliGenInfoTask.h new file mode 100644 index 00000000000..2741323af29 --- /dev/null +++ b/PWG1/TPC/AliGenInfoTask.h @@ -0,0 +1,84 @@ +#ifndef ALIGENINFOTASK_H +#define ALIGENINFOTASK_H + +// ROOT includes +#include +#include +#include + +// AliRoot includes +#include +#include +#include +#include +#include +#include +class AliGenInfoMaker; +class TTreeSRedirector; +class AliMCEventHadnler; +class TParticle; +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliESDfriend; +class AliMCEvent; +class AliComparisonObject; + +class AliGenInfoTask : public AliAnalysisTask { + public: + AliGenInfoTask(); + AliGenInfoTask(const char *name); + virtual ~AliGenInfoTask(); + + virtual void ConnectInputData(Option_t *); + virtual void CreateOutputObjects(); + virtual void Exec(Option_t *option); + virtual void Terminate(Option_t *); + virtual void FinishTaskOutput(); + // + // + void ProcessMCInfo(); + void ProcessESDInfo(); + void ProcessComparison(); + void DumpInfo(); + static Float_t GetTPCTrackLength(const TClonesArray& trackRefs, TParticle*part, Float_t bz, Int_t &counter, Float_t deadWidth); + // + // + // debug streamer part + // + TTreeSRedirector *GetDebugStreamer(); + void SetStreamLevel(Int_t streamLevel){fStreamLevel=streamLevel;} + void SetDebugLevel(Int_t level) {fDebugLevel = level;} + Int_t GetStreamLevel() const {return fStreamLevel;} + Int_t GetDebugLevel() const {return fDebugLevel;} + // + Bool_t AcceptParticle(TParticle *part); + AliMCInfo *GetTrack(Int_t index, Bool_t force=kFALSE); + AliESDRecInfo *GetRecTrack(Int_t index, Bool_t force=kFALSE); + Bool_t AddComparisonObject(AliComparisonObject *pObj); + void RegisterDebugOutput(const char *path); + void SetDebugOuputhPath(const char * name){fDebugOutputPath=name;} + protected: + AliGenInfoTask(const AliGenInfoTask& /*info*/); + AliGenInfoTask& operator=(const AliGenInfoTask& /*info*/) { return *this;} + AliMCEvent * fMCinfo; //! MC event handler + AliESDEvent * fESD; //! current esd event + AliESDfriend * fESDfriend; //! current esd event + // + TObjArray *fCompList; // comparison object list + // + TClonesArray *fGenTracksArray; //clones array with filtered particles + TClonesArray *fGenKinkArray; //clones array with filtered Kinks + TClonesArray *fGenV0Array; //clones array with filtered V0s + // + TClonesArray *fRecTracksArray; //clones array with filtered tracks + // + // + TTreeSRedirector *fDebugStreamer; //! debug streamer + Int_t fStreamLevel; // debug stream level + Int_t fDebugLevel; // debug level + TString fDebugOutputPath; // debug output path + ClassDef(AliGenInfoTask, 1); // Analysis task base class for tracks +}; + +#endif diff --git a/PWG1/TPC/AliGenKinkInfo.cxx b/PWG1/TPC/AliGenKinkInfo.cxx new file mode 100644 index 00000000000..5164c19c789 --- /dev/null +++ b/PWG1/TPC/AliGenKinkInfo.cxx @@ -0,0 +1,216 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////// +/* + +Origin: marian.ivanov@cern.ch +Container classes with MC infomation + +*/ + +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +#include +//ROOT includes +#include "TROOT.h" +#include "Rtypes.h" +#include "TFile.h" +#include "TTree.h" +#include "TChain.h" +#include "TCut.h" +#include "TString.h" +#include "TStopwatch.h" +#include "TParticle.h" +#include "TDatabasePDG.h" +#include "TSystem.h" +#include "TCanvas.h" +#include "TPolyLine3D.h" + +//ALIROOT includes +#include "AliRun.h" +#include "AliStack.h" +#include "AliSimDigits.h" +#include "AliTPCParam.h" +#include "AliTPC.h" +#include "AliTPCLoader.h" +#include "AliDetector.h" +#include "AliTrackReference.h" +#include "AliTPCParamSR.h" +#include "AliTracker.h" +#include "AliMagF.h" +#include "AliHelix.h" +#include "AliTrackPointArray.h" + +#endif +#include "AliGenKinkInfo.h" + +// +// + +ClassImp(AliGenKinkInfo) + + + +///////////////////////////////////////////////////////////////////////////////// + +AliGenKinkInfo::AliGenKinkInfo(): + fMCd(), //info about daughter particle - second particle for V0 + fMCm(), //info about mother particle - first particle for V0 + fMCDist1(0), //info about closest distance according closest MC - linear DCA + fMCDist2(0), //info about closest distance parabolic DCA + fMCRr(0), // rec position of the vertex + fMCR(0) //exact r position of the vertex +{ + // + // default constructor + // + for (Int_t i=0;i<3;i++){ + fMCPdr[i]=0; + fMCPd[i]=0; + fMCX[i]=0; + fMCPm[i]=0; + fMCAngle[i]=0; + } + for (Int_t i=0; i<2; i++) { + fPdg[i]= 0; + fLab[i]=0; + } +} + +void AliGenKinkInfo::Update() +{ + // + // Update information + // some redundancy - faster acces to the values in analysis code + // + fMCPd[0] = fMCd.GetParticle().Px(); + fMCPd[1] = fMCd.GetParticle().Py(); + fMCPd[2] = fMCd.GetParticle().Pz(); + fMCPd[3] = fMCd.GetParticle().P(); + // + fMCX[0] = fMCd.GetParticle().Vx(); + fMCX[1] = fMCd.GetParticle().Vy(); + fMCX[2] = fMCd.GetParticle().Vz(); + fMCR = TMath::Sqrt( fMCX[0]*fMCX[0]+fMCX[1]*fMCX[1]); + // + fPdg[0] = fMCd.GetParticle().GetPdgCode(); + fPdg[1] = fMCm.GetParticle().GetPdgCode(); + // + fLab[0] = fMCd.GetParticle().GetUniqueID(); + fLab[1] = fMCm.GetParticle().GetUniqueID(); + // + // + // + Double_t x1[3],p1[3]; + TParticle& pdaughter = fMCd.GetParticle(); + x1[0] = pdaughter.Vx(); + x1[1] = pdaughter.Vy(); + x1[2] = pdaughter.Vz(); + p1[0] = pdaughter.Px(); + p1[1] = pdaughter.Py(); + p1[2] = pdaughter.Pz(); + Double_t sign = (pdaughter.GetPDG()->Charge()>0)? -1:1; + AliHelix dhelix1(x1,p1,sign); + // + // + Double_t x2[3],p2[3]; + // + TParticle& pmother = fMCm.GetParticle(); + x2[0] = pmother.Vx(); + x2[1] = pmother.Vy(); + x2[2] = pmother.Vz(); + p2[0] = pmother.Px(); + p2[1] = pmother.Py(); + p2[2] = pmother.Pz(); + // + const AliTrackReference & pdecay = fMCm.GetTRdecay(); + x2[0] = pdecay.X(); + x2[1] = pdecay.Y(); + x2[2] = pdecay.Z(); + p2[0] = pdecay.Px(); + p2[1] = pdecay.Py(); + p2[2] = pdecay.Pz(); + // + sign = (pmother.GetPDG()->Charge()>0) ? -1:1; + AliHelix mhelix(x2,p2,sign); + + // + // + // + //find intersection linear + // + Double_t distance1, distance2; + Double_t phase[2][2],radius[2]; + Int_t points = dhelix1.GetRPHIintersections(mhelix, phase, radius); + Double_t delta1=10000,delta2=10000; + if (points>0){ + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + } + if (points==2){ + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + } + distance1 = TMath::Min(delta1,delta2); + // + //find intersection parabolic + // + points = dhelix1.GetRPHIintersections(mhelix, phase, radius); + delta1=10000,delta2=10000; + + if (points>0){ + dhelix1.ParabolicDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + } + if (points==2){ + dhelix1.ParabolicDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + } + + distance2 = TMath::Min(delta1,delta2); + // + if (delta1 +#include "AliMCInfo.h" + +class TFile; +class AliRunLoader; +class AliStack; +class AliTPCParam; + + + + +class AliGenKinkInfo: public TObject { +public: + AliGenKinkInfo(); //default cosntructor + void Update(); // put some derived info to special field + Float_t GetQt(); // + AliMCInfo & GetPlus() {return fMCd;} + AliMCInfo & GetMinus() {return fMCm;} + void SetInfoDaughter(AliMCInfo &daughter) {fMCd=daughter;} + void SetInfoMother(AliMCInfo &mother){fMCm=mother;} +private: + AliMCInfo fMCd; //info about daughter particle - second particle for V0 + AliMCInfo fMCm; //info about mother particle - first particle for V0 + Double_t fMCDist1; //info about closest distance according closest MC - linear DCA + Double_t fMCDist2; //info about closest distance parabolic DCA + // + Double_t fMCPdr[3]; //momentum at vertex daughter - according approx at DCA + Double_t fMCPd[4]; //exact momentum from MC info + Double_t fMCX[3]; //exact position of the vertex + Double_t fMCXr[3]; //rec. position according helix + // + Double_t fMCPm[3]; //momentum at the vertex mother + Double_t fMCAngle[3]; //three angels + Double_t fMCRr; // rec position of the vertex + Double_t fMCR; //exact r position of the vertex + Int_t fPdg[2]; //pdg code of mother and daugter particles + Int_t fLab[2]; //MC label of the partecle + ClassDef(AliGenKinkInfo,1) // container for +}; + +#endif diff --git a/PWG1/TPC/AliGenV0Info.cxx b/PWG1/TPC/AliGenV0Info.cxx new file mode 100644 index 00000000000..45cc8e79c2a --- /dev/null +++ b/PWG1/TPC/AliGenV0Info.cxx @@ -0,0 +1,262 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////// +/* + +Origin: marian.ivanov@cern.ch +Container classes with MC infomation for V0 + + +*/ + +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +#include +//ROOT includes +#include "TROOT.h" +#include "Rtypes.h" +#include "TFile.h" +#include "TTree.h" +#include "TChain.h" +#include "TCut.h" +#include "TString.h" +#include "TStopwatch.h" +#include "TParticle.h" +#include "TDatabasePDG.h" +#include "TSystem.h" +#include "TCanvas.h" +#include "TPolyLine3D.h" + +//ALIROOT includes +#include "AliRun.h" +#include "AliStack.h" +#include "AliSimDigits.h" +#include "AliTPCParam.h" +#include "AliTPC.h" +#include "AliTPCLoader.h" +#include "AliDetector.h" +#include "AliTrackReference.h" +#include "AliTPCParamSR.h" +#include "AliTracker.h" +#include "AliMagF.h" +#include "AliHelix.h" +#include "AliTrackPointArray.h" + +#endif +#include "AliGenV0Info.h" +// +// + +ClassImp(AliGenV0Info) + + + + + +///////////////////////////////////////////////////////////////////////////////// +AliGenV0Info::AliGenV0Info(): + fMCd(), //info about daughter particle - + fMCm(), //info about mother particle - first particle for V0 + fMotherP(), //particle info about mother particle + fMCDist1(0), //info about closest distance according closest MC - linear DCA + fMCDist2(0), //info about closest distance parabolic DCA + fMCRr(0), // rec position of the vertex + fMCR(0), //exact r position of the vertex + fInvMass(0), //reconstructed invariant mass - + fPointAngleFi(0), //point angle fi + fPointAngleTh(0), //point angle theta + fPointAngle(0) //point angle full +{ + for (Int_t i=0;i<3; i++){ + fMCPdr[i]=0; + fMCX[i]=0; + fMCXr[i]=0; + fMCPm[i]=0; + fMCAngle[i]=0; + fMCPd[i]=0; + } + fMCPd[3]=0; + for (Int_t i=0; i<2;i++){ + fPdg[i]=0; + fLab[i]=0; + } +} + +void AliGenV0Info::Update(Float_t vertex[3]) +{ + // + // Update information - calculates derived variables + // + + fMCPd[0] = fMCd.GetParticle().Px(); + fMCPd[1] = fMCd.GetParticle().Py(); + fMCPd[2] = fMCd.GetParticle().Pz(); + fMCPd[3] = fMCd.GetParticle().P(); + // + fMCX[0] = fMCd.GetParticle().Vx(); + fMCX[1] = fMCd.GetParticle().Vy(); + fMCX[2] = fMCd.GetParticle().Vz(); + fMCR = TMath::Sqrt( fMCX[0]*fMCX[0]+fMCX[1]*fMCX[1]); + // + fPdg[0] = fMCd.GetParticle().GetPdgCode(); + fPdg[1] = fMCm.GetParticle().GetPdgCode(); + // + fLab[0] = fMCd.GetParticle().GetUniqueID(); + fLab[1] = fMCm.GetParticle().GetUniqueID(); + // + // + // + Double_t x1[3],p1[3]; + TParticle& part0 = fMCd.GetParticle(); + x1[0] = part0.Vx(); + x1[1] = part0.Vy(); + x1[2] = part0.Vz(); + p1[0] = part0.Px(); + p1[1] = part0.Py(); + p1[2] = part0.Pz(); + if (part0.GetPDG()==0) return; + + Double_t sign = (part0.GetPDG()->Charge()>0)? -1:1; + AliHelix dhelix1(x1,p1,sign); + // + // + Double_t x2[3],p2[3]; + // + TParticle& part1 = fMCm.GetParticle(); + if (part1.GetPDG()==0) return; + x2[0] = part1.Vx(); + x2[1] = part1.Vy(); + x2[2] = part1.Vz(); + p2[0] = part1.Px(); + p2[1] = part1.Py(); + p2[2] = part1.Pz(); + // + // + if (part1.GetPDG()==0) return; + sign = (part1.GetPDG()->Charge()>0) ? -1:1; + AliHelix mhelix(x2,p2,sign); + + // + // + // + //find intersection linear + // + Double_t distance1, distance2; + Double_t phase[2][2],radius[2]; + Int_t points = dhelix1.GetRPHIintersections(mhelix, phase, radius); + Double_t delta1=10000,delta2=10000; + if (points>0){ + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + dhelix1.LinearDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + } + else{ + fInvMass=-1; + return; + } + if (points==2){ + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + } + distance1 = TMath::Min(delta1,delta2); + // + //find intersection parabolic + // + points = dhelix1.GetRPHIintersections(mhelix, phase, radius); + delta1=10000,delta2=10000; + + if (points>0){ + dhelix1.ParabolicDCA(mhelix,phase[0][0],phase[0][1],radius[0],delta1); + } + if (points==2){ + dhelix1.ParabolicDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2); + } + + distance2 = TMath::Min(delta1,delta2); + // + if (delta10){ + fPointAngleFi = (v[0]*p[0]+v[1]*p[1])/(vnorm2*pnorm2); + fPointAngleTh = (v[2]*p[2]+vnorm2*pnorm2)/(vnorm3*pnorm3); + fPointAngle = (v[0]*p[0]+v[1]*p[1]+v[2]*p[2])/(vnorm3*pnorm3); + }else{ + fPointAngleFi = 1; + fPointAngleTh = 1; + fPointAngle = 1; + } + Double_t mass1 = fMCd.GetMass(); + Double_t mass2 = fMCm.GetMass(); + + + Double_t e1 = TMath::Sqrt(mass1*mass1+ + fMCPd[0]*fMCPd[0]+ + fMCPd[1]*fMCPd[1]+ + fMCPd[2]*fMCPd[2]); + Double_t e2 = TMath::Sqrt(mass2*mass2+ + fMCPm[0]*fMCPm[0]+ + fMCPm[1]*fMCPm[1]+ + fMCPm[2]*fMCPm[2]); + + fInvMass = + (fMCPm[0]+fMCPd[0])*(fMCPm[0]+fMCPd[0])+ + (fMCPm[1]+fMCPd[1])*(fMCPm[1]+fMCPd[1])+ + (fMCPm[2]+fMCPd[2])*(fMCPm[2]+fMCPd[2]); + + // fInvMass = TMath::Sqrt((e1+e2)*(e1+e2)-fInvMass); + fInvMass = (e1+e2)*(e1+e2)-fInvMass; + if (fInvMass>0) fInvMass = TMath::Sqrt(fInvMass); +} + + + + + + + + diff --git a/PWG1/TPC/AliGenV0Info.h b/PWG1/TPC/AliGenV0Info.h new file mode 100644 index 00000000000..f995629b30d --- /dev/null +++ b/PWG1/TPC/AliGenV0Info.h @@ -0,0 +1,71 @@ +#ifndef ALIGENV0INFO_H +#define ALIGENV0INFO_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + + + +////////////////////////////////////////////////////////////////////////////// +// Class AliGenV0Info // +// collect together MC info for comparison purposes - effieciency studies and so on// // +// marian.ivanov@cern.ch // +////////////////////////////////////////////////////////////////////////////// + + + +#include +#include "AliMCInfo.h" + +class TFile; +class AliRunLoader; +class AliStack; +class AliTPCParam; + + + + +class AliGenV0Info: public TObject { +public: + AliGenV0Info(); // + void Update(Float_t vertex[3]); + AliMCInfo & GetPlus() {return fMCd;} + AliMCInfo & GetMinus() {return fMCm;} + TParticle & GetMother() {return fMotherP;} + Double_t GetMCDist1() const { return fMCDist1;} + Double_t GetMCDist2() const {return fMCDist2;} + const Double_t* GetMCPdr() const {return fMCPdr;} + const Double_t* GetMCPd() const {return fMCPd;} + const Double_t* GetMCX() const {return fMCX;} + void SetInfoP(AliMCInfo &plus) {fMCd=plus;} + void SetInfoM(AliMCInfo &minus){fMCm=minus;} + void SetMother(TParticle&mother){fMotherP=mother;} +private: + AliMCInfo fMCd; //info about daughter particle - second particle for V0 + AliMCInfo fMCm; //info about mother particle - first particle for V0 + TParticle fMotherP; //particle info about mother particle + Double_t fMCDist1; //info about closest distance according closest MC - linear DCA + Double_t fMCDist2; //info about closest distance parabolic DCA + // + Double_t fMCPdr[3]; //momentum at vertex daughter - according approx at DCA + Double_t fMCPd[4]; //exact momentum from MC info + Double_t fMCX[3]; //exact position of the vertex + Double_t fMCXr[3]; //rec. position according helix + // + Double_t fMCPm[3]; //momentum at the vertex mother + Double_t fMCAngle[3]; //three angels + Double_t fMCRr; // rec position of the vertex + Double_t fMCR; //exact r position of the vertex + Int_t fPdg[2]; //pdg code of mother and daugter particles + Int_t fLab[2]; //MC label of the partecle + // + Double_t fInvMass; //reconstructed invariant mass - + Float_t fPointAngleFi; //point angle fi + Float_t fPointAngleTh; //point angle theta + Float_t fPointAngle; //point angle full + // + ClassDef(AliGenV0Info,1) // container for +}; + + + +#endif diff --git a/PWG1/TPC/AliMCInfo.cxx b/PWG1/TPC/AliMCInfo.cxx new file mode 100644 index 00000000000..5d2005d5d90 --- /dev/null +++ b/PWG1/TPC/AliMCInfo.cxx @@ -0,0 +1,510 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////// +/* + +Origin: marian.ivanov@cern.ch +Container classes with MC infomation + +The AliMCInfo contains the information about the particles properties +during transportation throuch ALICE Detector + +The base Information : +TParticle - fParticle - properties of the particle at creation point +AliTrackReference - fXXXRefernces - TClonesArray of refernces in differnt detectors +fNXXXRef - number of the track refernces in differnt detectors +AliTPCdigitRow - fTPCRow - the map of the hitted rows - (will be repalced by TBits) +fRowsWith* - number of rows hitted by particle +fMCtracks - - number of turn over of the track inside of the TPC + +++++ +some additional information usable for tree draw - TO SPEED UP tree queries +IMPORTANT FOR PROOF FAST PROTOTYPING ANALYSIS + + + + +*/ + +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +//ROOT includes +#include "Rtypes.h" +#include "TClonesArray.h" +#include "TDatabasePDG.h" +//ALIROOT includes +#include "AliTrackReference.h" +#include "AliMCInfo.h" +#include "AliMathBase.h" +#endif + +// +// + +ClassImp(AliTPCdigitRow) +ClassImp(AliMCInfo) + + + +//////////////////////////////////////////////////////////////////////// +AliMCInfo::AliMCInfo(): + fTrackRef(), + fTrackRefOut(), + fTRdecay(), + fPrimPart(0), + fParticle(), + fMass(0), + fCharge(0), + fLabel(0), + fEventNr(), + fMCtracks(), + fPdg(0), + fTPCdecay(0), + fRowsWithDigitsInn(0), + fRowsWithDigits(0), + fRowsTrackLength(0), + fTPCtrackLength(-1), + fPrim(0), + fTPCRow(), + fNTPCRef(0), // tpc references counter + fNITSRef(0), // ITS references counter + fNTRDRef(0), // TRD references counter + fNTOFRef(0), // TOF references counter + fNTPCRefOut(0), // tpc references counter + fNITSRefOut(0), // ITS references counter + fNTRDRefOut(0), // TRD references counter + fNTOFRefOut(0), // TOF references counter + fTPCReferences(0), + fITSReferences(0), + fTRDReferences(0), + fTOFReferences(0) +{ + // + // Default constructor + // + fTPCReferences = new TClonesArray("AliTrackReference",10); + fITSReferences = new TClonesArray("AliTrackReference",10); + fTRDReferences = new TClonesArray("AliTrackReference",10); + fTOFReferences = new TClonesArray("AliTrackReference",10); + fTRdecay.SetTrack(-1); + for (Int_t i=0;i<4;i++) fVDist[i]=0; + for (Int_t i=0;i<3;i++) fDecayCoord[i]=0; + fCharge = 0; +} + +AliMCInfo::AliMCInfo(const AliMCInfo& info): + TObject(), + fTrackRef(info.fTrackRef), + fTrackRefOut(info.fTrackRefOut), + fTRdecay(info.GetTRdecay()), + fPrimPart(info.fPrimPart), + fParticle(info.fParticle), + fMass(info.GetMass()), + fCharge(info.fCharge), + fLabel(info.fLabel), + fEventNr(info.fEventNr), + fMCtracks(info.fMCtracks), + fPdg(info.fPdg), + fTPCdecay(info.fTPCdecay), + fRowsWithDigitsInn(info.fRowsWithDigitsInn), + fRowsWithDigits(info.fRowsWithDigits), + fRowsTrackLength(info.fRowsTrackLength), + fTPCtrackLength(info.fTPCtrackLength), + fPrim(info.fPrim), + fTPCRow(info.fTPCRow), + fNTPCRef(info.fNTPCRef), // tpc references counter + fNITSRef(info.fNITSRef), // ITS references counter + fNTRDRef(info.fNTRDRef), // TRD references counter + fNTOFRef(info.fNTOFRef), // TOF references counter + fNTPCRefOut(info.fNTPCRefOut), // tpc references counter + fNITSRefOut(info.fNITSRefOut), // ITS references counter + fNTRDRefOut(info.fNTRDRefOut), // TRD references counter + fNTOFRefOut(info.fNTOFRefOut), // TOF references counter + fTPCReferences(0), + fITSReferences(0), + fTRDReferences(0), + fTOFReferences(0) +{ + // + // copy constructor + // + fTPCReferences = (TClonesArray*)info.fTPCReferences->Clone(); + fITSReferences = (TClonesArray*)info.fITSReferences->Clone(); + fTRDReferences = (TClonesArray*)info.fTRDReferences->Clone(); + fTOFReferences = (TClonesArray*)info.fTOFReferences->Clone(); + for (Int_t i=0;i<4;i++) fVDist[i]=info.fVDist[i]; + for (Int_t i=0;i<3;i++) fDecayCoord[i]=info.fDecayCoord[i]; + +} + + +AliMCInfo& AliMCInfo::operator=(const AliMCInfo& info) { + // + // Assignment operator + // + this->~AliMCInfo(); + new (this) AliMCInfo(info); + return *this; +} + + +AliMCInfo::~AliMCInfo() +{ + // + // Destructor of the class + // + if (fTPCReferences) { + delete fTPCReferences; + } + if (fITSReferences){ + delete fITSReferences; + } + if (fTRDReferences){ + delete fTRDReferences; + } + if (fTOFReferences){ + delete fTOFReferences; + } + +} + + + + +void AliMCInfo::Update() +{ + // + // Update MC info + // Calculates some derived variables + // + // + fMCtracks =1; + // + // decay info + fTPCdecay=kFALSE; + if (fTRdecay.GetTrack()>0){ + fDecayCoord[0] = fTRdecay.X(); + fDecayCoord[1] = fTRdecay.Y(); + fDecayCoord[2] = fTRdecay.Z(); + if ( (fTRdecay.R()<250)&&(fTRdecay.R()>85) && (TMath::Abs(fTRdecay.Z())<250) ){ + fTPCdecay=kTRUE; + } + else{ + fDecayCoord[0] = 0; + fDecayCoord[1] = 0; + fDecayCoord[2] = 0; + } + } + // + // + //digits information update + fRowsWithDigits = fTPCRow.RowsOn(); + fRowsWithDigitsInn = fTPCRow.RowsOn(63); // 63 = number of inner rows + fRowsTrackLength = fTPCRow.Last() - fTPCRow.First(); + // + // + // calculate primary ionization per cm + if (fParticle.GetPDG()){ + fMass = fParticle.GetMass(); + fCharge = fParticle.GetPDG()->Charge(); + if (fTPCReferences->GetEntriesFast()>0){ + fTrackRef = *((AliTrackReference*)fTPCReferences->At(0)); + } + if (fMass>0){ + Float_t p = TMath::Sqrt(fTrackRef.Px()*fTrackRef.Px()+ + fTrackRef.Py()*fTrackRef.Py()+ + fTrackRef.Pz()*fTrackRef.Pz()); + if (p>0.001){ + Float_t betagama = p /fMass; + fPrim = AliMathBase::BetheBlochAleph(betagama); + }else fPrim=0; + } + }else{ + fMass =0; + fPrim =0; + } + + + +} + + + + +//////////////////////////////////////////////////////////////////////// +AliTPCdigitRow::AliTPCdigitRow() +{ + Reset(); +} +//////////////////////////////////////////////////////////////////////// +AliTPCdigitRow & AliTPCdigitRow::operator=(const AliTPCdigitRow &digOld) +{ + for (Int_t i = 0; i<32; i++) fDig[i] = digOld.fDig[i]; + return (*this); +} +//////////////////////////////////////////////////////////////////////// +void AliTPCdigitRow::SetRow(Int_t row) +{ + // + // set bit mask for given row + // + if (row >= 8*32) { + // cerr<<"AliTPCdigitRow::SetRow: index "< upto) return total; + if (TESTBIT(fDig[i],j)) total++; + } + } + return total; +} +//////////////////////////////////////////////////////////////////////// +void AliTPCdigitRow::Reset() +{ +// +// resets all rows to zero +// + for (Int_t i = 0; i<32; i++) { + fDig[i] <<= 8; + } +} +//////////////////////////////////////////////////////////////////////// +Int_t AliTPCdigitRow::Last() const +{ +// +// returns the last row number with a digit +// returns -1 if now digits +// + for (Int_t i = 32-1; i>=0; i--) { + for (Int_t j = 7; j >= 0; j--) { + if TESTBIT(fDig[i],j) return i*8+j; + } + } + return -1; +} +//////////////////////////////////////////////////////////////////////// +Int_t AliTPCdigitRow::First() const +{ +// +// returns the first row number with a digit +// returns -1 if now digits +// + for (Int_t i = 0; i<32; i++) { + for (Int_t j = 0; j < 8; j++) { + if (TESTBIT(fDig[i],j)) return i*8+j; + } + } + return -1; +} + + +void AliMCInfo::Clear(Option_t* ){ + // + // clear the content + // + if (fTPCReferences) fTPCReferences->Clear(); + if (fITSReferences) fITSReferences->Clear(); + if (fTRDReferences) fTRDReferences->Clear(); + if (fTOFReferences) fTOFReferences->Clear(); + for (Int_t i=0;i<4;i++) fVDist[i]=0; + for (Int_t i=0;i<3;i++) fDecayCoord[i]=0; + fTRdecay.SetTrack(-1); + fCharge = 0; + fEventNr=-1; + fPrimPart=-1; // index of primary particle in TreeH + fMass=0; // mass of the particle + fCharge=0; // charge of the particle + fLabel=0; // track label + fEventNr=0; // event number + fMCtracks=0; // indication of how many times the track is retuturned back + fPdg=0; //pdg code + fTPCdecay=0; //indicates decay in TPC + fRowsWithDigitsInn=0; // number of rows with digits in the inner sectors + fRowsWithDigits=0; // number of rows with digits in the outer sectors + fRowsTrackLength=0; // last - first row with digit + fTPCtrackLength=0; // distance between first and last track reference + fPrim=0; // theoretical dedx in tpc according particle momenta and mass + fNTPCRef=0; // tpc references counter + fNITSRef=0; // ITS references counter + fNTRDRef=0; // TRD references counter + fNTOFRef=0; // TOF references counter + // + fNTPCRefOut=0; // tpc references counter - out + fNITSRefOut=0; // ITS references counter - out + fNTRDRefOut=0; // TRD references counter - out + fNTOFRefOut=0; // TOF references counter - out +} + + + +void AliMCInfo::CalcTPCrows(TClonesArray * runArrayTR){ + // + // Calculates the numebr of the track references for detectors + // In case of changing direction - curling tracks - the counter is not increasing + // + // Rough calculation + // of the first and last point in the TPC + // + fNTPCRef = 0; + fNITSRef = 0; + fNTRDRef = 0; + fNTOFRef = 0; + fNTPCRefOut = 0; + fNITSRefOut = 0; + fNTRDRefOut = 0; + fNTOFRefOut = 0; + // + // + Float_t tpcminRadius=TMath::Max(90., fParticle.R()); + Float_t tpcmaxRadius=TMath::Min(250.,fParticle.R()); + Int_t nover=-1; + + if (runArrayTR->GetEntriesFast()>0){ + nover=0; + AliTrackReference *ref0 = (AliTrackReference*)runArrayTR->At(0); + Float_t dir = ((ref0->X()*ref0->Px()+ref0->Y()*ref0->Py())>0)? 1.:-1.; //inside or outside + // + // + for (Int_t iTrackRef = 0; iTrackRef < runArrayTR->GetEntriesFast(); iTrackRef++) { + // + AliTrackReference *ref = (AliTrackReference*)runArrayTR->At(iTrackRef); + Float_t newdirection = ((ref->X()*ref->Px()+ref->Y()*ref->Py())>0)? 1.:-1.; //inside or outside + // + // + if (dir*newdirection<0.0) { + nover++; + dir = newdirection; + } + // + if (ref->DetectorId()== AliTrackReference::kTRD){ + if (nover==0) { + tpcmaxRadius =250; + fNTRDRefOut++; + } + fNTRDRef++; + } + if (ref->DetectorId()== AliTrackReference::kITS){ + if (nover==0) { + fNITSRefOut++; + tpcminRadius =90; + } + fNITSRef++; + } + if (ref->DetectorId()== AliTrackReference::kTOF){ + fNTOFRef++; + if (nover==0) { + fNTOFRefOut++; + tpcmaxRadius =250; + } + } + // + if (ref->DetectorId()== AliTrackReference::kTPC){ + fNTPCRef++; + if (nover==0) { + fNTPCRefOut++; + fTrackRefOut = (*ref); + if (ref->R()>tpcmaxRadius) tpcmaxRadius = ref->R(); + if (ref->R()R(); + } + } + if (ref->DetectorId()== AliTrackReference::kDisappeared){ + if (nover==0 &&TMath::Abs(ref->Z())<250){ + tpcmaxRadius = TMath::Min(Float_t(250.),ref->R()); + } + } + } + } // if we have track refs + fTPCtrackLength = tpcmaxRadius-tpcminRadius; + fMCtracks=nover+1; +} + +// +// +// + + + +void AliMCInfo::Update(TParticle * part, TClonesArray * runArrayTR, Double_t pvertex[4], Int_t label){ + // + // + // + Clear(); + fLabel=label; + fParticle=(*part); + AliMCInfo *info = this; + fVDist[0]=part->Vx()-pvertex[0]; + fVDist[1]=part->Vy()-pvertex[1]; + fVDist[2]=part->Vz()-pvertex[2]; + fVDist[3]=part->R()-pvertex[3]; + // + // + // + for (Int_t iTrackRef = 0; iTrackRef < runArrayTR->GetEntriesFast(); iTrackRef++) { + AliTrackReference *trackRef = (AliTrackReference*)runArrayTR->At(iTrackRef); + if (trackRef->DetectorId()== AliTrackReference::kTPC){ + TClonesArray & arr = *(info->fTPCReferences); + new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef); + } + if (trackRef->DetectorId()== AliTrackReference::kITS){ + TClonesArray & arr = *(info->fITSReferences); + new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef); + } + if (trackRef->DetectorId()== AliTrackReference::kTRD){ + TClonesArray & arr = *(info->fTRDReferences); + new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef); + } + if (trackRef->DetectorId()== AliTrackReference::kTOF){ + TClonesArray & arr = *(info->fTOFReferences); + new (arr[arr.GetEntriesFast()]) AliTrackReference(*trackRef); + } + // + // decay case + // + if (trackRef->DetectorId()== AliTrackReference::kDisappeared){ + info->fTRdecay = *trackRef; + } + } + // + Update(); + CalcTPCrows(runArrayTR); +} + diff --git a/PWG1/TPC/AliMCInfo.h b/PWG1/TPC/AliMCInfo.h new file mode 100644 index 00000000000..c989da60c7f --- /dev/null +++ b/PWG1/TPC/AliMCInfo.h @@ -0,0 +1,148 @@ +#ifndef ALIMCINFO_H +#define ALIMCINFO_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + + + +////////////////////////////////////////////////////////////////////////////// +// Class AliGenInfo // +// collect together MC info for comparison purposes - effieciency studies and so on// // +// marian.ivanov@cern.ch // +////////////////////////////////////////////////////////////////////////////// + + + +//////////////////////////////////////////////////////////////////////// +// +// Start of implementation of the class AliTPCdigitRow +// +//////////////////////////////////////////////////////////////////////// + +#include +#include "AliTrackReference.h" + +class TFile; +class AliRunLoader; +class AliStack; + + +class AliTPCdigitRow: public TObject { +public: + AliTPCdigitRow(); + virtual ~AliTPCdigitRow(){;} + void SetRow(Int_t row); + Bool_t TestRow(Int_t row) const ; + AliTPCdigitRow & operator=(const AliTPCdigitRow &digOld); + Int_t RowsOn(Int_t upto=8*32) const; + Int_t Last() const; + Int_t First() const ; + void Reset(); + +private: + UChar_t fDig[32]; // bitmask of the digits presence + ClassDef(AliTPCdigitRow,1) // container for digit pattern +}; + + +//////////////////////////////////////////////////////////////////////// +// +// Start of implementation of the class AliMCInfo +// +//////////////////////////////////////////////////////////////////////// + +class AliMCInfo: public TObject { + friend class AliGenInfoMaker; + friend class AliRecInfoMaker; + friend class AliESDRecInfo; +public: + AliMCInfo(); + ~AliMCInfo(); + AliMCInfo(const AliMCInfo& info); + AliMCInfo& operator=(const AliMCInfo& info); + void Update(TParticle * part, TClonesArray * arrayTr, Double_t pvertex[4], Int_t label); + void Clear(Option_t* = ""); + // + void Update(); + Int_t GetEventNr() const {return fEventNr;} + const AliTrackReference& GetTrackRef() const {return fTrackRef;} + const AliTrackReference& GetTrackRefOut() const {return fTrackRefOut;} + const AliTrackReference& GetTRdecay() const {return fTRdecay;} + TParticle& GetParticle() {return fParticle;} + // + Int_t GetPrimPart() const {return fPrimPart;} + Float_t GetMass() const {return fMass;} + Float_t GetCharge() const {return fCharge;} + Int_t GetLabel() const {return fLabel;} + + Int_t GetMCtracks() const {return fMCtracks;} + Int_t GetPdg() const {return fPdg;} + const Float_t* GetDecayCoord() const {return fDecayCoord;} + const Double_t* GetVDist() const {return fVDist;} + + Bool_t IsTPCdecay() const {return fTPCdecay;} + + Int_t GetRowsWithDigitsInn() const {return fRowsWithDigitsInn;} + Int_t GetRowsWithDigits() const {return fRowsWithDigits;} + Int_t GetRowsTrackLength() const {return fRowsTrackLength;} + Float_t GetPrim() const { return fPrim;} + + AliTPCdigitRow & GetTPCRow() {return fTPCRow;} + Int_t GetNTPCRef() const {return fNTPCRef;} + Int_t GetNITSRef() const {return fNITSRef;} + Int_t GetNTRDRef() const {return fNTRDRef;} + Int_t GetNTOFRef() const {return fNTOFRef;} + const TClonesArray *GetTPCReferences() const { return fTPCReferences;} + const TClonesArray * GetTRDReferences() const { return fTRDReferences;} + const TClonesArray * GetITSReferences() const { return fITSReferences;} + const TClonesArray * GetTOFReferences() const { return fTOFReferences;} + void CalcTPCrows(TClonesArray *arrayTR); +private: + AliTrackReference fTrackRef; // track reference saved in the output tree + AliTrackReference fTrackRefOut; // decay track reference saved in the output tree + AliTrackReference fTRdecay; // track reference at decay point + // + Int_t fPrimPart; // index of primary particle in TreeH + TParticle fParticle; // generated particle + Float_t fMass; // mass of the particle + Float_t fCharge; // charge of the particle + Int_t fLabel; // track label + Int_t fEventNr; // event number + Int_t fMCtracks; // indication of how many times the track is retuturned back + Int_t fPdg; //pdg code + Float_t fDecayCoord[3]; // position of particle decay + Double_t fVDist[4]; //distance of the particle vertex from primary vertex + Bool_t fTPCdecay; //indicates decay in TPC + // + // TPC row information using digits + Int_t fRowsWithDigitsInn; // number of rows with digits in the inner sectors + Int_t fRowsWithDigits; // number of rows with digits in the outer sectors + Int_t fRowsTrackLength; // last - first row with digit + // + // TPC track refernce information + Float_t fTPCtrackLength; // distance between first and last track reference + // + Float_t fPrim; // theoretical dedx in tpc according particle momenta and mass + AliTPCdigitRow fTPCRow; // information about digits row pattern + // + Int_t fNTPCRef; // tpc references counter + Int_t fNITSRef; // ITS references counter + Int_t fNTRDRef; // TRD references counter + Int_t fNTOFRef; // TOF references counter + // + Int_t fNTPCRefOut; // tpc references counter - out + Int_t fNITSRefOut; // ITS references counter - out + Int_t fNTRDRefOut; // TRD references counter - out + Int_t fNTOFRefOut; // TOF references counter - out + + TClonesArray * fTPCReferences; //containner with all track references -in the TPC + TClonesArray * fITSReferences; //container with ITS references + TClonesArray * fTRDReferences; //container with TRD references + TClonesArray * fTOFReferences; //container with TRD references + // + ClassDef(AliMCInfo,2); // container for +}; + + + +#endif diff --git a/PWG1/TPC/AliMCInfoCuts.cxx b/PWG1/TPC/AliMCInfoCuts.cxx new file mode 100644 index 00000000000..bf32212bb0c --- /dev/null +++ b/PWG1/TPC/AliMCInfoCuts.cxx @@ -0,0 +1,162 @@ +/************************************************************************** +* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +//------------------------------------------------------------------------------ +// Impementation of AliMCInfoCuts class. It keeps selection cuts for MC tracks. +// +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +#include +#include +#include + +#include "AliLog.h" +#include "AliMCInfoCuts.h" + +using namespace std; + +ClassImp(AliMCInfoCuts) + +//_____________________________________________________________________________ +AliMCInfoCuts::AliMCInfoCuts(const Char_t* name,const Char_t *title) : +AliAnalysisCuts(name, title) +, fMinRowsWithDigits(0) +, fMaxR(0) +, fMaxVz(0) +, fMinTPCSignal(0) +, fMaxTPCSignal(0) +, fMinTrackLength(0) +, aTrackParticles(0) +{ + // default constructor + + // init data members with defaults + Init(); +} + +//_____________________________________________________________________________ +AliMCInfoCuts::~AliMCInfoCuts() +{ + // destructor + if(aTrackParticles != 0) + { + delete aTrackParticles; + aTrackParticles = 0; + } +} + +//_____________________________________________________________________________ +void AliMCInfoCuts::Init() +{ + // set default values + SetMinRowsWithDigits(); + SetMaxR(); + SetMaxVz(); + SetRangeTPCSignal(); + SetMinTrackLength(); + + // create aTrackParticles array + aTrackParticles = new TArrayI(kNParticles); // max nb. of particles + aTrackParticles->Reset(0); + + // create an array of track particles: e, muons, pions, kaons, protons + if(aTrackParticles != 0) + { + // keep order adding a new particles + AddPdgParticle(0,ep); // e+ + AddPdgParticle(1,em); // e- + AddPdgParticle(2,mup); // mu+ + AddPdgParticle(3,mum); // mu- + AddPdgParticle(4,pip); // pi+ + AddPdgParticle(5,pim); // pi- + AddPdgParticle(6,kp); // K+ + AddPdgParticle(7,km); // K- + AddPdgParticle(8,prot); // p + AddPdgParticle(9,protbar); // p_bar + } +} + +//_____________________________________________________________________________ +void AliMCInfoCuts::AddPdgParticle(Int_t idx, Int_t pdgcode) const +{ + // add particle to the array + if(aTrackParticles != 0) aTrackParticles->AddAt(pdgcode,idx); + else AliDebug(AliLog::kError, "ERROR: Cannot add particle to the array"); +} + +//_____________________________________________________________________________ +Bool_t AliMCInfoCuts::IsPdgParticle(Int_t pdgcode) const +{ + // check PDG particle + if(aTrackParticles == 0) { + AliDebug(AliLog::kError, "ERROR: Cannot get particle array"); + return kFALSE; + } + + Int_t size = aTrackParticles->GetSize(); + for(int i=0; iAt(i)) return kTRUE; + } + return kFALSE; +} + +//_____________________________________________________________________________ +Bool_t AliMCInfoCuts::IsPosPdgParticle(Int_t pdgcode) const +{ + // check PDG particle (only positive charged) + if(aTrackParticles == 0) { + AliDebug(AliLog::kError, "ERROR: Cannot get particle array"); + return kFALSE; + } + + Int_t size = aTrackParticles->GetSize(); + for(int i=0; i 0 && (pdgcode == 11 || pdgcode == 13)) return kFALSE; + if(pdgcode < 0 && (pdgcode != -11 || pdgcode != -13) ) return kFALSE; + // + if(pdgcode == aTrackParticles->At(i)) return kTRUE; + } + return kFALSE; +} + + +//_____________________________________________________________________________ +Long64_t AliMCInfoCuts::Merge(TCollection* list) +{ + // Merge list of objects (needed by PROOF) + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliMCInfoCuts* entry = dynamic_cast(obj); + if (entry == 0) + continue; + + count++; + } + +return count; +} diff --git a/PWG1/TPC/AliMCInfoCuts.h b/PWG1/TPC/AliMCInfoCuts.h new file mode 100644 index 00000000000..0819a9fbadf --- /dev/null +++ b/PWG1/TPC/AliMCInfoCuts.h @@ -0,0 +1,97 @@ +#ifndef ALIMCINFOCUTS_H +#define ALIMCINFOCUTS_H + +//------------------------------------------------------------------------------ +// Class to keep selection cuts for MC tracks. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +#include +#include "AliAnalysisCuts.h" + +class TArrayI; + +class AliMCInfoCuts : public AliAnalysisCuts +{ +public: + AliMCInfoCuts(const Char_t* name ="AliMCInfoCuts", const Char_t *title =""); + virtual ~AliMCInfoCuts(); + + // setters + void SetMinRowsWithDigits(const Int_t min=0) {fMinRowsWithDigits = min;} + void SetMaxR(const Float_t max=1e99) {fMaxR = max;} + void SetMaxVz(const Float_t max=1e99) {fMaxVz = max;} + void SetRangeTPCSignal(const Float_t min=0, const Float_t max=1e99) {fMinTPCSignal = min; fMaxTPCSignal = max;} + void SetMinTrackLength(const Int_t min=0) {fMinTrackLength = min;} + + // getters + Int_t GetMinRowsWithDigits() const {return fMinRowsWithDigits;} + Float_t GetMaxR() const {return fMaxR;} + Float_t GetMaxVz() const {return fMaxVz;} + Float_t GetMinTPCSignal() const {return fMinTPCSignal;} + Float_t GetMaxTPCSignal() const {return fMaxTPCSignal;} + Float_t GetMinTrackLength() const {return fMinTrackLength;} + + Float_t GetEP() const {return ep;} + Float_t GetEM() const {return em;} + Float_t GetMuP() const {return mup;} + Float_t GetMuM() const {return mum;} + Float_t GetPiP() const {return pip;} + Float_t GetPiM() const {return pim;} + Float_t GetKP() const {return kp;} + Float_t GetKM() const {return km;} + Float_t GetProt() const {return prot;} + Float_t GetProtBar() const {return protbar;} + + // cuts init function + void Init(); + + // check MC tracks + virtual Bool_t IsSelected(TObject *) {return kTRUE;} + virtual Bool_t IsSelected(TList *) {return kTRUE;} + + // add particle to array + void AddPdgParticle(Int_t idx=-1, Int_t pdgcode=0) const; + + // check particle in array + Bool_t IsPdgParticle(Int_t pdgcode=0) const; + + // check particle in array + Bool_t IsPosPdgParticle(Int_t pdgcode=0) const; + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* list); + +private: + Int_t fMinRowsWithDigits; // min. number of TPC raws with digits + Float_t fMaxR; // max. R distance from MC vertex + Float_t fMaxVz; // max. Z distance from MC vertex + Float_t fMinTPCSignal; // min. TPC Signal calculated from Bethe Bloch formula + Float_t fMaxTPCSignal; // max. TPC Signal calculated from Bethe Bloch formula + Float_t fMinTrackLength; // min. TPC minimum track length + + TArrayI* aTrackParticles; // array of tracked particles + + // PDG tracked particles (later added to aTrackParticles) + enum enumData { + kNParticles = 10, // number of particles below + ep = kPositron, + em = kElectron, + mup = kMuonPlus, + mum = kMuonMinus, + pip = kPiPlus, + pim = kPiMinus, + kp = kKPlus, + km = kKMinus, + prot = kProton, + protbar = kProtonBar + }; + + AliMCInfoCuts(const AliMCInfoCuts&); // not implemented + AliMCInfoCuts& operator=(const AliMCInfoCuts&); // not implemented + + ClassDef(AliMCInfoCuts, 1) +}; + +#endif // ALIMCINFOCUTS_H diff --git a/PWG1/TPC/AliMCTrackingTestTask.cxx b/PWG1/TPC/AliMCTrackingTestTask.cxx new file mode 100644 index 00000000000..a2a27a2ea22 --- /dev/null +++ b/PWG1/TPC/AliMCTrackingTestTask.cxx @@ -0,0 +1,591 @@ +// +// This class is the task to check the +// Propagation and Update method used in the +// 1. AliExternalTrackParam +// 2. AliTracker +// +// Pure Monte-Carlo data used, not influence of detectors + +// Input - TParticle + Array of track references - (Points alogn track trajectories) +// Output - Trees with track references - no histograms +// MC tree - test for material budget correction +// see function ProcessRefTracker +// MCupdate tree - test for correctness of propagation and update +// see function AliMCTrackingTestTask::FitTrackRefs +// +// Principle - Creates AliExternalTrackParam form 1 Track Refernece - +// Propagate it to other +// Magnetic field and the geometry has to be created before using it + +// +// +// + +// +// ROOT includes +#include +#include +#include +#include +#include + +// ALIROOT includes +#include +#include +#include +#include "AliStack.h" +#include "AliMCEvent.h" +#include "AliMCEventHandler.h" + +#include +#include "AliMCTrackingTestTask.h" +#include "AliGenInfoMaker.h" +#include "AliHelix.h" + +// +#include "AliMCInfo.h" +#include "AliComparisonObject.h" +#include "AliESDRecInfo.h" +#include "AliTPCParamSR.h" +#include "AliTracker.h" +#include "AliTPCseed.h" + +// STL includes +#include + +using namespace std; + +ClassImp(AliMCTrackingTestTask) + +//________________________________________________________________________ +AliMCTrackingTestTask::AliMCTrackingTestTask() : + AliAnalysisTask(), + fMCinfo(0), //! MC event handler + fESD(0), + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(0), + fDebugOutputPath() +{ + // + // Default constructor (should not be used) + // +} + +AliMCTrackingTestTask::AliMCTrackingTestTask(const AliMCTrackingTestTask& /*info*/) : + AliAnalysisTask(), + fMCinfo(0), //! MC event handler + fESD(0), + // + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(), + fDebugOutputPath() +{ + // + // Default constructor + // +} + + + +//________________________________________________________________________ +AliMCTrackingTestTask::AliMCTrackingTestTask(const char *name) : + AliAnalysisTask(name, "AliMCTrackingTestTask"), + fMCinfo(0), //! MC event handler + fESD(0), + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(0), + fDebugOutputPath() +{ + // + // Normal constructor + // + // Input slot #0 works with a TChain + DefineInput(0, TChain::Class()); + // Output slot #0 writes into a TList + DefineOutput(0, TObjArray::Class()); + // + // +} + +AliMCTrackingTestTask::~AliMCTrackingTestTask(){ + // + // + // + if (fDebugLevel>0) printf("AliMCTrackingTestTask::~AliMCTrackingTestTask\n"); + if (fDebugStreamer) delete fDebugStreamer; + fDebugStreamer=0; +} + + +//________________________________________________________________________ +void AliMCTrackingTestTask::ConnectInputData(Option_t *) +{ + // + // Connect the input data + // + if(fDebugLevel>3) + cout << "AnalysisTaskTPCCluster::ConnectInputData()" << endl; + + TTree* tree=dynamic_cast(GetInputData(0)); + if (!tree) { + //Printf("ERROR: Could not read chain from input slot 0"); + } + else { + AliESDInputHandler *esdH = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if (!esdH) { + //Printf("ERROR: Could not get ESDInputHandler"); + } + else { + fESD = esdH->GetEvent(); + //Printf("*** CONNECTED NEW EVENT ****"); + } + } + AliMCEventHandler* mcinfo = (AliMCEventHandler*) (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); + mcinfo->SetReadTR(kTRUE); + + fMCinfo = mcinfo->MCEvent(); + + +} + + + + + + +//________________________________________________________________________ +void AliMCTrackingTestTask::CreateOutputObjects() +{ + // + // Connect the output objects + // + if(fDebugLevel>3) + cout << "AnalysisTaskTPCCluster::CreateOutputObjects()" << endl; + +} + + +//________________________________________________________________________ +void AliMCTrackingTestTask::Exec(Option_t *) { + // + // Execute analysis for current event + // + + if(fDebugLevel>3) + cout << "AliMCTrackingTestTask::Exec()" << endl; + + + // If MC has been connected + + if (!fMCinfo){ + cout << "Not MC info\n" << endl; + }else{ + ProcessMCInfo(); + //mcinfo->Print(); + //DumpInfo(); + } + // +} + + + + +//________________________________________________________________________ +void AliMCTrackingTestTask::Terminate(Option_t *) { + // + // Terminate loop + // + if(fDebugLevel>3) + printf("AliMCTrackingTestTask: Terminate() \n"); + // + if (fDebugLevel>0) printf("AliMCtrackingTestTask::Terminate\n"); + if (fDebugStreamer) delete fDebugStreamer; + fDebugStreamer = 0; + return; +} + + + +TTreeSRedirector *AliMCTrackingTestTask::GetDebugStreamer(){ + // + // Get Debug streamer + // In case debug streamer not yet initialized and StreamLevel>0 create new one + // + if (fStreamLevel==0) return 0; + if (fDebugStreamer) return fDebugStreamer; + TString dsName; + dsName=GetName(); + dsName+="Debug.root"; + dsName.ReplaceAll(" ",""); + fDebugStreamer = new TTreeSRedirector(dsName.Data()); + return fDebugStreamer; +} + + + + + + +AliExternalTrackParam * AliMCTrackingTestTask::MakeTrack(const AliTrackReference* ref, TParticle*part) +{ + // + // Make track out of the track ref + // part - TParticle used to determine chargr + // the covariance matrix - equal 0 - starting from ideal MC position + Double_t xyz[3]={ref->X(),ref->Y(),ref->Z()}; + Double_t pxyz[3]={ref->Px(),ref->Py(),ref->Pz()}; + Double_t cv[21]; + for (Int_t i=0; i<21;i++) cv[i]=0; + if (!part->GetPDG()) return 0; + AliExternalTrackParam * param = new AliExternalTrackParam(xyz,pxyz,cv,TMath::Nint(part->GetPDG()->Charge()/3.)); + return param; +} + +Bool_t AliMCTrackingTestTask::PropagateToPoint(AliExternalTrackParam *param, Double_t *xyz, Double_t mass, Float_t step){ + // + // Propagate track to point xyz using + // AliTracker::PropagateTo functionality + // + // param - track parameters + // xyz - position to propagate + // mass - particle mass + // step - step to be used + Double_t radius=TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]); + AliTracker::PropagateTrackTo(param, radius+step, mass, step, kTRUE,0.99); + AliTracker::PropagateTrackTo(param, radius+0.5, mass, step*0.1, kTRUE,0.99); + Double_t sxyz[3]={0,0,0}; + AliESDVertex vertex(xyz,sxyz); + Bool_t isOK = param->PropagateToDCA(&vertex,AliTracker::GetBz(),10); + return isOK; +} + + +void AliMCTrackingTestTask::ProcessMCInfo(){ + // + // + // + // + TParticle * particle= new TParticle; + TClonesArray * trefs = new TClonesArray("AliTrackReference"); + const Double_t kPcut=0.1; + // + // + // Process tracks + // + Int_t npart = fMCinfo->GetNumberOfTracks(); + if (npart==0) return; + Double_t vertex[4]={0,0,0,0}; + fMCinfo->GetParticleAndTR(0, particle, trefs); + if (particle){ + vertex[0]=particle->Vx(); + vertex[1]=particle->Vy(); + vertex[2]=particle->Vz(); + vertex[3]=particle->R(); + } + // + // + + for (Int_t ipart=0;ipartGetParticleAndTR(ipart, particle, trefs); + if (status<0) continue; + if (!particle) continue; + if (!trefs) continue; + Int_t nref = trefs->GetEntries(); + if (nref<5) continue; + FitTrackRefs(particle,trefs); + AliTrackReference * tpcIn=0; + AliTrackReference * tpcOut=0; + AliTrackReference * trdIn=0; + AliTrackReference * trdOut=0; + AliTrackReference * itsIn=0; + AliTrackReference * itsOut=0; + Double_t rmax=0; + Double_t rmin=1000; + for (Int_t iref=0;irefAt(iref); + if (!ref) continue; + + Float_t dir = ref->X()*ref->Px()+ref->Y()*ref->Py(); + + if (dir<0) break; // oposite direction - looping track - return back + if (ref->P()R()R()DetectorId()==AliTrackReference::kTPC){ + if (!tpcIn) { + tpcIn = ref; + }else{ + if (ref->R()>tpcIn->R()) tpcOut = ref; + } + } + //ITS + if (ref->DetectorId()==AliTrackReference::kITS){ + if (!itsIn) { + itsIn = ref; + }else{ + if (ref->R()>itsIn->R()) itsOut = ref; + } + } + //TRD + if (ref->DetectorId()==AliTrackReference::kTRD){ + if (!trdIn) { + trdIn = ref; + }else{ + if (ref->R()>trdIn->R()) trdOut = ref; + } + } + if (ref->R()R(); + if (ref->R()>rmax) rmax=ref->R(); + } + if (tpcIn && tpcOut) { + ProcessRefTracker(tpcIn,tpcOut,particle,1); + ProcessRefTracker(tpcIn,tpcOut,particle,3); + } + if (itsIn && itsOut) ProcessRefTracker(itsIn,itsOut,particle,0); + if (trdIn && trdOut) ProcessRefTracker(trdIn,trdOut,particle,2); + } +} + + + +void AliMCTrackingTestTask::ProcessRefTracker(AliTrackReference* refIn, AliTrackReference* refOut, TParticle*part,Int_t type){ + // + // Test propagation from In to out + // + AliExternalTrackParam *param = 0; + AliExternalTrackParam *paramMC = 0; + Double_t xyzIn[3]={refIn->X(),refIn->Y(), refIn->Z()}; + Double_t mass = part->GetMass(); + Double_t step=1; + // + param=MakeTrack(refOut,part); + paramMC=MakeTrack(refOut,part); + if (!param) return; + if (type<3) PropagateToPoint(param,xyzIn, mass, step); + if (type==3) { + AliTPCseed seed; + seed.Set(param->GetX(),param->GetAlpha(),param->GetParameter(),param->GetCovariance()); + Float_t alpha= TMath::ATan2(refIn->Y(),refIn->X()); + seed.Rotate(alpha-seed.GetAlpha()); + seed.SetMass(mass); + for (Float_t xlayer= seed.GetX(); xlayer>refIn->R(); xlayer-=step){ + seed.PropagateTo(xlayer); + } + seed.PropagateTo(refIn->R()); + param->Set(seed.GetX(),seed.GetAlpha(),seed.GetParameter(),seed.GetCovariance()); + } + TTreeSRedirector *pcstream = GetDebugStreamer(); + TVectorD gpos(3); + TVectorD gmom(3); + param->GetXYZ(gpos.GetMatrixArray()); + param->GetPxPyPz(gmom.GetMatrixArray()); + if (pcstream){ + (*pcstream)<<"MC"<< + "type="<GetEntries(); + if (nrefsAt(iref); + if (!ref) continue; + Float_t dir = ref->X()*ref->Px()+ref->Y()*ref->Py(); + if (dir<0) break; + if (ref->DetectorId()!=AliTrackReference::kTPC) continue; + if (iref0<0) iref0 = iref; + iref1 = iref; + } + if (iref1-iref0At(iref0); + AliTrackReference * refOut = (AliTrackReference*)trefs->At(iref1); + AliExternalTrackParam *paramPropagate= MakeTrack(refIn,part); + AliExternalTrackParam *paramUpdate = MakeTrack(refIn,part); + paramUpdate->AddCovariance(covar); + Double_t mass = part->GetMass(); + Double_t charge = part->GetPDG()->Charge()/3.; +/* + Float_t alphaIn= TMath::ATan2(refIn->Y(),refIn->X()); + Float_t radiusIn= refIn->R(); + Float_t alphaOut= TMath::ATan2(refOut->Y(),refOut->X()); + Float_t radiusOut= refOut->R(); +*/ + Bool_t isOKP=kTRUE; + Bool_t isOKU=kTRUE; + AliMagF * field = (AliMagF*) TGeoGlobalMagField::Instance()->GetField(); + for (Int_t iref = iref0; iref<=iref1; iref++){ + AliTrackReference * ref = (AliTrackReference*)trefs->At(iref); + Float_t alphaC= TMath::ATan2(ref->Y(),ref->X()); + Double_t pos[3] = {ref->X(), ref->Y(), ref->Z()}; + Double_t mag[3]; + field->Field(pos,mag); + isOKP&=paramPropagate->Rotate(alphaC); + isOKU&=paramUpdate->Rotate(alphaC); + for (Float_t xref= paramPropagate->GetX(); xrefR(); xref++){ + isOKP&=paramPropagate->PropagateTo(xref, mag[2]); + isOKU&=paramUpdate->PropagateTo(xref, mag[2]); + } + isOKP&=paramPropagate->PropagateTo(ref->R(), mag[2]); + isOKU&=paramUpdate->PropagateTo(ref->R(), mag[2]); + Double_t clpos[2] = {0, ref->Z()}; + Double_t clcov[3] = { 0.005,0,0.005}; + isOKU&= paramUpdate->Update(clpos, clcov); + } + TTreeSRedirector *pcstream = GetDebugStreamer(); + if (pcstream){ + TVectorD gposU(3); + TVectorD gmomU(3); + TVectorD gposP(3); + TVectorD gmomP(3); + paramUpdate->GetXYZ(gposU.GetMatrixArray()); + paramUpdate->GetPxPyPz(gmomU.GetMatrixArray()); + paramPropagate->GetXYZ(gposP.GetMatrixArray()); + paramPropagate->GetPxPyPz(gmomP.GetMatrixArray()); + + (*pcstream)<<"MCupdate"<< + "isOKU="<Exec("pwd"); + RegisterDebugOutput(); + +} + + +void AliMCTrackingTestTask::RegisterDebugOutput(){ + // + // + // + // + // store - copy debug output to the destination position + // currently ONLY for local copy + TString dsName; + dsName=GetName(); + dsName+="Debug.root"; + dsName.ReplaceAll(" ",""); + TString dsName2=fDebugOutputPath.Data(); + gSystem->MakeDirectory(dsName2.Data()); + dsName2+=gSystem->HostName(); + gSystem->MakeDirectory(dsName2.Data()); + dsName2+="/"; + dsName2+=gSystem->BaseName(gSystem->pwd()); + dsName2+="/"; + gSystem->MakeDirectory(dsName2.Data()); + dsName2+=dsName; + AliInfo(Form("copy %s\t%s\n",dsName.Data(),dsName2.Data())); + printf("copy %s\t%s\n",dsName.Data(),dsName2.Data()); + TFile::Cp(dsName.Data(),dsName2.Data()); +} + + +/* + gSystem->AddIncludePath("-I$ALICE_ROOT/TPC/macros"); + gROOT->LoadMacro("$ALICE_ROOT/TPC/macros/AliXRDPROOFtoolkit.cxx+") + AliXRDPROOFtoolkit tool; + TChain * chain = tool.MakeChain("mctracking.txt","MC",0,100); + chain->Lookup(); + // + // + chain->SetAlias("pdg","(p.fPdgCode)"); + chain->SetAlias("dPRec","(refOut.P()-par.P())/refIn.P()"); + chain->SetAlias("dPMC","(refOut.P()-refIn.P())/refIn->P()"); + chain->SetAlias("dPtRec","(refOut.Pt()-par.Pt())/refIn.Pt()"); + chain->SetAlias("dPtMC","(refOut.Pt()-refIn.Pt())/refIn->Pt()"); + + + // ITS + chain->Draw("-sqrt(dPRec):-sqrt(dPMC)","abs(pdg)!=11&&type==0&&p.Pt()<0.5&&abs(p.R())<1&&abs(refOut.fZ)<220"); + htemp->SetYTitle("#sqrt{#DeltaP_{rec}/P}"); + htemp->SetXTitle("#sqrt{#DeltaP_{mc}/P}"); + gPad->SaveAs("picLoss/dPcorr_ITS_step1.gif"); + gPad->SaveAs("picLoss/dPcorr_ITS_step1.eps"); + // TPC + chain->Draw("-sqrt(dPRec):-sqrt(dPMC)","abs(pdg)!=11&&type==1&&p.Pt()<0.5&&abs(p.R())<1&&abs(refOut.fZ)<220"); + htemp->SetYTitle("#sqrt{#DeltaP_{rec}/P}"); + htemp->SetXTitle("#sqrt{#DeltaP_{mc}/P}"); + gPad->SaveAs("picLoss/dPcorr_TPC_step1.gif"); + gPad->SaveAs("picLoss/dPcorr_TPC_step1.eps"); + // + // TPC + chain->Draw("-sqrt(dPRec):-sqrt(dPMC)","abs(pdg)!=11&&type==3&&p.Pt()<0.5&&abs(p.R())<1&&abs(refOut.fZ)<220"); + htemp->SetYTitle("#sqrt{#DeltaP_{rec}/P}"); + htemp->SetXTitle("#sqrt{#DeltaP_{mc}/P}"); + gPad->SaveAs("picLoss/dPcorr_TPCseed_step1.gif"); + gPad->SaveAs("picLoss/dPcorr_TPCseed_step1.eps"); + + + // TRD + chain->Draw("-sqrt(dPRec):-sqrt(dPMC)","abs(pdg)!=11&&type==2&&p.Pt()<0.5&&abs(p.R())<1&&abs(refOut.fZ)<220"); + htemp->SetYTitle("#sqrt{#DeltaP_{rec}/P}"); + htemp->SetXTitle("#sqrt{#DeltaP_{mc}/P}"); + gPad->SaveAs("picLoss/dPcorr_TRD_step1.gif"); + gPad->SaveAs("picLoss/dPcorr_TRD_step1.eps"); + + // + // + // + chain->Draw("(par.Pt()-refIn.Pt())/refIn.Pt()>>his(100,-0.02,0.02)","abs(pdg)!=11&&type==3&&p.Pt()<0.5&&abs(p.R())<1&&abs(refOut.fZ)<220"); + his->SetXTitle("(P_{trec}-P_{tmc})/P_{tmc}"); + gPad->SaveAs("picLoss/dPtcorr_TPCseed_step1_1D.eps"); + gPad->SaveAs("picLoss/dPtcorr_TPCseed_step1_1D.gif"); + + chain->Draw("(par.P()-refIn.P())/refIn.P()>>his(100,-0.02,0.02)","abs(pdg)!=11&&type==3&&p.Pt()<0.5&&abs(p.R())<1&&abs(refOut.fZ)<220"); + his->SetXTitle("(P_{rec}-P_{mc})/P_{mc}"); + gPad->SaveAs("picLoss/dPcorr_TPCseed_step1_1D.eps"); + gPad->SaveAs("picLoss/dPcorr_TPCseed_step1_1D.gif"); +*/ diff --git a/PWG1/TPC/AliMCTrackingTestTask.h b/PWG1/TPC/AliMCTrackingTestTask.h new file mode 100644 index 00000000000..0abe077f70f --- /dev/null +++ b/PWG1/TPC/AliMCTrackingTestTask.h @@ -0,0 +1,73 @@ +#ifndef ALIMCTRACKINGTESTTASK_H +#define ALIMCTRACKINGTESTTASK_H + +// ROOT includes +#include +#include +#include + +// AliRoot includes +#include +#include +#include +#include +#include +#include +#include +class AliGenInfoMaker; +class TTreeSRedirector; +class AliMCEventHadnler; +class TParticle; +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliMCEvent; +class AliComparisonObject; + +class AliMCTrackingTestTask : public AliAnalysisTask { + public: + AliMCTrackingTestTask(); + AliMCTrackingTestTask(const char *name); + virtual ~AliMCTrackingTestTask(); + + virtual void ConnectInputData(Option_t *); + virtual void CreateOutputObjects(); + virtual void Exec(Option_t *option); + virtual void Terminate(Option_t *); + virtual void FinishTaskOutput(); + void SetDebugOuputhPath(const char * name){fDebugOutputPath=name;} + + // + void ProcessMCInfo(); + void ProcessRefTracker(AliTrackReference* refIn, AliTrackReference* refOut, TParticle*part, Int_t type); + + void FitTrackRefs(TParticle * part, TClonesArray * trefs); + + // + // debug streamer part + // + TTreeSRedirector *GetDebugStreamer(); + void SetStreamLevel(Int_t streamLevel){fStreamLevel=streamLevel;} + void SetDebugLevel(Int_t level) {fDebugLevel = level;} + Int_t GetStreamLevel() const {return fStreamLevel;} + Int_t GetDebugLevel() const {return fDebugLevel;} + // + static AliExternalTrackParam * MakeTrack(const AliTrackReference* ref, TParticle*part); + static Bool_t PropagateToPoint(AliExternalTrackParam *param, Double_t *xyz, Double_t mass, Float_t step); + protected: + void RegisterDebugOutput(); + AliMCTrackingTestTask(const AliMCTrackingTestTask& /*info*/); + AliMCTrackingTestTask& operator=(const AliMCTrackingTestTask& /*info*/) { return *this;} + AliMCEvent * fMCinfo; //! MC event handler + AliESDEvent * fESD; //! current esd event + // + // + // + TTreeSRedirector *fDebugStreamer; //! debug streamer + Int_t fStreamLevel; // debug stream level + Int_t fDebugLevel; // debug level + TString fDebugOutputPath; // debug output path + ClassDef(AliMCTrackingTestTask, 1); // Analysis task base class for tracks +}; + +#endif diff --git a/PWG1/TPC/AliMaterialBudget.cxx b/PWG1/TPC/AliMaterialBudget.cxx new file mode 100644 index 00000000000..1650a1505f8 --- /dev/null +++ b/PWG1/TPC/AliMaterialBudget.cxx @@ -0,0 +1,1052 @@ + + + + +// +// + +// This class estiamtes the material budget of the inner detectors in ALICE based +// on the "upper/lower track matching"-method of the ALICE TPC. + +// +// +// + +// + + + + +// ROOT includes +#include +#include +#include +#include +#include +#include "TGeoGlobalMagField.h" + +// ALIROOT includes +#include +#include +#include +#include "AliStack.h" +#include "AliMCEvent.h" +#include "AliMCEventHandler.h" + +#include +#include "AliMaterialBudget.h" +#include "AliGenInfoMaker.h" +#include "AliHelix.h" + +// +#include "AliMCInfo.h" +#include "AliComparisonObject.h" +#include "AliESDRecInfo.h" +#include "AliTPCParamSR.h" +#include "AliTracker.h" +#include "AliTPCseed.h" + +// STL includes +#include + +using namespace std; + +ClassImp(AliMaterialBudget) + +//________________________________________________________________________ +AliMaterialBudget::AliMaterialBudget() : + AliAnalysisTask(), + fMCinfo(0), //! MC event handler + fESD(0), + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(0), + fDebugOutputPath(), + fListHist(0), + fHistMult(0), + fCutMaxD(5), // maximal distance in rfi ditection + fCutMaxDz(40), // maximal distance in z ditection + fCutTheta(0.03), // maximal distan theta + fCutMinDir(-0.99) // direction vector products +{ + // + // Default constructor (should not be used) + // +} + +AliMaterialBudget::AliMaterialBudget(const AliMaterialBudget& /*info*/) : + AliAnalysisTask(), + fMCinfo(0), //! MC event handler + fESD(0), + // + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(), + fDebugOutputPath(), + fListHist(0), + fHistMult(0), + fCutMaxD(5), // maximal distance in rfi ditection + fCutMaxDz(40), // maximal distance in z ditection + fCutTheta(0.03), // maximal distan theta + fCutMinDir(-0.99) // direction vector products +{ + // + // Default constructor + // +} + + + +//________________________________________________________________________ +AliMaterialBudget::AliMaterialBudget(const char *name) : + AliAnalysisTask(name, "AliMaterialBudget"), + fMCinfo(0), //! MC event handler + fESD(0), + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(0), + fDebugOutputPath(), + fListHist(0), + fHistMult(0), + fCutMaxD(5), // maximal distance in rfi ditection + fCutMaxDz(40), // maximal distance in z ditection + fCutTheta(0.03), // maximal distan theta + fCutMinDir(-0.99) // direction vector products +{ + // + // Normal constructor + // + // Input slot #0 works with a TChain + DefineInput(0, TChain::Class()); + // Output slot #0 writes into a TList + DefineOutput(0, TList::Class()); + // + // +} + +AliMaterialBudget::~AliMaterialBudget(){ + // + // + // + if (fDebugLevel>0) printf("AliMaterialBudget::~AliMaterialBudget\n"); + if (fDebugStreamer) delete fDebugStreamer; + fDebugStreamer=0; +} + + +//________________________________________________________________________ +void AliMaterialBudget::ConnectInputData(Option_t *) +{ + // + // Connect the input data + // + if(fDebugLevel>3) + cout << "AnalysisTaskTPCCluster::ConnectInputData()" << endl; + + TTree* tree=dynamic_cast(GetInputData(0)); + if (!tree) { + //Printf("ERROR: Could not read chain from input slot 0"); + } + else { + AliESDInputHandler *esdH = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if (!esdH) { + //Printf("ERROR: Could not get ESDInputHandler"); + } + else { + esdH->SetActiveBranches("ESDfriend"); + fESD = esdH->GetEvent(); + //Printf("*** CONNECTED NEW EVENT ****"); + } + } + AliMCEventHandler* mcinfo = (AliMCEventHandler*) (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); + mcinfo->SetReadTR(kTRUE); + + fMCinfo = mcinfo->MCEvent(); + + +} + + + + + + +//________________________________________________________________________ +void AliMaterialBudget::CreateOutputObjects() +{ + // + // Connect the output objects + // + if(fDebugLevel>3) + cout << "AnalysisTaskTPCCluster::CreateOutputObjects()" << endl; + // + fListHist = new TList(); + fListHist->SetOwner(); + // + fHistMult = new TH1F("HistMult", "Number of Tracks per Event; number of tracks per event; number of tracks",501,-0.5,500.5); + fListHist->Add(fHistMult); + + +} + + +//________________________________________________________________________ +void AliMaterialBudget::Exec(Option_t *) { + // + // Execute analysis for current event + // + + if(fDebugLevel>3) + cout << "AliMaterialBudget::Exec()" << endl; + + fHistMult->Fill(fESD->GetNumberOfTracks()); + //FindPairs(fESD); // nearly everything takes place in find pairs... + + // If MC has been connected + + if (!fMCinfo){ + cout << "Not MC info\n" << endl; + }else{ + ProcessMCInfo(); + //mcinfo->Print(); + //DumpInfo(); + } + // + PostData(0, fListHist); +} + + + + +//________________________________________________________________________ +void AliMaterialBudget::Terminate(Option_t *) { + // + // Terminate loop + // + if(fDebugLevel>3) + printf("AliMaterialBudget: Terminate() \n"); + // + if (fDebugLevel>0) printf("AliMCtrackingTestTask::Terminate\n"); + if (fDebugStreamer) delete fDebugStreamer; + fDebugStreamer = 0; + return; +} + + + +TTreeSRedirector *AliMaterialBudget::GetDebugStreamer(){ + // + // Get Debug streamer + // In case debug streamer not yet initialized and StreamLevel>0 create new one + // + if (fStreamLevel==0) return 0; + if (fDebugStreamer) return fDebugStreamer; + TString dsName; + dsName=GetName(); + dsName+="Debug.root"; + dsName.ReplaceAll(" ",""); + fDebugStreamer = new TTreeSRedirector(dsName.Data()); + return fDebugStreamer; +} + + + + + + +AliExternalTrackParam * AliMaterialBudget::MakeTrack(const AliTrackReference* ref, TParticle*part) +{ + // + // Make track out of the track ref + // part - TParticle used to determine chargr + // the covariance matrix - equal 0 - starting from ideal MC position + if (!part->GetPDG()) return 0; + Double_t xyz[3]={ref->X(),ref->Y(),ref->Z()}; + Double_t pxyz[3]={ref->Px(),ref->Py(),ref->Pz()}; + Double_t charge = TMath::Nint(part->GetPDG()->Charge()/3.); + if (ref->X()*ref->Px()+ref->Y()*ref->Py() <0){ + pxyz[0]*=-1; + pxyz[1]*=-1; + pxyz[2]*=-1; + charge*=-1.; + } + Double_t cv[21]; + for (Int_t i=0; i<21;i++) cv[i]=0; + AliExternalTrackParam * param = new AliExternalTrackParam(xyz,pxyz,cv,charge); + return param; +} + +Bool_t AliMaterialBudget::PropagateToPoint(AliExternalTrackParam *param, Double_t *xyz, Double_t mass, Float_t step){ + // + // Propagate track to point xyz using + // AliTracker::PropagateTo functionality + // + // param - track parameters + // xyz - position to propagate + // mass - particle mass + // step - step to be used + Double_t radius=TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]); + AliTracker::PropagateTrackToBxByBz(param, radius+step, mass, step, kTRUE,0.99); + AliTracker::PropagateTrackToBxByBz(param, radius+0.5, mass, step*0.1, kTRUE,0.99); + Double_t sxyz[3]={0,0,0}; + AliESDVertex vertex(xyz,sxyz); + Bool_t isOK = param->PropagateToDCA(&vertex,AliTracker::GetBz(),10); + return isOK; +} + + +void AliMaterialBudget::ProcessMCInfo(){ + // + // + // + // + TParticle * particle= new TParticle; + TClonesArray * trefs = new TClonesArray("AliTrackReference"); + const Double_t kPcut=0.05; + const Double_t kMinDrITS = 2.; // minimal distance between references + const Double_t kMinDrTRD = 8.; // minimal distance between references + const Double_t kMinDrTOF = 10.; // minimal distance between references + // + // + // Process tracks + // + Int_t npart = fMCinfo->GetNumberOfTracks(); + if (npart==0) return; + Double_t vertex[4]={0,0,0,0}; + fMCinfo->GetParticleAndTR(0, particle, trefs); + if (particle){ + vertex[0]=particle->Vx(); + vertex[1]=particle->Vy(); + vertex[2]=particle->Vz(); + vertex[3]=particle->R(); + } + // + // + AliTrackReference dummy,*pdummy= &dummy; + AliExternalTrackParam epdummy,*pepdummy= &epdummy; + Int_t nRefITS =0; + Int_t nRefTPC =0; + Int_t nRefTRD =0; + Int_t nRefTOF =0; + AliTrackReference * refITS0, *refITS1; + AliTrackReference * refTPC0, *refTPC1; + AliTrackReference * refTPCIn0, *refTPCIn1; + AliTrackReference * refTRD0, *refTRD1; + AliTrackReference * refTOF0, *refTOF1; + AliTrackReference *refMinR; + // + for (Int_t ipart=0;ipartGetParticleAndTR(ipart, particle, trefs); + AliMCParticle * pp = (AliMCParticle*) fMCinfo->GetTrack(ipart); + if (!pp) continue; + if (particle->P()GetMass(); + + // RESET + nRefITS =0; + nRefTPC =0; + nRefTRD =0; + nRefTOF =0; + refITS0=pdummy; refITS1=pdummy; + refTPC0=pdummy; refTPC1=pdummy; + refTPCIn0=pdummy; refTPCIn1=pdummy; + refTRD0=pdummy; refTRD1=pdummy; + refTOF0=pdummy; refTOF1=pdummy; + refMinR = pdummy; + // + Int_t nref = pp->GetNumberOfTrackReferences(); + if (nref==0) continue; + for (Int_t iref = 0; iref < nref; iref++) { + AliTrackReference *ref = pp->GetTrackReference(iref); + if (ref->DetectorId()==AliTrackReference::kDisappeared) continue; + // if (ref.Px()*particle.Px()+ref.Py()*particle.Py()<0) break; // returning track + // + if (ref->DetectorId()==AliTrackReference::kITS){ + if (TMath::Abs(ref->R()-refITS1->R())>kMinDrITS) { + refITS1 = ref; + nRefITS++; + } + if (refITS0==pdummy) refITS0=ref; + } + if (ref->DetectorId()==AliTrackReference::kTPC){ + nRefTPC++; + refTPC1 = ref; + if (refTPC0==pdummy) refTPC0=ref; + } + if (ref->DetectorId()==AliTrackReference::kTRD){ + if (TMath::Abs(ref->R()-refTRD1->R())>kMinDrTRD) { + refTRD1 = ref; + nRefTRD++; + } + if (refTRD0==pdummy) refTRD0=ref; + } + if (ref->DetectorId()==AliTrackReference::kTOF){ + if (TMath::Abs(ref->X()-refTOF1->X()) + TMath::Abs(ref->Y()-refTOF1->Y()) + TMath::Abs(ref->Z()-refTOF1->Z())>kMinDrTOF) { + refTOF1 = ref; + nRefTOF++; + } + if (refTOF0==pdummy) refTOF0=ref; + } + // + // "find inner track ref" + if (ref->DetectorId()==AliTrackReference::kTPC){ + if (ref->Px()*ref->X()+ref->Py()*ref->Y()<0){ + // track in + if (refTPCIn0 == pdummy) refTPCIn0=ref; + if (refTPCIn0 != pdummy && refTPCIn0->R()>ref->R()) + refTPCIn0=ref; + } + if (ref->Px()*ref->X()+ref->Py()*ref->Y()>0){ + // track in + if (refTPCIn1 == pdummy) refTPCIn1=ref; + if (refTPCIn1 != pdummy && refTPCIn1->R()>ref->R()) + refTPCIn1=ref; + } + } + + + if (refMinR==pdummy && ref->P()>0 ){ + refMinR=ref; + } + if (refMinR->R()>ref->R() && ref->P()>0 ) refMinR=ref; + + } + // + AliExternalTrackParam * trackMC = pepdummy; + //track0->GetDZ(0,0,0,bz,dvertex0) + Float_t dist[2]={0,0}; + AliMagF* field = (AliMagF*) TGeoGlobalMagField::Instance()->GetField(); + Double_t esdfield= fESD->GetMagneticField(); + Double_t xyz[3]={0,0,0}; + Double_t bxyz[3]={0,0,0}; + field->Field(xyz,bxyz); + if (refMinR->P()>0) { + trackMC = MakeTrack(refMinR,particle); + trackMC->GetDZ(0,0,0,bxyz[2],dist); + } + Double_t alphaTOF0 = TMath::ATan2(refTOF0->Y(),refTOF0->X()); + Double_t alphaTOF1 = TMath::ATan2(refTOF1->Y(),refTOF1->X()); + Int_t dsecTOF = TMath::Nint(180*(alphaTOF0-alphaTOF1)/(TMath::Pi()*20.)-0.5); + // + // make the two different TPC tracks and propagate them to their DCA + // + Double_t dP = 0; + Bool_t statusProp = kFALSE; + Double_t dY = 0; + Double_t dZ = 0; + AliExternalTrackParam * track0 = pepdummy; + AliExternalTrackParam * track1 = pepdummy; + AliExternalTrackParam * otrack0 = pepdummy; + AliExternalTrackParam * otrack1 = pepdummy; + if (refTPCIn0!=pdummy && refTPCIn1!=pdummy) { + track0 = MakeTrack(refTPCIn0,particle); + track1 = MakeTrack(refTPCIn1,particle); + otrack0 = MakeTrack(refTPCIn0,particle); + otrack1 = MakeTrack(refTPCIn1,particle); + dP = track0->P() - track1->P(); // momentum loss + statusProp = AliMaterialBudget::PropagateCosmicToDCA(track0,track1,mass); + if (statusProp) { + dY = track0->GetY() - track1->GetY(); + dZ = track0->GetZ() - track1->GetZ(); + } + } + // + TTreeSRedirector *pcstream = GetDebugStreamer(); + if (pcstream){ + char name[100]; + for (Int_t id=0; id<3;id++){ + + // if (id==0) sprintf(name,"mcAll"); // all tracks: inconvenient to cut if on is only interest in tracks which reach the TPC + if (id==0) continue; // require TPC + if (id==1) sprintf(name,"mcITS"); + if (id==2) sprintf(name,"mcTPC"); + if (id==1&& nRefITS==0) continue; + if (id==2&& nRefTPC==0) continue; + + (*pcstream)<X(),refIn->Y(), refIn->Z()}; + Double_t mass = part->GetMass(); + Double_t step=1; + // + param=MakeTrack(refOut,part); + paramMC=MakeTrack(refOut,part); + if (!param) return; + if (type<3) PropagateToPoint(param,xyzIn, mass, step); + if (type==3) { + AliTPCseed seed; + seed.Set(param->GetX(),param->GetAlpha(),param->GetParameter(),param->GetCovariance()); + Float_t alpha= TMath::ATan2(refIn->Y(),refIn->X()); + seed.Rotate(alpha-seed.GetAlpha()); + seed.SetMass(mass); + for (Float_t xlayer= seed.GetX(); xlayer>refIn->R(); xlayer-=step){ + seed.PropagateTo(xlayer); + } + seed.PropagateTo(refIn->R()); + param->Set(seed.GetX(),seed.GetAlpha(),seed.GetParameter(),seed.GetCovariance()); + } + TTreeSRedirector *pcstream = GetDebugStreamer(); + TVectorD gpos(3); + TVectorD gmom(3); + param->GetXYZ(gpos.GetMatrixArray()); + param->GetPxPyPz(gmom.GetMatrixArray()); + if (pcstream){ + (*pcstream)<<"MC"<< + "type="<GetEntries(); + if (nrefsAt(iref); + if (!ref) continue; + Float_t dir = ref->X()*ref->Px()+ref->Y()*ref->Py(); + if (dir<0) break; + if (ref->DetectorId()!=AliTrackReference::kTPC) continue; + if (iref0<0) iref0 = iref; + iref1 = iref; + } + if (iref1-iref0At(iref0); + AliTrackReference * refOut = (AliTrackReference*)trefs->At(iref1); + AliExternalTrackParam *paramPropagate= MakeTrack(refIn,part); + AliExternalTrackParam *paramUpdate = MakeTrack(refIn,part); + paramUpdate->AddCovariance(covar); + Double_t mass = part->GetMass(); + Double_t charge = part->GetPDG()->Charge()/3.; +/* + Float_t alphaIn= TMath::ATan2(refIn->Y(),refIn->X()); + Float_t radiusIn= refIn->R(); + Float_t alphaOut= TMath::ATan2(refOut->Y(),refOut->X()); + Float_t radiusOut= refOut->R(); +*/ + Bool_t isOKP=kTRUE; + Bool_t isOKU=kTRUE; + AliMagF * field = (AliMagF*) TGeoGlobalMagField::Instance()->GetField(); + for (Int_t iref = iref0; iref<=iref1; iref++){ + AliTrackReference * ref = (AliTrackReference*)trefs->At(iref); + Float_t alphaC= TMath::ATan2(ref->Y(),ref->X()); + Double_t pos[3] = {ref->X(), ref->Y(), ref->Z()}; + Double_t mag[3]; + field->Field(pos,mag); + isOKP&=paramPropagate->Rotate(alphaC); + isOKU&=paramUpdate->Rotate(alphaC); + for (Float_t xref= paramPropagate->GetX(); xrefR(); xref++){ + isOKP&=paramPropagate->PropagateTo(xref, mag[2]); + isOKU&=paramUpdate->PropagateTo(xref, mag[2]); + } + isOKP&=paramPropagate->PropagateTo(ref->R(), mag[2]); + isOKU&=paramUpdate->PropagateTo(ref->R(), mag[2]); + Double_t clpos[2] = {0, ref->Z()}; + Double_t clcov[3] = { 0.005,0,0.005}; + isOKU&= paramUpdate->Update(clpos, clcov); + } + TTreeSRedirector *pcstream = GetDebugStreamer(); + if (pcstream){ + TVectorD gposU(3); + TVectorD gmomU(3); + TVectorD gposP(3); + TVectorD gmomP(3); + paramUpdate->GetXYZ(gposU.GetMatrixArray()); + paramUpdate->GetPxPyPz(gmomU.GetMatrixArray()); + paramPropagate->GetXYZ(gposP.GetMatrixArray()); + paramPropagate->GetPxPyPz(gmomP.GetMatrixArray()); + + (*pcstream)<<"MCupdate"<< + "isOKU="<3) + cout << "AliMaterialBudget::FindPairs()" << endl; + + + AliESDfriend *ESDfriend=static_cast(event->FindListObject("AliESDfriend")); + Int_t ntracks=event->GetNumberOfTracks(); + TObjArray tpcSeeds(ntracks); + if (ntracks==0) return; + Double_t vtxx[3]={0,0,0}; + Double_t svtxx[3]={0.000001,0.000001,100.}; + AliESDVertex vtx(vtxx,svtxx); + // + //track loop + // + for (Int_t i=0;iGetTrack(i); + const AliExternalTrackParam * trackIn = track->GetInnerParam(); + const AliExternalTrackParam * trackOut = track->GetOuterParam(); + if (!trackIn) continue; + if (!trackOut) continue; + AliESDfriendTrack *friendTrack = ESDfriend->GetTrack(i); + TObject *calibObject; + AliTPCseed *seed = 0; + for (Int_t l=0;(calibObject=friendTrack->GetCalibObject(l));++l) { + if ((seed=dynamic_cast(calibObject))) break; + } + if (seed) tpcSeeds.AddAt(seed,i); + } + + if (ntracks<2) return; + // + // Find pairs + // + for (Int_t i=0;iGetTrack(i); + // track0 - choosen upper part + if (!track0) continue; + if (!track0->GetOuterParam()) continue; + if (track0->GetOuterParam()->GetAlpha()<0) continue; + Double_t dir0[3]; + track0->GetDirection(dir0); + for (Int_t j=0;jGetTrack(j); + //track 1 lower part + if (!track1) continue; + if (!track1->GetOuterParam()) continue; + if (track1->GetOuterParam()->GetAlpha()>0) continue; + // + Double_t dir1[3]; + track1->GetDirection(dir1); + + AliTPCseed * seed0 = (AliTPCseed*) tpcSeeds.At(i); + AliTPCseed * seed1 = (AliTPCseed*) tpcSeeds.At(j); + if (! seed0) continue; + if (! seed1) continue; + // + Float_t dir = (dir0[0]*dir1[0] + dir0[1]*dir1[1] + dir0[2]*dir1[2]); + Float_t d0 = track0->GetLinearD(0,0); + Float_t d1 = track1->GetLinearD(0,0); + // + // conservative cuts - convergence to be guarantied + // applying before track propagation + if (TMath::Abs(d0+d1)>fCutMaxD) continue; // distance to the 0,0 + if (dir>fCutMinDir) continue; // direction vector product + Float_t bz = AliTracker::GetBz(); + Float_t dvertex0[2]; //distance to 0,0 + Float_t dvertex1[2]; //distance to 0,0 + track0->GetDZ(0,0,0,bz,dvertex0); + track1->GetDZ(0,0,0,bz,dvertex1); + if (TMath::Abs(dvertex0[1])>250) continue; + if (TMath::Abs(dvertex1[1])>250) continue; + // + // + // + Float_t dmax = TMath::Max(TMath::Abs(d0),TMath::Abs(d1)); + AliExternalTrackParam param0(*track0); + AliExternalTrackParam param1(*track1); + // + // Propagate using Magnetic field and correct fo material budget + // + AliTracker::PropagateTrackToBxByBz(¶m0,dmax+1,0.0005,3,kTRUE); + AliTracker::PropagateTrackToBxByBz(¶m1,dmax+1,0.0005,3,kTRUE); + // + // Propagate rest to the 0,0 DCA - z should be ignored + // + Bool_t b0 = param0.PropagateToDCA(&vtx,bz,1000); + Bool_t b1 = param1.PropagateToDCA(&vtx,bz,1000); + // + param0.GetDZ(0,0,0,bz,dvertex0); + param1.GetDZ(0,0,0,bz,dvertex1); + if (TMath::Abs(param0.GetZ()-param1.GetZ())>fCutMaxDz) continue; + // + Double_t xyz0[3];//,pxyz0[3]; + Double_t xyz1[3];//,pxyz1[3]; + param0.GetXYZ(xyz0); + param1.GetXYZ(xyz1); + Bool_t isPair = IsPair(¶m0,¶m1); + // + // HERE WE WILL PUT THE ACCESS TO THE MC TRACKS AND MATCH THESE !!!! + // + Int_t label0 = TMath::Abs(track0->GetLabel()); + AliMCParticle *mcParticle0 = (AliMCParticle*) fMCinfo->GetTrack(label0); + TParticle *particle0 = mcParticle0->Particle(); + AliTrackReference *ref0 = GetFirstTPCTrackRef(mcParticle0); // get the first TPC track reference + if (!ref0) continue; + AliExternalTrackParam *paramMC0 = 0; + paramMC0 = MakeTrack(ref0, particle0); + // + Int_t label1 = TMath::Abs(track1->GetLabel()); + AliMCParticle *mcParticle1 = (AliMCParticle*) fMCinfo->GetTrack(label1); + TParticle *particle1 = mcParticle1->Particle(); + AliTrackReference *ref1 = GetFirstTPCTrackRef(mcParticle1); // get the first TPC track reference + if (!ref1) continue; + AliExternalTrackParam *paramMC1 = 0; + paramMC1 = MakeTrack(ref1, particle1); + // + // ACCESS TOF INFORMATION + Int_t nTrackRefTOF0 = 0; + Int_t nTrackRefITS0 = 0; + AliTrackReference * refLastTOF0 = 0; + AliTrackReference * refFirstTOF0 = GetAllTOFinfo(mcParticle0, nTrackRefTOF0, nTrackRefITS0); + Float_t alphaTOF0 = 0; + if (refFirstTOF0) alphaTOF0 = refFirstTOF0->Alpha(); + // + Int_t nTrackRefTOF1 = 0; + Int_t nTrackRefITS1 = 0; + AliTrackReference * refLastTOF1 = 0; + AliTrackReference * refFirstTOF1 =GetAllTOFinfo(mcParticle1, nTrackRefTOF1, nTrackRefITS1); + Float_t alphaTOF1 = 0; + if (refFirstTOF1) alphaTOF1 = refFirstTOF1->Alpha(); + //cout << " STATUS "<0){ + TTreeSRedirector * cstream = GetDebugStreamer(); + AliExternalTrackParam *ip0 = (AliExternalTrackParam *)track0->GetInnerParam(); + AliExternalTrackParam *ip1 = (AliExternalTrackParam *)track1->GetInnerParam(); + AliExternalTrackParam *op0 = (AliExternalTrackParam *)track0->GetOuterParam(); + AliExternalTrackParam *op1 = (AliExternalTrackParam *)track1->GetOuterParam(); + // + // + // + if (cstream) { + (*cstream) << "Track0" << + "dir="<GetParameter(); + const Double_t *p1 = tr1->GetParameter(); + if (TMath::Abs(p0[3]+p1[3])>fCutTheta) return kFALSE; + if (TMath::Abs(p0[1]-p1[1])>fCutMaxDz) return kFALSE; + if (TMath::Abs(p0[0]+p1[0])>fCutMaxD) return kFALSE; + + Double_t d0[3], d1[3]; + tr0->GetDirection(d0); + tr1->GetDirection(d1); + if (d0[0]*d1[0] + d0[1]*d1[1] + d0[2]*d1[2] >fCutMinDir) return kFALSE; + // + return kTRUE; +} + + +AliTrackReference * AliMaterialBudget::GetFirstTPCTrackRef(AliMCParticle *mcParticle) +{ + // return first TPC track reference + if(!mcParticle) return 0; + + // find first track reference + // check direction to select proper reference point for looping tracks + Int_t nTrackRef = mcParticle->GetNumberOfTrackReferences(); + AliTrackReference *ref = 0; + AliTrackReference *refIn = 0; + for (Int_t iref = 0; iref < nTrackRef; iref++) { + ref = mcParticle->GetTrackReference(iref); + if(ref && (ref->DetectorId()==AliTrackReference::kTPC)) + { + //Float_t dir = ref->X()*ref->Px()+ref->Y()*ref->Py(); + //if(dir < 0.) break; + + refIn = ref; + break; + } + } + + return refIn; +} + + +AliTrackReference * AliMaterialBudget::GetAllTOFinfo(AliMCParticle *mcParticle, Int_t &nTrackRef, Int_t &nTrackRefITS, Int_t retValue) { + // + // + // + + if(!mcParticle) return 0; + Int_t counter = 0; + nTrackRef = 0; + nTrackRefITS = 0; + AliTrackReference *ref = 0; + for (Int_t iref = 0; iref < mcParticle->GetNumberOfTrackReferences(); iref++) { + ref = mcParticle->GetTrackReference(iref); + if(ref && (ref->DetectorId()==AliTrackReference::kTOF)) { + counter = iref; + nTrackRef++; + } + if(ref && (ref->DetectorId()==AliTrackReference::kITS)) nTrackRefITS++; + } + if (nTrackRef ==0) return 0; + if (retValue == 0) return mcParticle->GetTrackReference(counter - nTrackRef +1); + return mcParticle->GetTrackReference(counter); + +} + + +void AliMaterialBudget::FinishTaskOutput() +{ + // + // According description in AliAnalisysTask this method is call + // on the slaves before sending data + // + Terminate("slave"); + gSystem->Exec("pwd"); + RegisterDebugOutput(); + +} + + +void AliMaterialBudget::RegisterDebugOutput(){ + // + // + // + // + // store - copy debug output to the destination position + // currently ONLY for local copy + TString dsName; + dsName=GetName(); + dsName+="Debug.root"; + dsName.ReplaceAll(" ",""); + TString dsName2=fDebugOutputPath.Data(); + gSystem->MakeDirectory(dsName2.Data()); + dsName2+=gSystem->HostName(); + gSystem->MakeDirectory(dsName2.Data()); + dsName2+="/"; + dsName2+=gSystem->BaseName(gSystem->pwd()); + dsName2+="/"; + gSystem->MakeDirectory(dsName2.Data()); + dsName2+=dsName; + AliInfo(Form("copy %s\t%s\n",dsName.Data(),dsName2.Data())); + printf("copy %s\t%s\n",dsName.Data(),dsName2.Data()); + TFile::Cp(dsName.Data(),dsName2.Data()); +} + + +Bool_t AliMaterialBudget::PropagateCosmicToDCA(AliExternalTrackParam *param0, AliExternalTrackParam *param1, Double_t mass){ + // + // param0 - upper part of cosmic track + // param1 - lower part of cosmic track + // + // 0. Propagate both tracks to DCA to (0,0,0) + // 1. After propagation to DCA rotate track param1 to corrdinate system of track1 <-> rotate param0 to coordinate system of param 1 ???? + // 2. Propagate track 1 to refernce x from track0 + // + + // step 0. + + Float_t d0 = param0->GetLinearD(0,0); + Float_t d1 = param1->GetLinearD(0,0); + Float_t dmax = TMath::Max(TMath::Abs(d0),TMath::Abs(d1)); + // + // propagate in the beginning taking all material into account + // + AliTracker::PropagateTrackToBxByBz(param0,dmax+1.,mass,0.5,kTRUE,0.99,-1.); + AliTracker::PropagateTrackToBxByBz(param1,dmax+1.,mass,0.5,kTRUE,0.99,1.); + // + Double_t vtxx[3]={0,0,0}; + Double_t svtxx[3]={0.000001,0.000001,100.}; + AliESDVertex vtx(vtxx,svtxx); + // + Bool_t b0 = param0->PropagateToDCA(&vtx,AliTracker::GetBz(),1000); + Bool_t b1 = param1->PropagateToDCA(&vtx,AliTracker::GetBz(),1000); + + if (!(b0 && b1)) return 0; + + // step 1. + + Float_t dAlpha = param0->GetAlpha(); + param1->Rotate(dAlpha); + + // step 2. + + Float_t refX = param0->GetX(); + param1->PropagateTo(refX,AliTracker::GetBz()); + + return kTRUE; + + +} + + diff --git a/PWG1/TPC/AliMaterialBudget.h b/PWG1/TPC/AliMaterialBudget.h new file mode 100644 index 00000000000..cbb846ac391 --- /dev/null +++ b/PWG1/TPC/AliMaterialBudget.h @@ -0,0 +1,94 @@ +#ifndef ALIMATERIALBUDGET_H +#define ALIMATERIALBUDGET_H + +// ROOT includes +#include +#include +#include + +// AliRoot includes +#include +#include +#include +#include +#include +#include +#include +class AliGenInfoMaker; +class TTreeSRedirector; +class AliMCEventHadnler; +class TParticle; +class AliMCInfo; +class AliMCParticle; +class AliESDRecInfo; +class AliESDEvent; +class AliMCEvent; +class AliComparisonObject; + +class AliMaterialBudget : public AliAnalysisTask { + public: + AliMaterialBudget(); + AliMaterialBudget(const char *name); + virtual ~AliMaterialBudget(); + + virtual void ConnectInputData(Option_t *); + virtual void CreateOutputObjects(); + virtual void Exec(Option_t *option); + virtual void Terminate(Option_t *); + virtual void FinishTaskOutput(); + void SetDebugOuputhPath(const char * name){fDebugOutputPath=name;} + + // + void FindPairs(AliESDEvent * event); + Bool_t IsPair(AliExternalTrackParam *tr0, AliExternalTrackParam *tr1); + // + void ProcessMCInfo(); + void ProcessRefTracker(AliTrackReference* refIn, AliTrackReference* refOut, TParticle*part, Int_t type); + + void FitTrackRefs(TParticle * part, TClonesArray * trefs); + + // + // debug streamer part + // + TTreeSRedirector *GetDebugStreamer(); + void SetStreamLevel(Int_t streamLevel){fStreamLevel=streamLevel;} + void SetDebugLevel(Int_t level) {fDebugLevel = level;} + Int_t GetStreamLevel() const {return fStreamLevel;} + Int_t GetDebugLevel() const {return fDebugLevel;} + // + static Bool_t PropagateCosmicToDCA(AliExternalTrackParam *param0, AliExternalTrackParam *param1, Double_t mass); + static AliExternalTrackParam * MakeTrack(const AliTrackReference* ref, TParticle*part); + static Bool_t PropagateToPoint(AliExternalTrackParam *param, Double_t *xyz, Double_t mass, Float_t step); + // + AliTrackReference * GetFirstTPCTrackRef(AliMCParticle *mcParticle); + AliTrackReference * GetAllTOFinfo(AliMCParticle *mcParticle, Int_t & nTrackRef, Int_t &nTrackRefITS, Int_t retValue =0); + protected: + void RegisterDebugOutput(); + AliMaterialBudget(const AliMaterialBudget& /*info*/); + AliMaterialBudget& operator=(const AliMaterialBudget& /*info*/) { return *this;} + AliMCEvent * fMCinfo; //! MC event handler + AliESDEvent * fESD; //! current esd event + // + // + // + TTreeSRedirector *fDebugStreamer; //! debug streamer + Int_t fStreamLevel; // debug stream level + Int_t fDebugLevel; // debug level + TString fDebugOutputPath; // debug output path + // + // histogran + // + TList * fListHist; // list for histograms + TH1F * fHistMult; // track multiplicity histograms + // + // cuts + // + Float_t fCutMaxD; // maximal distance in rfi ditection + Float_t fCutMaxDz; // maximal distance in z ditection + Float_t fCutTheta; // maximal distance in theta ditection + Float_t fCutMinDir; // direction vector products + // + ClassDef(AliMaterialBudget, 1); // Analysis task base class for tracks +}; + +#endif diff --git a/PWG1/TPC/AliPerformanceDCA.cxx b/PWG1/TPC/AliPerformanceDCA.cxx new file mode 100644 index 00000000000..e330ab9847e --- /dev/null +++ b/PWG1/TPC/AliPerformanceDCA.cxx @@ -0,0 +1,610 @@ +//------------------------------------------------------------------------------ +// Implementation of AliPerformanceDCA class. It keeps information from +// comparison of reconstructed and MC particle tracks. In addtion, +// it keeps selection cuts used during comparison. The comparison +// information is stored in the ROOT histograms. Analysis of these +// histograms can be done by using Analyse() class function. The result of +// the analysis (histograms/graphs) are stored in the folder +// which is a data member of AliPerformanceDCA. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + TFile f("Output.root"); + AliPerformanceDCA * compObj = (AliPerformanceDCA*)coutput->FindObject("AliPerformanceDCA"); + + // Analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderDCA" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_DCA.root","recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include +#include +#include +#include +#include +#include +#include + +#include "AliPerformanceDCA.h" +#include "AliESDEvent.h" +#include "AliESDVertex.h" +#include "AliLog.h" +#include "AliMathBase.h" +#include "AliRecInfoCuts.h" +#include "AliMCInfoCuts.h" +#include "AliStack.h" +#include "AliMCEvent.h" +#include "AliTracker.h" +#include "AliHeader.h" +#include "AliGenEventHeader.h" + +using namespace std; + +ClassImp(AliPerformanceDCA) + +//_____________________________________________________________________________ +AliPerformanceDCA::AliPerformanceDCA(): + AliPerformanceObject("AliPerformanceDCA"), + + // DCA histograms + fDCAHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // default constructor + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceDCA::AliPerformanceDCA(Char_t* name="AliPerformanceDCA", Char_t* title="AliPerformanceDCA",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE): + AliPerformanceObject(name,title), + + // DCA histograms + fDCAHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceDCA::~AliPerformanceDCA() +{ + // destructor + if(fDCAHisto) delete fDCAHisto; fDCAHisto=0; + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; +} + +//_____________________________________________________________________________ +void AliPerformanceDCA::Init() +{ + // DCA histograms + Int_t nPtBins = 50; + Double_t ptMin = 1.e-2, ptMax = 10.; + + Double_t *binsPt = 0; + if (IsHptGenerator()) { + nPtBins = 100; ptMax = 100.; + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } else { + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } + + /* + Int_t nPtBins = 31; + Double_t binsPt[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.}; + Double_t ptMin = 0., ptMax = 10.; + + if(IsHptGenerator() == kTRUE) { + nPtBins = 100; + ptMin = 0.; ptMax = 100.; + } + */ + + //dca_r, dca_z, eta, pt + Int_t binsQA[4] = {100,100,30,nPtBins}; + Double_t xminQA[4] = {-10.,-10.,-1.5,ptMin}; + Double_t xmaxQA[4] = {10.,10.,1.5,ptMax}; + + fDCAHisto = new THnSparseF("fDCAHisto","dca_r:dca_z:eta:pt",4,binsQA,xminQA,xmaxQA); + fDCAHisto->SetBinEdges(3,binsPt); + + fDCAHisto->GetAxis(0)->SetTitle("dca_r (cm)"); + fDCAHisto->GetAxis(1)->SetTitle("dca_z (cm)"); + fDCAHisto->GetAxis(2)->SetTitle("#eta"); + fDCAHisto->GetAxis(3)->SetTitle("p_{T} (GeV/c)"); + fDCAHisto->Sumw2(); + + // init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderDCA","Analysis DCA Folder"); +} + +//_____________________________________________________________________________ +void AliPerformanceDCA::ProcessTPC(AliStack* const stack, AliESDtrack *const esdTrack) +{ + // Fill DCA comparison information + if(!esdTrack) return; + + const AliExternalTrackParam *track = esdTrack->GetTPCInnerParam(); + if(!track) return; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParametersTPC(dca,cov); + + if (esdTrack->GetTPCNcls()GetMinNClustersTPC()) return; // min. nb. TPC clusters + + Double_t vDCAHisto[4]={dca[0],dca[1],track->Eta(),track->Pt()}; + fDCAHisto->Fill(vDCAHisto); + + // + // Fill rec vs MC information + // + if(!stack) return; + + } + +//_____________________________________________________________________________ +void AliPerformanceDCA::ProcessTPCITS(AliStack* const stack, AliESDtrack *const esdTrack) +{ + // Fill DCA comparison information + if(!esdTrack) return; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParameters(dca,cov); + + if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return; // TPC refit + if (esdTrack->GetTPCNcls()GetMinNClustersTPC()) return; // min. nb. TPC clusters + Int_t clusterITS[200]; + if(esdTrack->GetITSclusters(clusterITS)GetMinNClustersITS()) return; // min. nb. ITS clusters + + Double_t vDCAHisto[4]={dca[0],dca[1],esdTrack->Eta(),esdTrack->Pt()}; + fDCAHisto->Fill(vDCAHisto); + + // + // Fill rec vs MC information + // + if(!stack) return; + +} + +void AliPerformanceDCA::ProcessConstrained(AliStack* const /*stack*/, AliESDtrack *const /*esdTrack*/) +{ + // Fill DCA comparison information + + AliDebug(AliLog::kWarning, "Warning: Not implemented"); +} + +//_____________________________________________________________________________ +Long64_t AliPerformanceDCA::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliPerformanceDCA* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fDCAHisto->Add(entry->fDCAHisto); + count++; + } + +return count; +} + +//_____________________________________________________________________________ +void AliPerformanceDCA::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend) +{ + // Process comparison information + // + if(!esdEvent) + { + Error("Exec","esdEvent not available"); + return; + } + AliHeader* header = 0; + AliGenEventHeader* genHeader = 0; + AliStack* stack = 0; + TArrayF vtxMC(3); + + if(bUseMC) + { + if(!mcEvent) { + Error("Exec","mcEvent not available"); + return; + } + // get MC event header + header = mcEvent->Header(); + if (!header) { + Error("Exec","Header not available"); + return; + } + // MC particle stack + stack = mcEvent->Stack(); + if (!stack) { + Error("Exec","Stack not available"); + return; + } + // get MC vertex + genHeader = header->GenEventHeader(); + if (!genHeader) { + Error("Exec","Could not retrieve genHeader from Header"); + return; + } + genHeader->PrimaryVertex(vtxMC); + } + + // use ESD friends + if(bUseESDfriend) { + if(!esdFriend) { + Error("Exec","esdFriend not available"); + return; + } + } + + // Process events + for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) + { + AliESDtrack *track = esdEvent->GetTrack(iTrack); + if(!track) continue; + + if(GetAnalysisMode() == 0) ProcessTPC(stack,track); + else if(GetAnalysisMode() == 1) ProcessTPCITS(stack,track); + else if(GetAnalysisMode() == 2) ProcessConstrained(stack,track); + else { + printf("ERROR: AnalysisMode %d \n",fAnalysisMode); + return; + } + } +} + +//_____________________________________________________________________________ +void AliPerformanceDCA::Analyse() +{ + // + // Analyse comparison information and store output histograms + // in the analysis folder "folderDCA" + // + + TH1::AddDirectory(kFALSE); + TH1 *h1D=0; + TH2 *h2D=0; + //TH3 *h3D=0; + TObjArray *aFolderObj = new TObjArray; + char title[256]; + + // set pt measurable range + fDCAHisto->GetAxis(3)->SetRangeUser(0.10,10.); + + // + h2D = fDCAHisto->Projection(0,1); // inverse projection convention + h2D->SetName("dca_r_vs_dca_z"); + h2D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(1)->GetTitle()); + h2D->GetYaxis()->SetTitle(fDCAHisto->GetAxis(0)->GetTitle()); + sprintf(title,"%s vs %s",fDCAHisto->GetAxis(0)->GetTitle(),fDCAHisto->GetAxis(1)->GetTitle()); + h2D->SetTitle(title); + aFolderObj->Add(h2D); + + // + h2D = fDCAHisto->Projection(0,2); + h2D->SetName("dca_r_vs_eta"); + h2D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(2)->GetTitle()); + h2D->GetYaxis()->SetTitle(fDCAHisto->GetAxis(0)->GetTitle()); + sprintf(title,"%s vs %s",fDCAHisto->GetAxis(2)->GetTitle(),fDCAHisto->GetAxis(0)->GetTitle()); + h2D->SetTitle(title); + aFolderObj->Add(h2D); + + h1D = MakeStat1D(h2D,0,0); + h1D->SetName("mean_dca_r_vs_eta"); + h1D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(2)->GetTitle()); + h1D->GetYaxis()->SetTitle("mean_dca_r (cm)"); + sprintf(title," mean_dca_r (cm) vs %s",fDCAHisto->GetAxis(2)->GetTitle()); + h1D->SetTitle(title); + aFolderObj->Add(h1D); + + h1D = MakeStat1D(h2D,0,1); + h1D->SetName("rms_dca_r_vs_eta"); + h1D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(2)->GetTitle()); + h1D->GetYaxis()->SetTitle("rms_dca_r (cm)"); + sprintf(title," rms_dca_r (cm) vs %s",fDCAHisto->GetAxis(2)->GetTitle()); + h1D->SetTitle(title); + aFolderObj->Add(h1D); + + // + h2D = fDCAHisto->Projection(0,3); + h2D->SetName("dca_r_vs_pt"); + h2D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(3)->GetTitle()); + h2D->GetYaxis()->SetTitle(fDCAHisto->GetAxis(0)->GetTitle()); + sprintf(title,"%s vs %s",fDCAHisto->GetAxis(0)->GetTitle(),fDCAHisto->GetAxis(3)->GetTitle()); + h2D->SetTitle(title); + h2D->SetBit(TH1::kLogX); + aFolderObj->Add(h2D); + + h1D = MakeStat1D(h2D,0,0); + h1D->SetName("mean_dca_r_vs_pt"); + h1D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(3)->GetTitle()); + h1D->GetYaxis()->SetTitle("mean_dca_r (cm)"); + sprintf(title,"mean_dca_r (cm) vs %s",fDCAHisto->GetAxis(3)->GetTitle()); + h1D->SetTitle(title); + h1D->SetBit(TH1::kLogX); + aFolderObj->Add(h1D); + + h1D = MakeStat1D(h2D,0,1); + h1D->SetName("rms_dca_r_vs_pt"); + h1D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(3)->GetTitle()); + h1D->GetYaxis()->SetTitle("rms_dca_r (cm)"); + sprintf(title,"rms_dca_r (cm) vs %s",fDCAHisto->GetAxis(3)->GetTitle()); + h1D->SetTitle(title); + h1D->SetBit(TH1::kLogX); + aFolderObj->Add(h1D); + + // + h2D = fDCAHisto->Projection(1,2); + h2D->SetName("dca_z_vs_eta"); + h2D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(2)->GetTitle()); + h2D->GetYaxis()->SetTitle(fDCAHisto->GetAxis(1)->GetTitle()); + sprintf(title,"%s vs %s",fDCAHisto->GetAxis(1)->GetTitle(),fDCAHisto->GetAxis(2)->GetTitle()); + h2D->SetTitle(title); + aFolderObj->Add(h2D); + + h1D = MakeStat1D(h2D,0,0); + h1D->SetName("mean_dca_z_vs_eta"); + h1D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(2)->GetTitle()); + h1D->GetYaxis()->SetTitle("mean_dca_z (cm)"); + sprintf(title,"mean_dca_z (cm) vs %s",fDCAHisto->GetAxis(2)->GetTitle()); + h1D->SetTitle(title); + aFolderObj->Add(h1D); + + h1D = MakeStat1D(h2D,0,1); + h1D->SetName("rms_dca_z_vs_eta"); + h1D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(2)->GetTitle()); + h1D->GetYaxis()->SetTitle("rms_dca_z (cm)"); + sprintf(title,"rms_dca_z (cm) vs %s",fDCAHisto->GetAxis(2)->GetTitle()); + h1D->SetTitle(title); + aFolderObj->Add(h1D); + + // + h2D = fDCAHisto->Projection(1,3); + h2D->SetName("dca_z_vs_pt"); + h2D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(3)->GetTitle()); + h2D->GetYaxis()->SetTitle(fDCAHisto->GetAxis(1)->GetTitle()); + sprintf(title,"%s vs %s",fDCAHisto->GetAxis(1)->GetTitle(),fDCAHisto->GetAxis(3)->GetTitle()); + h2D->SetTitle(title); + h2D->SetBit(TH1::kLogX); + aFolderObj->Add(h2D); + + h1D = MakeStat1D(h2D,0,0); + h1D->SetName("mean_dca_z_vs_pt"); + h1D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(3)->GetTitle()); + h1D->GetYaxis()->SetTitle("mean_dca_z (cm)"); + sprintf(title,"mean_dca_z (cm) vs %s",fDCAHisto->GetAxis(3)->GetTitle()); + h1D->SetTitle(title); + h1D->SetBit(TH1::kLogX); + aFolderObj->Add(h1D); + + h1D = MakeStat1D(h2D,0,1); + h1D->SetName("rms_dca_z_vs_pt"); + h1D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(3)->GetTitle()); + h1D->GetYaxis()->SetTitle("rms_dca_z (cm)"); + sprintf(title,"rms_dca_z (cm) vs %s",fDCAHisto->GetAxis(3)->GetTitle()); + h1D->SetTitle(title); + h1D->SetBit(TH1::kLogX); + aFolderObj->Add(h1D); + + /* + h3D = fDCAHisto->Projection(2,3,0); // normal 3D projection convention + h3D->SetName("dca_r_vs_eta_vs_pt"); + + h2D = MakeStat2D(h3D,0,0,0); + h2D->SetName("mean_dca_r_vs_eta_vs_pt"); + h2D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(2)->GetTitle()); + h2D->GetYaxis()->SetTitle(fDCAHisto->GetAxis(3)->GetTitle()); + h2D->GetZaxis()->SetTitle("mean_dca_r (cm)"); + sprintf(title,"mean_dca_r (cm) vs %s vs %s",fDCAHisto->GetAxis(2)->GetTitle(),fDCAHisto->GetAxis(3)->GetTitle()); + h2D->SetTitle(title); + aFolderObj->Add(h2D); + + h2D = MakeStat2D(h3D,0,0,1); + h2D->SetName("rms_dca_r_vs_eta_vs_pt"); + h2D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(2)->GetTitle()); + h2D->GetYaxis()->SetTitle(fDCAHisto->GetAxis(3)->GetTitle()); + h2D->GetZaxis()->SetTitle("rms_dca_r (cm)"); + sprintf(title,"rms_dca_r (cm) vs %s vs %s",fDCAHisto->GetAxis(2)->GetTitle(),fDCAHisto->GetAxis(3)->GetTitle()); + h2D->SetTitle(title); + aFolderObj->Add(h2D); + + // + h3D = fDCAHisto->Projection(2,3,1); + h3D->SetName("dca_z_vs_eta_vs_pt"); + + h2D = MakeStat2D(h3D,0,0,0); + h2D->SetName("mean_dca_z_vs_eta_vs_pt"); + h2D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(2)->GetTitle()); + h2D->GetYaxis()->SetTitle(fDCAHisto->GetAxis(3)->GetTitle()); + h2D->GetZaxis()->SetTitle("mean_dca_z (cm)"); + sprintf(title,"mean_dca_z (cm) vs %s vs %s",fDCAHisto->GetAxis(2)->GetTitle(),fDCAHisto->GetAxis(3)->GetTitle()); + h2D->SetTitle(title); + aFolderObj->Add(h2D); + + h2D = MakeStat2D(h3D,0,0,1); + h2D->SetName("rms_dca_z_vs_eta_vs_pt"); + h2D->GetXaxis()->SetTitle(fDCAHisto->GetAxis(2)->GetTitle()); + h2D->GetYaxis()->SetTitle(fDCAHisto->GetAxis(3)->GetTitle()); + h2D->GetZaxis()->SetTitle("rms_dca_z (cm)"); + sprintf(title,"rms_dca_z (cm) vs %s vs %s",fDCAHisto->GetAxis(2)->GetTitle(),fDCAHisto->GetAxis(3)->GetTitle()); + h2D->SetTitle(title); + aFolderObj->Add(h2D); + */ + + + + + + + + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TH1F* AliPerformanceDCA::MakeStat1D(TH2 *hist, Int_t delta0, Int_t type) +{ + // Return TH1F histogram + // delta - number of bins to integrate + // with mean (type == 0) or RMS (type==1) + + char hname[256]; + const char* suffix = "_stat1d"; + sprintf(hname,"%s%s",hist->GetName(),suffix); + TAxis* xaxis = hist->GetXaxis(); + Int_t nbinx = xaxis->GetNbins(); + + TH1F *hnew = (TH1F*)hist->ProjectionX()->Clone(); + hnew->SetName(hname); + + char name[256]; + for (Int_t ix=0; ix<=nbinx;ix++) { + sprintf(name,"%s_%d",hist->GetName(),ix); + TH1 *projection = hist->ProjectionY(name,ix-delta0,ix+delta0); + + Float_t stat= 0., stat_err =0.; + if (type==0) { stat = projection->GetMean(); stat_err = projection->GetMeanError(); } + if (type==1) { stat = projection->GetRMS(); stat_err = projection->GetRMSError(); } + + hnew->SetBinContent(ix, stat); + hnew->SetBinError(ix, stat_err); + } + +return hnew; +} + +//_____________________________________________________________________________ +TH2F* AliPerformanceDCA::MakeStat2D(TH3 *hist, Int_t delta0, Int_t delta1, Int_t type) +{ + // Return TH1F histogram + // delta0 - number of bins to integrate in x + // delta1 - number of bins to integrate in y + // with mean (type==0) or RMS (type==1) + + char hname[256]; + const char* suffix = "_stat2d"; + sprintf(hname,"%s%s",hist->GetName(),suffix); + + TAxis* xaxis = hist->GetXaxis(); + Int_t nbinx = xaxis->GetNbins(); + + TH2F *hnew = (TH2F*)hist->Project3D("yx")->Clone(); + hnew->SetName(hname); + + TAxis* yaxis = hist->GetYaxis(); + Int_t nbiny = yaxis->GetNbins(); + + char name[256]; + for (Int_t ix=0; ix<=nbinx;ix++) { + for (Int_t iy=0; iy<=nbiny;iy++) { + sprintf(name,"%s_%d_%d",hist->GetName(),ix,iy); + TH1 *projection = hist->ProjectionZ(name,ix-delta0,ix+delta0,iy-delta1,iy+delta1); + + Float_t stat= 0., stat_err =0.; + if (type==0) { stat = projection->GetMean(); stat_err = projection->GetMeanError(); } + if (type==1) { stat = projection->GetRMS(); stat_err = projection->GetRMSError(); } + + hnew->SetBinContent(ix,iy,stat); + hnew->SetBinError(ix,iy,stat_err); + } + } + +return hnew; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceDCA::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliPerformanceDCA * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceDCA::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} diff --git a/PWG1/TPC/AliPerformanceDCA.h b/PWG1/TPC/AliPerformanceDCA.h new file mode 100644 index 00000000000..04a75d2b5f2 --- /dev/null +++ b/PWG1/TPC/AliPerformanceDCA.h @@ -0,0 +1,91 @@ +#ifndef ALIPERFORMANCEDCA_H +#define ALIPERFORMANCEDCA_H + +//------------------------------------------------------------------------------ +// Class to keep information from comparison of +// reconstructed and MC particle tracks (DCA - Distance of Closest Approach +// to the vertex). +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +class AliESDEvent; +class AliESDfriend; +class AliStack; +class AliRecInfoCuts; +class AliMCInfoCuts; +class AliESDVertex; +class AliESDtrack; +class TH3; +class TH2; +class TH1; +class TString; +class TNamed; + +#include "THnSparse.h" +#include "AliPerformanceObject.h" + +class AliPerformanceDCA : public AliPerformanceObject { +public : + AliPerformanceDCA(); + AliPerformanceDCA(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + ~AliPerformanceDCA(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend); + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderDCA",TString title = "Analysed DCA histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray * array=0); + + void ProcessConstrained(AliStack* const stack, AliESDtrack *const esdTrack); + void ProcessTPC(AliStack* const stack, AliESDtrack *const esdTrack); + void ProcessTPCITS(AliStack* const stack, AliESDtrack *const esdTrack); + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + // getters + THnSparse* GetDCAHisto() const {return fDCAHisto;} + + // Make stat histograms + TH1F* MakeStat1D(TH2 *hist, Int_t delta1, Int_t type); + TH2F* MakeStat2D(TH3 *hist, Int_t delta0, Int_t delta1, Int_t type); + +private: + + // DCA histograms + THnSparseF *fDCAHisto; //-> dca_r:dca_z:eta:pt + + // Global cuts objects + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliPerformanceDCA(const AliPerformanceDCA&); // not implemented + AliPerformanceDCA& operator=(const AliPerformanceDCA&); // not implemented + + ClassDef(AliPerformanceDCA,1); +}; + +#endif diff --git a/PWG1/TPC/AliPerformanceDEdx.cxx b/PWG1/TPC/AliPerformanceDEdx.cxx new file mode 100644 index 00000000000..14ab0520081 --- /dev/null +++ b/PWG1/TPC/AliPerformanceDEdx.cxx @@ -0,0 +1,466 @@ +//------------------------------------------------------------------------------ +// Implementation of AliPerformanceDEdx class. It keeps information from +// comparison of reconstructed and MC particle tracks. In addtion, +// it keeps selection cuts used during comparison. The comparison +// information is stored in the ROOT histograms. Analysis of these +// histograms can be done by using Analyse() class function. The result of +// the analysis (histograms/graphs) are stored in the folder which is +// a data of AliPerformanceDEdx. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + TFile f("Output.root"); + //AliPerformanceDEdx * compObj = (AliPerformanceDEdx*)f.Get("AliPerformanceDEdx"); + AliPerformanceDEdx * compObj = (AliPerformanceDEdx*)coutput->FindObject("AliPerformanceDEdx"); + + // Analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderDEdx" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_DEdx.root"."recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include +#include +#include +#include +#include +#include + +#include "AliPerformanceDEdx.h" +#include "AliESDEvent.h" +#include "AliMCEvent.h" +#include "AliESDtrack.h" +#include "AliStack.h" +#include "AliLog.h" +#include "AliMCInfoCuts.h" +#include "AliMathBase.h" +#include "AliRecInfoCuts.h" +#include "AliTreeDraw.h" +#include "AliHeader.h" +#include "AliGenEventHeader.h" + +using namespace std; + +ClassImp(AliPerformanceDEdx) + +//_____________________________________________________________________________ +AliPerformanceDEdx::AliPerformanceDEdx(): + AliPerformanceObject("AliPerformanceDEdx"), + + // dEdx + fDeDxHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // default constructor + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceDEdx::AliPerformanceDEdx(Char_t* name="AliPerformanceDEdx", Char_t* title="AliPerformanceDEdx",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE): + AliPerformanceObject(name,title), + + // dEdx + fDeDxHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + Init(); +} + + +//_____________________________________________________________________________ +AliPerformanceDEdx::~AliPerformanceDEdx() +{ + // destructor + if(fDeDxHisto) delete fDeDxHisto; fDeDxHisto=0; + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; +} + +//_____________________________________________________________________________ +void AliPerformanceDEdx::Init() +{ + // Init histograms + + // TPC dEdx + // set pt bins + Int_t nPBins = 50; + Double_t pMin = 1.e-2, pMax = 10.; + + Double_t *binsP = 0; + if (IsHptGenerator()) { + nPBins = 100; pMax = 100.; + binsP = CreateLogAxis(nPBins,pMin,pMax); + } else { + binsP = CreateLogAxis(nPBins,pMin,pMax); + } + + + /* + Int_t nPBins = 31; + Double_t binsP[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.}; + Double_t pMin = 0., pMax = 10.; + + if(IsHptGenerator() == kTRUE) { + nPBins = 100; + pMin = 0.; pMax = 100.; + } + */ + + //dedx:alpha:y:z:snp:tgl:ncls:p + //dedx:phi:y:z:snp:tgl:ncls:p + //Int_t binsQA[8] = {300, 50, 50, 50, 50, 50, 80, nPBins}; + //Double_t xminQA[8] = {0, -4,-20,-250, -1, -2, 0, pMin}; + //Double_t xmaxQA[8] = {300, 4, 20, 250, 1, 2, 160, pMax}; + Int_t binsQA[8] = {300, 90, 50, 50, 50, 50, 80, nPBins}; + Double_t xminQA[8] = {0, -TMath::Pi(),-20,-250, -1, -2, 0, pMin}; + Double_t xmaxQA[8] = {300, TMath::Pi(), 20, 250, 1, 2, 160, pMax}; + + //fDeDxHisto = new THnSparseF("fDeDxHisto","dedx:alpha:y:z:snp:tgl:ncls:momentum",8,binsQA,xminQA,xmaxQA); + fDeDxHisto = new THnSparseF("fDeDxHisto","dedx:phi:y:z:snp:tgl:ncls:momentum",8,binsQA,xminQA,xmaxQA); + fDeDxHisto->SetBinEdges(7,binsP); + + fDeDxHisto->GetAxis(0)->SetTitle("dedx (a.u.)"); + fDeDxHisto->GetAxis(1)->SetTitle("#phi (rad)"); + fDeDxHisto->GetAxis(2)->SetTitle("y (cm)"); + fDeDxHisto->GetAxis(3)->SetTitle("z (cm)"); + fDeDxHisto->GetAxis(4)->SetTitle("sin#phi"); + fDeDxHisto->GetAxis(5)->SetTitle("tan#lambda"); + fDeDxHisto->GetAxis(6)->SetTitle("ncls"); + fDeDxHisto->GetAxis(7)->SetTitle("p (GeV/c)"); + fDeDxHisto->Sumw2(); + + // Init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderDEdx","Analysis de/dx Folder"); +} + +//_____________________________________________________________________________ +void AliPerformanceDEdx::ProcessTPC(AliStack* const /*stack*/, AliESDtrack *const /*esdTrack*/) +{ + // Fill dE/dx comparison information + AliDebug(AliLog::kWarning, "Warning: Not implemented"); +} + +//_____________________________________________________________________________ +void AliPerformanceDEdx::ProcessInnerTPC(AliStack* const stack, AliESDtrack *const esdTrack) +{ + if(!esdTrack) return; + + const AliExternalTrackParam *innerParam = esdTrack->GetInnerParam(); + if(!innerParam) return; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParametersTPC(dca,cov); + + if((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return; // TPC refit + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + Float_t dedx = esdTrack->GetTPCsignal(); + Int_t ncls = esdTrack->GetTPCNcls(); + + Double_t pt = innerParam->Pt(); + Double_t lam = TMath::ATan2(innerParam->Pz(),innerParam->Pt()); + Double_t p = pt/TMath::Cos(lam); + //Double_t alpha = innerParam->GetAlpha(); + Double_t phi = TMath::ATan2(innerParam->Py(),innerParam->Px()); + //if(phi<0.) phi += 2.*TMath::Phi(); + Double_t y = innerParam->GetY(); + Double_t z = innerParam->GetZ(); + Double_t snp = innerParam->GetSnp(); + Double_t tgl = innerParam->GetTgl(); + + //Double_t vDeDxHisto[8] = {dedx,alpha,y,z,snp,tgl,ncls,p}; + Double_t vDeDxHisto[8] = {dedx,phi,y,z,snp,tgl,ncls,p}; + fDeDxHisto->Fill(vDeDxHisto); + } + + if(!stack) return; +} + +//_____________________________________________________________________________ +void AliPerformanceDEdx::ProcessTPCITS(AliStack* const /*stack*/, AliESDtrack *const /*esdTrack*/) +{ + // Fill dE/dx comparison information + + AliDebug(AliLog::kWarning, "Warning: Not implemented"); +} + +//_____________________________________________________________________________ +void AliPerformanceDEdx::ProcessConstrained(AliStack* const /*stack*/, AliESDtrack *const /*esdTrack*/) +{ + // Fill dE/dx comparison information + + AliDebug(AliLog::kWarning, "Warning: Not implemented"); +} + +//_____________________________________________________________________________ +Long64_t AliPerformanceDEdx::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliPerformanceDEdx* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fDeDxHisto->Add(entry->fDeDxHisto); + count++; + } + +return count; +} + +//_____________________________________________________________________________ +void AliPerformanceDEdx::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend) +{ + // Process comparison information + // + if(!esdEvent) + { + AliDebug(AliLog::kError, "esdEvent not available"); + return; + } + AliHeader* header = 0; + AliGenEventHeader* genHeader = 0; + AliStack* stack = 0; + TArrayF vtxMC(3); + + if(bUseMC) + { + if(!mcEvent) { + AliDebug(AliLog::kError, "mcEvent not available"); + return; + } + + // get MC event header + header = mcEvent->Header(); + if (!header) { + AliDebug(AliLog::kError, "Header not available"); + return; + } + // MC particle stack + stack = mcEvent->Stack(); + if (!stack) { + AliDebug(AliLog::kError, "Stack not available"); + return; + } + + // get MC vertex + genHeader = header->GenEventHeader(); + if (!genHeader) { + AliDebug(AliLog::kError, "Could not retrieve genHeader from Header"); + return; + } + genHeader->PrimaryVertex(vtxMC); + + } // end bUseMC + + // use ESD friends + if(bUseESDfriend) { + if(!esdFriend) { + AliDebug(AliLog::kError, "esdFriend not available"); + return; + } + } + + + + + // Process events + for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) + { + AliESDtrack *track = esdEvent->GetTrack(iTrack); + if(!track) continue; + + if(GetAnalysisMode() == 0) ProcessTPC(stack,track); + else if(GetAnalysisMode() == 1) ProcessTPCITS(stack,track); + else if(GetAnalysisMode() == 2) ProcessConstrained(stack,track); + else if(GetAnalysisMode() == 3) ProcessInnerTPC(stack,track); + else { + printf("ERROR: AnalysisMode %d \n",fAnalysisMode); + return; + } + } +} + +//_____________________________________________________________________________ +void AliPerformanceDEdx::Analyse() +{ + // Analyze comparison information and store output histograms + // in the folder "folderDEdx" + // + TH1::AddDirectory(kFALSE); + TH1F *h1D=0; + TH2F *h2D=0; + TObjArray *aFolderObj = new TObjArray; + + char name[256]; + char title[256]; + + for(Int_t i=1; i<8; i++) { + // + h2D = (TH2F*)fDeDxHisto->Projection(0,i); + + sprintf(name,"h_dedx_%d_vs_%d",0,i); + h2D->SetName(name); + sprintf(title,"%s vs %s",fDeDxHisto->GetAxis(0)->GetTitle(),fDeDxHisto->GetAxis(i)->GetTitle()); + h2D->SetTitle(title); + h2D->GetXaxis()->SetTitle(fDeDxHisto->GetAxis(i)->GetTitle()); + h2D->GetYaxis()->SetTitle(fDeDxHisto->GetAxis(0)->GetTitle()); + + if(i==7) h2D->SetBit(TH1::kLogX); + aFolderObj->Add(h2D); + } + + // resolution histograms for mips + fDeDxHisto->GetAxis(2)->SetRangeUser(-15.,14.999); + fDeDxHisto->GetAxis(3)->SetRangeUser(-120.,119.999); + fDeDxHisto->GetAxis(4)->SetRangeUser(-0.4, 0.399); + fDeDxHisto->GetAxis(5)->SetRangeUser(-1.,0.999); + fDeDxHisto->GetAxis(6)->SetRangeUser(60.,140.); + fDeDxHisto->GetAxis(7)->SetRangeUser(0.4,0.499); + + h1D=(TH1F*)fDeDxHisto->Projection(0); + h1D->SetName("dedx_mips"); + + h1D->SetTitle("dedx_mips"); + h1D->GetXaxis()->SetTitle(fDeDxHisto->GetAxis(0)->GetTitle()); + aFolderObj->Add(h1D); + + // + TObjArray *arr[7] = {0}; + TF1 *f1[7] = {0}; + + for(Int_t i=1; i<8; i++) + { + arr[i] = new TObjArray; + f1[i] = new TF1("gaus","gaus"); + //printf("i %d \n",i); + + h2D = (TH2F*)fDeDxHisto->Projection(0,i); + + f1[i]->SetRange(40,60); // should be pion peak + h2D->FitSlicesY(f1[i],0,-1,10,"QNR",arr[i]); // gaus fit of pion peak + + h1D = (TH1F*)arr[i]->At(1); + sprintf(name,"mean_dedx_mips_vs_%d",i); + h1D->SetName(name); + sprintf(title,"%s vs %s","mean_dedx_mips (a.u.)",fDeDxHisto->GetAxis(i)->GetTitle()); + h1D->SetTitle(title); + h1D->GetXaxis()->SetTitle(fDeDxHisto->GetAxis(i)->GetTitle()); + h1D->GetYaxis()->SetTitle("mean_dedx_mips (a.u.)"); + //h1D->SetMinimum(40); + //h1D->SetMaximum(60); + + aFolderObj->Add(h1D); + + h1D = (TH1F*)arr[i]->At(2); + sprintf(name,"res_dedx_mips_vs_%d",i); + h1D->SetName(name); + sprintf(title,"%s vs %s","res_dedx_mips (a.u)",fDeDxHisto->GetAxis(i)->GetTitle()); + h1D->SetTitle(title); + h1D->GetXaxis()->SetTitle(fDeDxHisto->GetAxis(i)->GetTitle()); + h1D->GetYaxis()->SetTitle("res_dedx_mips (a.u.)"); + //h1D->SetMinimum(0); + //h1D->SetMaximum(6); + + aFolderObj->Add(h1D); + } + + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjrArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceDEdx::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliPerformanceDEdx * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + + +//_____________________________________________________________________________ +TFolder* AliPerformanceDEdx::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} + diff --git a/PWG1/TPC/AliPerformanceDEdx.h b/PWG1/TPC/AliPerformanceDEdx.h new file mode 100644 index 00000000000..e797e67e0bb --- /dev/null +++ b/PWG1/TPC/AliPerformanceDEdx.h @@ -0,0 +1,91 @@ +#ifndef ALIPERFORMANCEDEdx_H +#define ALIPERFORMANCEDEdx_H + +//------------------------------------------------------------------------------ +// Class to keep information from comparison of +// reconstructed and MC particle tracks (TPC dE/dx). +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +class TCanvas; +class TH1F; +class TH2F; +class TNamed; +class TString; + +class AliESDEvent; +class AliESDfriend; +class AliMCEvent; +class AliESDtrack; +class AliStack; +class AliRecInfoCuts; +class AliMCInfoCuts; + +#include "THnSparse.h" +#include "AliPerformanceObject.h" + +class AliPerformanceDEdx : public AliPerformanceObject { +public : + AliPerformanceDEdx(); + AliPerformanceDEdx(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + ~AliPerformanceDEdx(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend); + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderDEdx",TString title = "Analysed DEdx histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray * array=0); + + // Process events + void ProcessTPC(AliStack* const stack, AliESDtrack *const esdTrack); // not implemented + void ProcessInnerTPC(AliStack* const stack, AliESDtrack *const esdTrack); + void ProcessTPCITS(AliStack* const stack, AliESDtrack *const esdTrack); // not implemented + void ProcessConstrained(AliStack* const stack, AliESDtrack *const esdTrack); // not implemented + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + // + // TPC dE/dx + // + THnSparse* GetDeDxHisto() const {return fDeDxHisto;} + +private: + + // TPC dE/dx + THnSparseF *fDeDxHisto; //-> signal:alpha:y:z:snp:tgl:ncls:pid:p + + // Selection cuts + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliPerformanceDEdx(const AliPerformanceDEdx&); // not implemented + AliPerformanceDEdx& operator=(const AliPerformanceDEdx&); // not implemented + + ClassDef(AliPerformanceDEdx,1); +}; + +#endif diff --git a/PWG1/TPC/AliPerformanceEff.cxx b/PWG1/TPC/AliPerformanceEff.cxx new file mode 100644 index 00000000000..d5c70f1ed25 --- /dev/null +++ b/PWG1/TPC/AliPerformanceEff.cxx @@ -0,0 +1,1554 @@ +//------------------------------------------------------------------------------ +// Implementation of AliPerformanceEff class. It keeps information from +// comparison of reconstructed and MC particle tracks. In addtion, +// it keeps selection cuts used during comparison. The comparison +// information is stored in the ROOT histograms. Analysis of these +// histograms can be done by using Analyse() class function. The result of +// the analysis (histograms/graphs) are stored in the folder which is +// a data member of AliPerformanceEff. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + TFile f("Output.root"); + AliPerformanceEff * compObj = (AliPerformanceEff*)coutput->FindObject("AliPerformanceEff"); + + // Analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderEff" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_Eff.root","recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include +#include +#include "THnSparse.h" + +// +#include "AliESDtrack.h" +#include "AliRecInfoCuts.h" +#include "AliMCInfoCuts.h" +#include "AliLog.h" +#include "AliESDVertex.h" +#include "AliExternalTrackParam.h" +#include "AliTracker.h" +#include "AliESDEvent.h" +#include "AliMCEvent.h" +#include "AliMCParticle.h" +#include "AliHeader.h" +#include "AliGenEventHeader.h" +#include "AliStack.h" +#include "AliPerformanceEff.h" + +using namespace std; + +ClassImp(AliPerformanceEff) + +//_____________________________________________________________________________ +AliPerformanceEff::AliPerformanceEff(): + AliPerformanceObject("AliPerformanceEff"), + + // histograms + fEffHisto(0), + fEffSecHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // default consttructor + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceEff::AliPerformanceEff(Char_t* name="AliPerformanceEff",Char_t*title="AliPerformanceEff",Int_t analysisMode=0, Bool_t hptGenerator=kFALSE): + AliPerformanceObject(name,title), + + // histograms + fEffHisto(0), + fEffSecHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + // + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + + Init(); +} + + +//_____________________________________________________________________________ +AliPerformanceEff::~AliPerformanceEff() +{ +// destructor + + if(fEffHisto) delete fEffHisto; fEffHisto=0; + if(fEffSecHisto) delete fEffSecHisto; fEffSecHisto=0; + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; +} + +//_____________________________________________________________________________ +void AliPerformanceEff::Init() +{ + // Init histograms + // + // set pt bins + Int_t nPtBins = 50; + Double_t ptMin = 1.e-2, ptMax = 10.; + + Double_t *binsPt = 0; + if (IsHptGenerator()) { + nPtBins = 100; ptMax = 100.; + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } else { + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } + + /* + Int_t nPtBins = 31; + Double_t binsPt[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.}; + Double_t ptMin = 0., ptMax = 10.; + + if(IsHptGenerator() == kTRUE) { + nPtBins = 100; + ptMin = 0.; ptMax = 100.; + } + */ + + //mceta:mcphi:mcpt:pid:recStatus:findable + Int_t binsEffHisto[6]={30,90,nPtBins,5,2,2}; + Double_t minEffHisto[6]={-1.5,0.,ptMin,0.,0.,0.}; + Double_t maxEffHisto[6]={ 1.5,2.*TMath::Pi(), ptMax,5.,2.,2.}; + + fEffHisto = new THnSparseF("fEffHisto","mceta:mcphi:mcpt:pid:recStatus:findable",6,binsEffHisto,minEffHisto,maxEffHisto); + fEffHisto->SetBinEdges(2,binsPt); + + fEffHisto->GetAxis(0)->SetTitle("#eta_{mc}"); + fEffHisto->GetAxis(1)->SetTitle("#phi_{mc} (rad)"); + fEffHisto->GetAxis(2)->SetTitle("p_{Tmc} (GeV/c)"); + fEffHisto->GetAxis(3)->SetTitle("pid"); + fEffHisto->GetAxis(4)->SetTitle("recStatus"); + fEffHisto->GetAxis(5)->SetTitle("findable"); + fEffHisto->Sumw2(); + + //mceta:mcphi:mcpt:pid:recStatus:findable:mcR:mother_phi:mother_eta + Int_t binsEffSecHisto[9]={30,60,nPtBins,5,2,2,100,60,30}; + Double_t minEffSecHisto[9]={-1.5,0.,ptMin,0.,0.,0.,0.,0.,-1.5}; + Double_t maxEffSecHisto[9]={ 1.5,2.*TMath::Pi(), ptMax,5.,2.,2.,200,2.*TMath::Pi(),1.5}; + + fEffSecHisto = new THnSparseF("fEffSecHisto","mceta:mcphi:mcpt:pid:recStatus:findable:mcR:mother_phi:mother_eta",9,binsEffSecHisto,minEffSecHisto,maxEffSecHisto); + fEffSecHisto->SetBinEdges(2,binsPt); + + fEffSecHisto->GetAxis(0)->SetTitle("#eta_{mc}"); + fEffSecHisto->GetAxis(1)->SetTitle("#phi_{mc} (rad)"); + fEffSecHisto->GetAxis(2)->SetTitle("p_{Tmc} (GeV/c)"); + fEffSecHisto->GetAxis(3)->SetTitle("pid"); + fEffSecHisto->GetAxis(4)->SetTitle("recStatus"); + fEffSecHisto->GetAxis(5)->SetTitle("findable"); + fEffSecHisto->GetAxis(6)->SetTitle("mcR (cm)"); + fEffSecHisto->GetAxis(7)->SetTitle("mother_phi (rad)"); + fEffSecHisto->GetAxis(8)->SetTitle("mother_eta"); + fEffSecHisto->Sumw2(); + + // init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderEff","Analysis Efficiency Folder"); +} + +//_____________________________________________________________________________ +void AliPerformanceEff::ProcessTPC(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent) +{ + // Fill TPC only efficiency comparison information + Int_t *labelsRec = new Int_t[esdEvent->GetNumberOfTracks()]; + if(!labelsRec) + AliDebug(AliLog::kError, "Cannot create labelsRec"); + + Int_t *labelsAllRec = new Int_t[esdEvent->GetNumberOfTracks()]; + if(!labelsAllRec) + AliDebug(AliLog::kError, "Cannot create labelsAllRec"); + + // loop over rec. tracks + AliESDtrack *track=0; + for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) + { + track = esdEvent->GetTrack(iTrack); + if(!track) continue; + if(track->Charge()==0) continue; + Int_t label = TMath::Abs(track->GetLabel()); + labelsAllRec[iTrack]=label; + + // TPC only + if(IsRecTPC(track) != 0) + labelsRec[iTrack]=label; + } + + // + // MC histograms for efficiency studies + // + if(!mcEvent) return; + + AliStack *stack = mcEvent->Stack(); + if (!stack) { + AliDebug(AliLog::kError, "Stack not available"); + return; + } + + //Int_t nPart = stack->GetNtrack(); + Int_t nPart = stack->GetNprimary(); + for (Int_t iMc = 0; iMc < nPart; ++iMc) + { + TParticle* particle = stack->Particle(iMc); + if (!particle) continue; + if (particle->GetPDG()->Charge() == 0.0) continue; + + // physical primary + Bool_t prim = stack->IsPhysicalPrimary(iMc); + if(!prim) continue; + + Bool_t findable = kFALSE; + for(Int_t iRec=0; iRecGetNumberOfTracks(); ++iRec) + { + // check findable + if(iMc == labelsAllRec[iRec]) + { + findable = IsFindable(mcEvent,iMc); + break; + } + } + + Bool_t recStatus = kFALSE; + for(Int_t iRec=0; iRecGetNumberOfTracks(); ++iRec) + { + // check reconstructed + if(iMc == labelsRec[iRec]) + { + recStatus = kTRUE; + break; + } + } + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; + + // transform Pdg to Pid + Int_t pid = TransformToPID(particle); + + Float_t mceta = particle->Eta(); + Float_t mcphi = particle->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = particle->Pt(); + + + // Fill histograms + Double_t vEffHisto[6] = {mceta, mcphi, mcpt, pid, recStatus, findable}; + fEffHisto->Fill(vEffHisto); + } + + if(labelsRec) delete [] labelsRec; labelsRec = 0; + if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0; +} + +//_____________________________________________________________________________ +void AliPerformanceEff::ProcessTPCSec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent) +{ + // Fill TPC only efficiency comparison information for secondaries + Int_t *labelsRec = new Int_t[esdEvent->GetNumberOfTracks()]; + if(!labelsRec) + AliDebug(AliLog::kError, "Cannot create labelsRec"); + + Int_t *labelsAllRec = new Int_t[esdEvent->GetNumberOfTracks()]; + if(!labelsAllRec) + AliDebug(AliLog::kError, "Cannot create labelsAllRec"); + + // loop over rec. tracks + AliESDtrack *track=0; + Int_t multAll=0, multRec=0; + for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) + { + track = esdEvent->GetTrack(iTrack); + if(!track) continue; + if(track->Charge()==0) continue; + Int_t label = TMath::Abs(track->GetLabel()); + labelsAllRec[multAll]=label; + multAll++; + + // TPC only + if(IsRecTPC(track) != 0) { + labelsRec[multRec]=label; + multRec++; + } + } + + // + // MC histograms for efficiency studies + // + if(!mcEvent) return; + + AliStack *stack = mcEvent->Stack(); + if (!stack) { + AliDebug(AliLog::kError, "Stack not available"); + return; + } + + Int_t nPart = stack->GetNtrack(); + //Int_t nPart = stack->GetNprimary(); + for (Int_t iMc = 0; iMc < nPart; ++iMc) + { + TParticle* particle = stack->Particle(iMc); + if (!particle) continue; + if (particle->GetPDG()->Charge() == 0.0) continue; + + // physical primary + Bool_t prim = stack->IsPhysicalPrimary(iMc); + + // only secondaries which can be reconstructed at TPC + if(prim) continue; + + //Float_t radius = TMath::Sqrt(particle->Vx()*particle->Vx()+particle->Vy()*particle->Vy()+particle->Vz()*particle->Vz()); + //if(radius > fCutsMC->GetMaxR()) continue; + + // only secondary electrons from gamma conversion + //if( TMath::Abs(particle->GetPdgCode())!=fCutsMC->GetEM() || particle->GetUniqueID() != 5) continue; + + Bool_t findable = kFALSE; + for(Int_t iRec=0; iRecIsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; + + // transform Pdg to Pid + Int_t pid = TransformToPID(particle); + + Float_t mceta = particle->Eta(); + Float_t mcphi = particle->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = particle->Pt(); + Float_t mcR = particle->R(); + + // get info about mother + Int_t motherLabel = particle->GetMother(0); + if(motherLabel < 0) continue; + TParticle *mother = stack->Particle(motherLabel); + if(!mother) continue; + + Float_t mother_eta = mother->Eta(); + Float_t mother_phi = mother->Phi(); + if(mother_phi<0) mother_phi += 2.*TMath::Pi(); + + // Fill histograms + Double_t vEffSecHisto[9] = { mceta, mcphi, mcpt, pid, recStatus, findable, mcR, mother_phi, mother_eta }; + fEffSecHisto->Fill(vEffSecHisto); + } + + if(labelsRec) delete [] labelsRec; labelsRec = 0; + if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0; +} + + + + +//_____________________________________________________________________________ +void AliPerformanceEff::ProcessTPCITS(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent) +{ + // Fill efficiency comparison information + Int_t *labelsRec = new Int_t[esdEvent->GetNumberOfTracks()]; + if(!labelsRec) + AliDebug(AliLog::kError, "Cannot create labelsRec"); + + Int_t *labelsAllRec = new Int_t[esdEvent->GetNumberOfTracks()]; + if(!labelsAllRec) + AliDebug(AliLog::kError, "Cannot create labelsAllRec"); + + // loop over rec. tracks + AliESDtrack *track=0; + for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) + { + track = esdEvent->GetTrack(iTrack); + if(!track) continue; + if(track->Charge()==0) continue; + Int_t label = TMath::Abs(track->GetLabel()); + labelsAllRec[iTrack]=label; + + // iTPC+ITS + if(IsRecTPCITS(track) != 0) + labelsRec[iTrack]=label; + } + + // + // MC histograms for efficiency studies + // + if(!mcEvent) return; + + AliStack *stack = mcEvent->Stack(); + if (!stack) { + AliDebug(AliLog::kError, "Stack not available"); + return; + } + + //Int_t nPart = stack->GetNtrack(); + Int_t nPart = stack->GetNprimary(); + for (Int_t iMc = 0; iMc < nPart; ++iMc) + { + TParticle* particle = stack->Particle(iMc); + if (!particle) continue; + if (particle->GetPDG()->Charge() == 0.0) continue; + + // physical primary + Bool_t prim = stack->IsPhysicalPrimary(iMc); + if(!prim) continue; + + Bool_t findable = kFALSE; + for(Int_t iRec=0; iRecGetNumberOfTracks(); ++iRec) + { + // check findable + if(iMc == labelsAllRec[iRec]) + { + findable = IsFindable(mcEvent,iMc); + break; + } + } + + Bool_t recStatus = kFALSE; + for(Int_t iRec=0; iRecGetNumberOfTracks(); ++iRec) + { + // check reconstructed + if(iMc == labelsRec[iRec]) + { + recStatus = kTRUE; + break; + } + } + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; + + // transform Pdg to Pid + Int_t pid = TransformToPID(particle); + + Float_t mceta = particle->Eta(); + Float_t mcphi = particle->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = particle->Pt(); + + // Fill histograms + Double_t vEffHisto[6] = { mceta, mcphi, mcpt, pid, recStatus, findable}; + fEffHisto->Fill(vEffHisto); + } + + if(labelsRec) delete [] labelsRec; labelsRec = 0; + if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0; +} + +//_____________________________________________________________________________ +void AliPerformanceEff::ProcessConstrained(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent) +{ + // Process comparison information + Int_t *labelsRec = new Int_t[esdEvent->GetNumberOfTracks()]; + if(!labelsRec) + AliDebug(AliLog::kError, "Cannot create labelsRec"); + + Int_t *labelsAllRec = new Int_t[esdEvent->GetNumberOfTracks()]; + if(!labelsAllRec) + AliDebug(AliLog::kError, "Cannot create labelsAllRec"); + + // loop over rec. tracks + AliESDtrack *track=0; + for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) + { + track = esdEvent->GetTrack(iTrack); + if(!track) continue; + if(track->Charge()==0) continue; + Int_t label = TMath::Abs(track->GetLabel()); + labelsAllRec[iTrack]=label; + + // Constrained + if(IsRecConstrained(track) != 0) + labelsRec[iTrack]=label; + + } + + // + // MC histograms for efficiency studies + // + if(!mcEvent) return; + + AliStack *stack = mcEvent->Stack(); + if (!stack) { + AliDebug(AliLog::kError, "Stack not available"); + return; + } + + //Int_t nPart = stack->GetNtrack(); + Int_t nPart = stack->GetNprimary(); + for (Int_t iMc = 0; iMc < nPart; ++iMc) + { + TParticle* particle = stack->Particle(iMc); + if (!particle) continue; + if (particle->GetPDG()->Charge() == 0.0) continue; + + // physical primary + Bool_t prim = stack->IsPhysicalPrimary(iMc); + if(!prim) continue; + + Bool_t findable = kFALSE; + for(Int_t iRec=0; iRecGetNumberOfTracks(); ++iRec) + { + // check findable + if(iMc == labelsAllRec[iRec]) + { + findable = IsFindable(mcEvent,iMc); + break; + } + } + + Bool_t recStatus = kFALSE; + for(Int_t iRec=0; iRecGetNumberOfTracks(); ++iRec) + { + // check reconstructed + if(iMc == labelsRec[iRec]) + { + recStatus = kTRUE; + break; + } + } + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) continue; + + // transform Pdg to Pid + Int_t pid = TransformToPID(particle); + + Float_t mceta = particle->Eta(); + Float_t mcphi = particle->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = particle->Pt(); + + // Fill histograms + Double_t vEffHisto[6] = { mceta, mcphi, mcpt, pid, recStatus, findable}; + fEffHisto->Fill(vEffHisto); + } + + if(labelsRec) delete [] labelsRec; labelsRec = 0; + if(labelsAllRec) delete [] labelsAllRec; labelsAllRec = 0; +} + +//_____________________________________________________________________________ +void AliPerformanceEff::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend) +{ + // Process comparison information + // + if(!esdEvent) + { + Error("Exec","esdEvent not available"); + return; + } + AliHeader* header = 0; + AliGenEventHeader* genHeader = 0; + AliStack* stack = 0; + TArrayF vtxMC(3); + + if(bUseMC) + { + if(!mcEvent) { + Error("Exec","mcEvent not available"); + return; + } + // get MC event header + header = mcEvent->Header(); + if (!header) { + Error("Exec","Header not available"); + return; + } + // MC particle stack + stack = mcEvent->Stack(); + if (!stack) { + Error("Exec","Stack not available"); + return; + } + // get MC vertex + genHeader = header->GenEventHeader(); + if (!genHeader) { + Error("Exec","Could not retrieve genHeader from Header"); + return; + } + genHeader->PrimaryVertex(vtxMC); + } + else { + Error("Exec","MC information required!"); + return; + } + + // use ESD friends + if(bUseESDfriend) { + if(!esdFriend) { + Error("Exec","esdFriend not available"); + return; + } + } + + // + // Process events + // + if(GetAnalysisMode() == 0) ProcessTPC(mcEvent,esdEvent); + else if(GetAnalysisMode() == 1) ProcessTPCITS(mcEvent,esdEvent); + else if(GetAnalysisMode() == 2) ProcessConstrained(mcEvent,esdEvent); + else if(GetAnalysisMode() == 5) ProcessTPCSec(mcEvent,esdEvent); + else { + printf("ERROR: AnalysisMode %d \n",fAnalysisMode); + return; + } +} + +//_____________________________________________________________________________ +Int_t AliPerformanceEff::TransformToPID(TParticle *particle) +{ +// transform Pdg to Pid +// Pdg convension is different for hadrons and leptons +// (e.g. K+/K- = 321/-321; e+/e- = -11/11 ) + + Int_t pid = -1; + if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetEM() ) pid = 0; + if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetMuM() ) pid = 1; + if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetPiP() ) pid = 2; + if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetKP() ) pid = 3; + if( TMath::Abs(particle->GetPdgCode())==fCutsMC->GetProt() ) pid = 4; + +return pid; +} + +//_____________________________________________________________________________ +Bool_t AliPerformanceEff::IsFindable(const AliMCEvent *mcEvent, Int_t label) +{ +// +// Findfindable tracks +// +if(!mcEvent) return kFALSE; + + AliMCParticle *mcParticle = (AliMCParticle*) mcEvent->GetTrack(label); + if(!mcParticle) return kFALSE; + + Int_t counter; + Float_t tpcTrackLength = mcParticle->GetTPCTrackLength(AliTracker::GetBz(),0.05,counter,3.0); + //printf("tpcTrackLength %f \n", tpcTrackLength); + +return (tpcTrackLength>fCutsMC->GetMinTrackLength()); +} + +//_____________________________________________________________________________ +Bool_t AliPerformanceEff::IsRecTPC(AliESDtrack *esdTrack) +{ +// +// Check whether track is reconstructed in TPC +// +if(!esdTrack) return kFALSE; + + const AliExternalTrackParam *track = esdTrack->GetTPCInnerParam(); + if(!track) return kFALSE; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParametersTPC(dca,cov); + + Bool_t recStatus = kFALSE; + if(esdTrack->GetTPCNcls()>fCutsRC->GetMinNClustersTPC()) recStatus = kTRUE; + + /* + if( TMath::Abs(dca[0])GetMaxDCAToVertexXY() && + TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + recStatus = kTRUE; + } + */ + +return recStatus; +} + +//_____________________________________________________________________________ +Bool_t AliPerformanceEff::IsRecTPCITS(AliESDtrack *esdTrack) +{ +// +// Check whether track is reconstructed in TPCITS +// +if(!esdTrack) return kFALSE; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParameters(dca,cov); + + Bool_t recStatus = kFALSE; + + if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return kFALSE; // TPC refit + if (esdTrack->GetTPCNcls()GetMinNClustersTPC()) return kFALSE; // min. nb. TPC clusters + //if ((esdTrack->GetStatus()&AliESDtrack::kITSrefit)==0) return kFALSE; // ITS refit + //Int_t clusterITS[200]; + //if(esdTrack->GetITSclusters(clusterITS)GetMinNClustersITS()) return kFALSE; // min. nb. ITS clusters + + recStatus = kTRUE; + /* + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && + TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + recStatus = kTRUE; + } + */ + +return recStatus; +} + +//_____________________________________________________________________________ +Bool_t AliPerformanceEff::IsRecConstrained(AliESDtrack *esdTrack) +{ +// +// Check whether track is reconstructed in IsRecConstrained +// + if(!esdTrack) return kFALSE; + + const AliExternalTrackParam * track = esdTrack->GetConstrainedParam(); + if(!track) return kFALSE; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParameters(dca,cov); + //Int_t label = TMath::Abs(esdTrack->GetLabel()); + + Bool_t recStatus = kFALSE; + + if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return kFALSE; // TPC refit + if (esdTrack->GetTPCNcls()GetMinNClustersTPC()) return kFALSE; // min. nb. TPC clusters + Int_t clusterITS[200]; + if(esdTrack->GetITSclusters(clusterITS)GetMinNClustersITS()) return kFALSE; // min. nb. ITS clusters + + recStatus = kTRUE; + + /* + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && + TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + recStatus = kTRUE; + } + */ + +return recStatus; +} + +//_____________________________________________________________________________ +Long64_t AliPerformanceEff::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliPerformanceEff* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fEffHisto->Add(entry->fEffHisto); + fEffSecHisto->Add(entry->fEffSecHisto); + count++; + } + +return count; +} + +//_____________________________________________________________________________ +void AliPerformanceEff::Analyse() +{ + // Analyse comparison information and store output histograms + // in the folder "folderEff" + // + TH1::AddDirectory(kFALSE); + TObjArray *aFolderObj = new TObjArray; + char title[256]; + + // + // efficiency vs pt + // + + if(GetAnalysisMode() != 5) { + + fEffHisto->GetAxis(0)->SetRangeUser(-0.9,0.9); // eta range + fEffHisto->GetAxis(2)->SetRangeUser(0.1,10.); // pt range + + // rec efficiency vs pt + TH1D *ptAll = fEffHisto->Projection(2); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRec = fEffHisto->Projection(2); + TH1D *ptRecc = (TH1D*)ptRec->Clone(); + ptRecc->Divide(ptRec,ptAll,1,1,"B"); + ptRecc->SetName("ptRecEff"); + + ptRecc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle()); + ptRecc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(2)->GetTitle()); + ptRecc->SetTitle(title); + + ptRecc->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecc); + + // rec efficiency vs pid vs pt + + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions + + TH1D *ptAllPi = fEffHisto->Projection(2); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRecPi = fEffHisto->Projection(2); + TH1D *ptRecPic = (TH1D*)ptRecPi->Clone(); + ptRecPic->Divide(ptRecPi,ptAllPi,1,1,"B"); + ptRecPic->SetName("ptRecEffPi"); + + ptRecPic->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle()); + ptRecPic->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(2)->GetTitle()); + ptRecPic->SetTitle(title); + + ptRecPic->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecPic); + + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons + TH1D *ptAllK = fEffHisto->Projection(2); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRecK = fEffHisto->Projection(2); + + TH1D *ptRecKc = (TH1D*)ptRecK->Clone(); + ptRecKc->Divide(ptRecK,ptAllK,1,1,"B"); + ptRecKc->SetName("ptRecEffK"); + + ptRecKc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle()); + ptRecKc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(2)->GetTitle()); + ptRecKc->SetTitle(title); + + + ptRecKc->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecKc); + + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons + TH1D *ptAllP = fEffHisto->Projection(2); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRecP = fEffHisto->Projection(2); + TH1D *ptRecPc = (TH1D*)ptRecP->Clone(); + ptRecPc->Divide(ptRecP,ptAllP,1,1,"B"); + ptRecPc->SetName("ptRecEffP"); + + ptRecPc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle()); + ptRecPc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(2)->GetTitle()); + ptRecPc->SetTitle(title); + + ptRecPc->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecPc); + + // findable efficiency vs pt + + fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable + TH1D *ptAllF = fEffHisto->Projection(2); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); + + TH1D *ptRecF = fEffHisto->Projection(2); // rec findable + TH1D *ptRecFc = (TH1D*)ptRecF->Clone(); + ptRecFc->Divide(ptRecF,ptAllF,1,1,"B"); + ptRecFc->SetName("ptRecEffF"); + + ptRecFc->GetXaxis()->SetTitle(fEffHisto->GetAxis(2)->GetTitle()); + ptRecFc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(2)->GetTitle()); + ptRecFc->SetTitle(title); + + ptRecFc->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecFc); + + // + // efficiency vs eta + // + + fEffHisto->GetAxis(0)->SetRangeUser(-1.5,1.5); // eta range + fEffHisto->GetAxis(2)->SetRangeUser(0.2,10.); // pt range + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); // all + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); // all + + TH1D *etaAll = fEffHisto->Projection(0); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRec = fEffHisto->Projection(0); + TH1D *etaRecc = (TH1D*)etaRec->Clone(); + etaRecc->Divide(etaRec,etaAll,1,1,"B"); + etaRecc->SetName("etaRecEff"); + + etaRecc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle()); + etaRecc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(0)->GetTitle()); + etaRecc->SetTitle(title); + + aFolderObj->Add(etaRecc); + + // rec efficiency vs pid vs eta + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions + + TH1D *etaAllPi = fEffHisto->Projection(0); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRecPi = fEffHisto->Projection(0); + TH1D *etaRecPic = (TH1D*)etaRecPi->Clone(); + etaRecPic->Divide(etaRecPi,etaAllPi,1,1,"B"); + etaRecPic->SetName("etaRecEffPi"); + + etaRecPic->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle()); + etaRecPic->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(0)->GetTitle()); + etaRecPic->SetTitle(title); + + aFolderObj->Add(etaRecPic); + + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons + TH1D *etaAllK = fEffHisto->Projection(0); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRecK = fEffHisto->Projection(0); + + TH1D *etaRecKc = (TH1D*)etaRecK->Clone(); + etaRecKc->Divide(etaRecK,etaAllK,1,1,"B"); + etaRecKc->SetName("etaRecEffK"); + + etaRecKc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle()); + etaRecKc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(0)->GetTitle()); + etaRecKc->SetTitle(title); + + + aFolderObj->Add(etaRecKc); + + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons + TH1D *etaAllP = fEffHisto->Projection(0); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRecP = fEffHisto->Projection(0); + TH1D *etaRecPc = (TH1D*)etaRecP->Clone(); + etaRecPc->Divide(etaRecP,etaAllP,1,1,"B"); + etaRecPc->SetName("etaRecEffP"); + + etaRecPc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle()); + etaRecPc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(0)->GetTitle()); + etaRecPc->SetTitle(title); + + aFolderObj->Add(etaRecPc); + + // findable efficiency vs eta + + fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable + TH1D *etaAllF = fEffHisto->Projection(0); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); + + TH1D *etaRecF = fEffHisto->Projection(0); // rec findable + TH1D *etaRecFc = (TH1D*)etaRecF->Clone(); + etaRecFc->Divide(etaRecF,etaAllF,1,1,"B"); + etaRecFc->SetName("etaRecEffF"); + + etaRecFc->GetXaxis()->SetTitle(fEffHisto->GetAxis(0)->GetTitle()); + etaRecFc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(0)->GetTitle()); + etaRecFc->SetTitle(title); + + aFolderObj->Add(etaRecFc); + + // + // efficiency vs phi + // + + fEffHisto->GetAxis(0)->SetRangeUser(-0.9,0.9); // eta range + fEffHisto->GetAxis(2)->SetRangeUser(0.2,10.); // pt range + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); // all + fEffHisto->GetAxis(5)->SetRangeUser(0.,1.); // all + + TH1D *phiAll = fEffHisto->Projection(1); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *phiRec = fEffHisto->Projection(1); + TH1D *phiRecc = (TH1D*)phiRec->Clone(); + phiRecc->Divide(phiRec,phiAll,1,1,"B"); + phiRecc->SetName("phiRecEff"); + + phiRecc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle()); + phiRecc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency",fEffHisto->GetAxis(1)->GetTitle()); + phiRecc->SetTitle(title); + + aFolderObj->Add(phiRecc); + + // rec efficiency vs pid vs phi + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions + + TH1D *phiAllPi = fEffHisto->Projection(1); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *phiRecPi = fEffHisto->Projection(1); + TH1D *phiRecPic = (TH1D*)phiRecPi->Clone(); + phiRecPic->Divide(phiRecPi,phiAllPi,1,1,"B"); + phiRecPic->SetName("phiRecEffPi"); + + phiRecPic->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle()); + phiRecPic->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffHisto->GetAxis(1)->GetTitle()); + phiRecPic->SetTitle(title); + + aFolderObj->Add(phiRecPic); + + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons + TH1D *phiAllK = fEffHisto->Projection(1); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *phiRecK = fEffHisto->Projection(1); + + TH1D *phiRecKc = (TH1D*)phiRecK->Clone(); + phiRecKc->Divide(phiRecK,phiAllK,1,1,"B"); + phiRecKc->SetName("phiRecEffK"); + + phiRecKc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle()); + phiRecKc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffHisto->GetAxis(1)->GetTitle()); + phiRecKc->SetTitle(title); + + + aFolderObj->Add(phiRecKc); + + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons + TH1D *phiAllP = fEffHisto->Projection(1); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *phiRecP = fEffHisto->Projection(1); + TH1D *phiRecPc = (TH1D*)phiRecP->Clone(); + phiRecPc->Divide(phiRecP,phiAllP,1,1,"B"); + phiRecPc->SetName("phiRecEffP"); + + phiRecPc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle()); + phiRecPc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffHisto->GetAxis(1)->GetTitle()); + phiRecPc->SetTitle(title); + + aFolderObj->Add(phiRecPc); + + // findable efficiency vs phi + + fEffHisto->GetAxis(3)->SetRangeUser(0.,4.); + fEffHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable + TH1D *phiAllF = fEffHisto->Projection(1); + + fEffHisto->GetAxis(4)->SetRangeUser(1.,1.); + fEffHisto->GetAxis(5)->SetRangeUser(1.,1.); + + TH1D *phiRecF = fEffHisto->Projection(1); // rec findable + TH1D *phiRecFc = (TH1D*)phiRecF->Clone(); + phiRecFc->Divide(phiRecF,phiAllF,1,1,"B"); + phiRecFc->SetName("phiRecEffF"); + + phiRecFc->GetXaxis()->SetTitle(fEffHisto->GetAxis(1)->GetTitle()); + phiRecFc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffHisto->GetAxis(1)->GetTitle()); + phiRecFc->SetTitle(title); + + aFolderObj->Add(phiRecFc); + } + else { + // + Float_t minEta=-1.5, maxEta=1.5; + Float_t minR=0.0, maxR=150.0; + Float_t minPt=0.15, maxPt=100.0; + + // mother eta range + fEffSecHisto->GetAxis(8)->SetRangeUser(minEta,maxEta); + + // particle creation radius range + fEffSecHisto->GetAxis(6)->SetRangeUser(minR,maxR); + + // + fEffSecHisto->GetAxis(0)->SetRangeUser(minEta,maxEta); + fEffSecHisto->GetAxis(2)->SetRangeUser(minPt,maxPt); + + // rec efficiency vs pt + TH1D *ptAll = fEffSecHisto->Projection(2); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRec = fEffSecHisto->Projection(2); + TH1D *ptRecc = (TH1D*)ptRec->Clone(); + ptRecc->Divide(ptRec,ptAll,1,1,"B"); + ptRecc->SetName("ptRecEff"); + + ptRecc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency",fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecc->SetTitle(title); + + ptRecc->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecc); + + // rec efficiency vs pid vs pt + + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(0.,0.); // electrons + + TH1D *ptAllEle = fEffSecHisto->Projection(2); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRecEle = fEffSecHisto->Projection(2); + TH1D *ptRecElec = (TH1D*)ptRecEle->Clone(); + ptRecElec->Divide(ptRecEle,ptAllEle,1,1,"B"); + ptRecElec->SetName("ptRecEffEle"); + + ptRecElec->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecElec->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (electrons)",fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecElec->SetTitle(title); + + ptRecElec->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecElec); + + // + + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions + + TH1D *ptAllPi = fEffSecHisto->Projection(2); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRecPi = fEffSecHisto->Projection(2); + TH1D *ptRecPic = (TH1D*)ptRecPi->Clone(); + ptRecPic->Divide(ptRecPi,ptAllPi,1,1,"B"); + ptRecPic->SetName("ptRecEffPi"); + + ptRecPic->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecPic->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecPic->SetTitle(title); + + ptRecPic->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecPic); + + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons + TH1D *ptAllK = fEffSecHisto->Projection(2); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRecK = fEffSecHisto->Projection(2); + + TH1D *ptRecKc = (TH1D*)ptRecK->Clone(); + ptRecKc->Divide(ptRecK,ptAllK,1,1,"B"); + ptRecKc->SetName("ptRecEffK"); + + ptRecKc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecKc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecKc->SetTitle(title); + + + ptRecKc->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecKc); + + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons + TH1D *ptAllP = fEffSecHisto->Projection(2); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *ptRecP = fEffSecHisto->Projection(2); + TH1D *ptRecPc = (TH1D*)ptRecP->Clone(); + ptRecPc->Divide(ptRecP,ptAllP,1,1,"B"); + ptRecPc->SetName("ptRecEffP"); + + ptRecPc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecPc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecPc->SetTitle(title); + + ptRecPc->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecPc); + + // findable efficiency vs pt + + fEffSecHisto->GetAxis(3)->SetRangeUser(0.,4.); + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable + TH1D *ptAllF = fEffSecHisto->Projection(2); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); + fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); + + TH1D *ptRecF = fEffSecHisto->Projection(2); // rec findable + TH1D *ptRecFc = (TH1D*)ptRecF->Clone(); + ptRecFc->Divide(ptRecF,ptAllF,1,1,"B"); + ptRecFc->SetName("ptRecEffF"); + + ptRecFc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecFc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffSecHisto->GetAxis(2)->GetTitle()); + ptRecFc->SetTitle(title); + + ptRecFc->SetBit(TH1::kLogX); + aFolderObj->Add(ptRecFc); + + // + // efficiency vs eta + // + fEffSecHisto->GetAxis(2)->SetRangeUser(minPt,maxPt); + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); // all + fEffSecHisto->GetAxis(5)->SetRangeUser(0.,1.); // all + + TH1D *etaAll = fEffSecHisto->Projection(0); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRec = fEffSecHisto->Projection(0); + TH1D *etaRecc = (TH1D*)etaRec->Clone(); + etaRecc->Divide(etaRec,etaAll,1,1,"B"); + etaRecc->SetName("etaRecEff"); + + etaRecc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency",fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecc->SetTitle(title); + + aFolderObj->Add(etaRecc); + + // rec efficiency vs pid vs eta + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(0.,0.); // electrons + + TH1D *etaAllEle = fEffSecHisto->Projection(0); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRecEle = fEffSecHisto->Projection(0); + TH1D *etaRecElec = (TH1D*)etaRecEle->Clone(); + etaRecElec->Divide(etaRecEle,etaAllEle,1,1,"B"); + etaRecElec->SetName("etaRecEffEle"); + + etaRecElec->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecElec->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (electrons)",fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecElec->SetTitle(title); + + aFolderObj->Add(etaRecElec); + + // + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions + + TH1D *etaAllPi = fEffSecHisto->Projection(0); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRecPi = fEffSecHisto->Projection(0); + TH1D *etaRecPic = (TH1D*)etaRecPi->Clone(); + etaRecPic->Divide(etaRecPi,etaAllPi,1,1,"B"); + etaRecPic->SetName("etaRecEffPi"); + + etaRecPic->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecPic->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecPic->SetTitle(title); + + aFolderObj->Add(etaRecPic); + + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons + TH1D *etaAllK = fEffSecHisto->Projection(0); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRecK = fEffSecHisto->Projection(0); + + TH1D *etaRecKc = (TH1D*)etaRecK->Clone(); + etaRecKc->Divide(etaRecK,etaAllK,1,1,"B"); + etaRecKc->SetName("etaRecEffK"); + + etaRecKc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecKc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecKc->SetTitle(title); + + + aFolderObj->Add(etaRecKc); + + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons + TH1D *etaAllP = fEffSecHisto->Projection(0); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *etaRecP = fEffSecHisto->Projection(0); + TH1D *etaRecPc = (TH1D*)etaRecP->Clone(); + etaRecPc->Divide(etaRecP,etaAllP,1,1,"B"); + etaRecPc->SetName("etaRecEffP"); + + etaRecPc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecPc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecPc->SetTitle(title); + + aFolderObj->Add(etaRecPc); + + // findable efficiency vs eta + + fEffSecHisto->GetAxis(3)->SetRangeUser(0.,4.); + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable + TH1D *etaAllF = fEffSecHisto->Projection(0); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); + fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); + + TH1D *etaRecF = fEffSecHisto->Projection(0); // rec findable + TH1D *etaRecFc = (TH1D*)etaRecF->Clone(); + etaRecFc->Divide(etaRecF,etaAllF,1,1,"B"); + etaRecFc->SetName("etaRecEffF"); + + etaRecFc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecFc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffSecHisto->GetAxis(0)->GetTitle()); + etaRecFc->SetTitle(title); + + aFolderObj->Add(etaRecFc); + + // + // efficiency vs phi + // + + fEffSecHisto->GetAxis(0)->SetRangeUser(minEta,maxEta); + fEffSecHisto->GetAxis(2)->SetRangeUser(minPt,maxPt); + + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); // all + fEffSecHisto->GetAxis(5)->SetRangeUser(0.,1.); // all + + TH1D *phiAll = fEffSecHisto->Projection(1); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *phiRec = fEffSecHisto->Projection(1); + TH1D *phiRecc = (TH1D*)phiRec->Clone(); + phiRecc->Divide(phiRec,phiAll,1,1,"B"); + phiRecc->SetName("phiRecEff"); + + phiRecc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency",fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecc->SetTitle(title); + + aFolderObj->Add(phiRecc); + + // rec efficiency vs pid vs phi + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions + + TH1D *phiAllEle = fEffSecHisto->Projection(1); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *phiRecEle = fEffSecHisto->Projection(1); + TH1D *phiRecElec = (TH1D*)phiRecEle->Clone(); + phiRecElec->Divide(phiRecEle,phiAllEle,1,1,"B"); + phiRecElec->SetName("phiRecEffEle"); + + phiRecElec->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecElec->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (electrons)",fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecElec->SetTitle(title); + + aFolderObj->Add(phiRecElec); + + // + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(2.,2.); // pions + + TH1D *phiAllPi = fEffSecHisto->Projection(1); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *phiRecPi = fEffSecHisto->Projection(1); + TH1D *phiRecPic = (TH1D*)phiRecPi->Clone(); + phiRecPic->Divide(phiRecPi,phiAllPi,1,1,"B"); + phiRecPic->SetName("phiRecEffPi"); + + phiRecPic->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecPic->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (pions)",fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecPic->SetTitle(title); + + aFolderObj->Add(phiRecPic); + + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(3.,3.); // kaons + TH1D *phiAllK = fEffSecHisto->Projection(1); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *phiRecK = fEffSecHisto->Projection(1); + + TH1D *phiRecKc = (TH1D*)phiRecK->Clone(); + phiRecKc->Divide(phiRecK,phiAllK,1,1,"B"); + phiRecKc->SetName("phiRecEffK"); + + phiRecKc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecKc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (kaons)",fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecKc->SetTitle(title); + + + aFolderObj->Add(phiRecKc); + + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(3)->SetRangeUser(4.,4.); // protons + TH1D *phiAllP = fEffSecHisto->Projection(1); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); // reconstructed + TH1D *phiRecP = fEffSecHisto->Projection(1); + TH1D *phiRecPc = (TH1D*)phiRecP->Clone(); + phiRecPc->Divide(phiRecP,phiAllP,1,1,"B"); + phiRecPc->SetName("phiRecEffP"); + + phiRecPc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecPc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (protons)",fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecPc->SetTitle(title); + + aFolderObj->Add(phiRecPc); + + // findable efficiency vs phi + + fEffSecHisto->GetAxis(3)->SetRangeUser(0.,4.); + fEffSecHisto->GetAxis(4)->SetRangeUser(0.,1.); + fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); // findable + TH1D *phiAllF = fEffSecHisto->Projection(1); + + fEffSecHisto->GetAxis(4)->SetRangeUser(1.,1.); + fEffSecHisto->GetAxis(5)->SetRangeUser(1.,1.); + + TH1D *phiRecF = fEffSecHisto->Projection(1); // rec findable + TH1D *phiRecFc = (TH1D*)phiRecF->Clone(); + phiRecFc->Divide(phiRecF,phiAllF,1,1,"B"); + phiRecFc->SetName("phiRecEffF"); + + phiRecFc->GetXaxis()->SetTitle(fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecFc->GetYaxis()->SetTitle("efficiency"); + sprintf(title,"%s vs %s","rec. efficiency (findable)",fEffSecHisto->GetAxis(1)->GetTitle()); + phiRecFc->SetTitle(title); + + aFolderObj->Add(phiRecFc); + } + + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceEff::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliPerformanceEff * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + + +//_____________________________________________________________________________ +TFolder* AliPerformanceEff::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +// +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} diff --git a/PWG1/TPC/AliPerformanceEff.h b/PWG1/TPC/AliPerformanceEff.h new file mode 100644 index 00000000000..bdbf11ab8be --- /dev/null +++ b/PWG1/TPC/AliPerformanceEff.h @@ -0,0 +1,101 @@ +#ifndef ALIPERFORMANCEEFF_H +#define ALIPERFORMANCEEFF_H + +//------------------------------------------------------------------------------ +// Class to keep information from comparison of +// reconstructed and MC particle tracks (TPC efficiency). +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +class TFile; +class TParticle; +class TString; +class TNamed; +class THnSparse; +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliESDfriend; +class AliMCEvent; +class AliESDEvent; +class AliMCParticle; +class AliESDtrack; +class AliESD; +class AliRecInfoCuts; +class AliMCInfoCuts; +class AliESDVertex; + +#include "AliPerformanceObject.h" + +class AliPerformanceEff : public AliPerformanceObject { +public : + AliPerformanceEff(); + AliPerformanceEff(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + ~AliPerformanceEff(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend); + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderEff",TString title = "Analysed Efficiency histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray *array=0); + + // Process events + void ProcessTPC(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent); + void ProcessTPCITS(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent); + void ProcessConstrained(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent); + void ProcessTPCSec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent); + + Bool_t IsRecTPC(AliESDtrack *track); + Bool_t IsRecTPCITS(AliESDtrack *track); + Bool_t IsRecConstrained(AliESDtrack *track); + + Bool_t IsFindable(const AliMCEvent *mcEvent, Int_t label); + Int_t TransformToPID(TParticle *particle); + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + // Getters + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + THnSparseF* GetEffHisto() const {return fEffHisto;} + THnSparseF* GetEffSecHisto() const {return fEffSecHisto;} + +private: + + // Control histograms + THnSparseF *fEffHisto; //-> mceta:mcphi:mcpt:pid:isPrim:recStatus:findable + THnSparseF *fEffSecHisto; //-> mceta:mcphi:mcpt:pid:isPrim:recStatus:findable:mcR:mother_phi:mother_eta + + // Global cuts objects + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliPerformanceEff(const AliPerformanceEff&); // not implemented + AliPerformanceEff& operator=(const AliPerformanceEff&); // not implemented + + ClassDef(AliPerformanceEff,1); +}; + +#endif diff --git a/PWG1/TPC/AliPerformanceMC.cxx b/PWG1/TPC/AliPerformanceMC.cxx new file mode 100644 index 00000000000..f5deccf8099 --- /dev/null +++ b/PWG1/TPC/AliPerformanceMC.cxx @@ -0,0 +1,796 @@ +//------------------------------------------------------------------------------ +// Implementation of AliPerformanceMC class. It keeps information from +// comparison of reconstructed and MC particle tracks. In addtion, +// it keeps selection cuts used during comparison. The comparison +// information is stored in the ROOT histograms. Analysis of these +// histograms can be done by using Analyse() class function. The result of +// the analysis (histograms/graphs) are stored in the folder which is +// a data member of AliPerformanceMC. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + + TFile f("Output.root"); + AliPerformanceMC * compObj = (AliPerformanceMC*)coutput->FindObject("AliPerformanceMC"); + + // analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderRes" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_MC.root","recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include "TCanvas.h" +#include "TH1.h" +#include "TH2.h" +#include "TAxis.h" +#include "TF1.h" + +#include "AliPerformanceMC.h" +#include "AliESDEvent.h" +#include "AliESDVertex.h" +#include "AliESDtrack.h" +#include "AliESDfriendTrack.h" +#include "AliESDfriend.h" +#include "AliLog.h" +#include "AliMCEvent.h" +#include "AliMCParticle.h" +#include "AliHeader.h" +#include "AliGenEventHeader.h" +#include "AliStack.h" +#include "AliMCInfoCuts.h" +#include "AliRecInfoCuts.h" +#include "AliTracker.h" +#include "AliTreeDraw.h" +#include "AliTPCseed.h" + +using namespace std; + +ClassImp(AliPerformanceMC) + +//_____________________________________________________________________________ +AliPerformanceMC::AliPerformanceMC(): + AliPerformanceObject("AliPerformanceMC"), + fResolHisto(0), + fPullHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceMC::AliPerformanceMC(Char_t* name="AliPerformanceMC", Char_t* title="AliPerformanceMC",Int_t analysisMode=0,Bool_t hptGenerator=kFALSE): + AliPerformanceObject(name,title), + fResolHisto(0), + fPullHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + // + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceMC::~AliPerformanceMC() +{ + // destructor + + if(fResolHisto) delete fResolHisto; fResolHisto=0; + if(fPullHisto) delete fPullHisto; fPullHisto=0; + + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; +} + +//_____________________________________________________________________________ +void AliPerformanceMC::Init(){ + + // + // histogram bining + // + + // set pt bins + Int_t nPtBins = 50; + Double_t ptMin = 1.e-2, ptMax = 10.; + + Double_t *binsPt = 0; + if (IsHptGenerator()) { + nPtBins = 100; ptMax = 100.; + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } else { + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } + + Double_t yMin = -0.02, yMax = 0.02; + Double_t zMin = -12.0, zMax = 12.0; + if(GetAnalysisMode() == 3) { // TrackRef coordinate system + yMin = -100.; yMax = 100.; + zMin = -100.; zMax = 100.; + } + + // res_y:res_z:res_phi,res_lambda:res_pt:y:z:eta:phi:pt + Int_t binsResolHisto[10]={100,100,100,100,100,25,50,90,30,nPtBins}; + Double_t minResolHisto[10]={-0.2,-0.2,-0.002,-0.002,-0.002, yMin, zMin, 0., -1.5, ptMin}; + Double_t maxResolHisto[10]={ 0.2, 0.2, 0.002, 0.002, 0.002, yMax, zMax, 2.*TMath::Pi(), 1.5, ptMax}; + + fResolHisto = new THnSparseF("fResolHisto","res_y:res_z:res_phi:res_lambda:res_pt:y:z:phi:eta:pt",10,binsResolHisto,minResolHisto,maxResolHisto); + fResolHisto->SetBinEdges(9,binsPt); + + fResolHisto->GetAxis(0)->SetTitle("y-y_{mc} (cm)"); + fResolHisto->GetAxis(1)->SetTitle("z-z_{mc} (cm)"); + fResolHisto->GetAxis(2)->SetTitle("#phi-#phi_{mc} (rad)"); + fResolHisto->GetAxis(3)->SetTitle("#lambda-#lambda_{mc} (rad)"); + fResolHisto->GetAxis(4)->SetTitle("(p_{T}/p_{Tmc}-1)"); + fResolHisto->GetAxis(5)->SetTitle("y_{mc} (cm)"); + fResolHisto->GetAxis(6)->SetTitle("z_{mc} (cm)"); + fResolHisto->GetAxis(7)->SetTitle("#phi_{mc} (rad)"); + fResolHisto->GetAxis(8)->SetTitle("#eta_{mc}"); + fResolHisto->GetAxis(9)->SetTitle("p_{Tmc} (GeV/c)"); + fResolHisto->Sumw2(); + + //pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt + Int_t binsPullHisto[10]={100,100,100,100,100,50,50,50,50,nPtBins}; + Double_t minPullHisto[10]={-5.,-5.,-5.,-5.,-5., yMin, zMin,-1., -2.0, ptMin}; + Double_t maxPullHisto[10]={ 5., 5., 5., 5., 5., yMax, zMax, 1., 2.0, ptMax}; + fPullHisto = new THnSparseF("fPullHisto","pull_y:pull_z:pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt",10,binsPullHisto,minPullHisto,maxPullHisto); + + fPullHisto->GetAxis(0)->SetTitle("(y-y_{mc})/#sigma"); + fPullHisto->GetAxis(1)->SetTitle("(z-z_{mc})/#sigma"); + fPullHisto->GetAxis(2)->SetTitle("(sin#phi-sin#phi_{mc})/#sigma"); + fPullHisto->GetAxis(3)->SetTitle("(tan#lambda-tan#lambda_{mc})/#sigma"); + fPullHisto->GetAxis(4)->SetTitle("(p_{Tmc}/p_{T}-1)/#sigma"); + fPullHisto->GetAxis(5)->SetTitle("y_{mc} (cm)"); + fPullHisto->GetAxis(6)->SetTitle("z_{mc} (cm)"); + fPullHisto->GetAxis(7)->SetTitle("sin#phi_{mc}"); + fPullHisto->GetAxis(8)->SetTitle("tan#lambda_{mc}"); + fPullHisto->GetAxis(9)->SetTitle("1/p_{Tmc} (GeV/c)^{-1}"); + fPullHisto->Sumw2(); + + // Init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderMC","Analysis MC Folder"); +} + +//_____________________________________________________________________________ +void AliPerformanceMC::Exec(AliMCEvent* const mcEvent, AliESDEvent *const /*esdEvent*/, AliESDfriend *const /*esdFriend*/, const Bool_t bUseMC, const Bool_t /*bUseESDfriend*/) +{ + // Process pure MC information + // + AliHeader* header = 0; + AliGenEventHeader* genHeader = 0; + AliStack* stack = 0; + TArrayF vtxMC(3); + + if(bUseMC) + { + if(!mcEvent) { + Error("Exec","mcEvent not available"); + return; + } + // get MC event header + header = mcEvent->Header(); + if (!header) { + Error("Exec","Header not available"); + return; + } + // MC particle stack + stack = mcEvent->Stack(); + if (!stack) { + Error("Exec","Stack not available"); + return; + } + // get MC vertex + genHeader = header->GenEventHeader(); + if (!genHeader) { + Error("Exec","Could not retrieve genHeader from Header"); + return; + } + genHeader->PrimaryVertex(vtxMC); + } + else { + Error("Exec","MC information required!"); + return; + } + + Int_t nPart = mcEvent->GetNumberOfTracks(); + if (nPart==0) return; + + //TParticle * part = new TParticle; + //TClonesArray * trefs = new TClonesArray("AliTrackReference"); + TParticle *part=0; + TClonesArray *trefs=0; + + // Process events + for (Int_t iPart = 0; iPart < nPart; iPart++) + { + Int_t status = mcEvent->GetParticleAndTR(iPart, part, trefs); + if (status<0) continue; + if(!part) continue; + if(!trefs) continue; + + AliMCParticle *mcParticle = (AliMCParticle*) mcEvent->GetTrack(iPart); + if(!mcParticle) continue; + + TParticle *particle = mcParticle->Particle(); + if(!particle) continue; + + Bool_t prim = stack->IsPhysicalPrimary(iPart); + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) break; + + // exclude electrons + if (fCutsMC->GetEP()==TMath::Abs(particle->GetPdgCode())) return; + + AliTrackReference *refTPCIn = 0; + AliTrackReference *refTPCOut = 0; + AliTrackReference *refITSIn = 0; + AliTrackReference *refITSOut = 0; + AliTrackReference *refTRDIn = 0; + AliTrackReference *refTRDOut = 0; + + Float_t rmax = 0.; + Int_t nTrackRef = mcParticle->GetNumberOfTrackReferences(); + if(nTrackRef < 5) continue; + + for (Int_t iref = 0; iref < nTrackRef; iref++) + { + AliTrackReference *ref = mcParticle->GetTrackReference(iref); + if(!ref) continue; + + Float_t dir = ref->X()*ref->Px()+ref->Y()*ref->Py(); + if(dir < 0.) break; // looping tracks (return back) + if (ref->R()Pt() < fCutsRC->GetPtMin()) break; + + // TPC + if(ref->DetectorId()==AliTrackReference::kTPC) + { + if(!refTPCIn) { + refTPCIn = ref; + } + else { + if(ref->R() > refTPCIn->R()) + refTPCOut = ref; + } + } + // ITS + if(ref->DetectorId()==AliTrackReference::kITS) + { + if(!refITSIn) { + refITSIn = ref; + } + else { + if(ref->R() > refITSIn->R()) + refITSOut = ref; + } + } + // TRD + if(ref->DetectorId()==AliTrackReference::kTRD) + { + if(!refTRDIn) { + refTRDIn = ref; + } + else { + if(ref->R() > refTRDIn->R()) + refTRDOut = ref; + } + } + if (ref->R()>rmax) rmax=ref->R(); + } + + if(GetAnalysisMode() == 0) { + // Propagate refTPCIn to DCA to prim. vertex and make comparison + // only primary particles + if(refTPCIn) { + if(prim) ProcessTPC(refTPCIn,particle); + } + } + + if(GetAnalysisMode() == 3) { + // Propagate refTPCOut to refTPCIn using AliTrack::PropagateTrackToBxByBz() + // + if(refTPCIn && refTPCOut) + ProcessInnerTPC(refTPCIn,refTPCOut,particle); + } + + if(GetAnalysisMode() == 4) { + // propagate refTPCIn to refTPCOut using AliExternalTrackParam::PropagateToBxByBz() + ProcessOuterTPCExt(part,trefs); + } + } + + //if(part) delete part; + //if(trefs) delete trefs; +} + +//_____________________________________________________________________________ +void AliPerformanceMC::ProcessTPC(AliTrackReference* const refIn, TParticle *const particle) { + // + // Test propagation from refIn to DCA + // + if(!refIn) return; + if(!particle) return; + + AliExternalTrackParam *track = 0; + Double_t radius = 2.8; // cm + Double_t mass = particle->GetMass(); + Double_t step=1; + // + track=MakeTrack(refIn,particle); + if (!track) return; + // + //AliTracker::PropagateTrackTo(track, radius+step, mass, step, kTRUE,0.99); + //AliTracker::PropagateTrackTo(track, radius+0.5, mass, step*0.1, kTRUE,0.99); + AliTracker::PropagateTrackToBxByBz(track, radius+step, mass, step, kTRUE,0.99); + AliTracker::PropagateTrackToBxByBz(track, radius+0.5, mass, step*0.1, kTRUE,0.99); + Double_t xyz[3] = {particle->Vx(),particle->Vy(),particle->Vz()}; + Double_t sxyz[3]={0.0,0.0,0.0}; + AliESDVertex vertex(xyz,sxyz); + Double_t dca[2], cov[3]; + //Bool_t isOK = track->PropagateToDCA(&vertex,AliTracker::GetBz(),10,dca,cov); + Double_t field[3]; track->GetBxByBz(field); + Bool_t isOK = track->PropagateToDCABxByBz(&vertex,field,10,dca,cov); + if(!isOK) return; + + // Fill histogram + Float_t deltaPtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC, pullYTPC, pullZTPC, pullPhiTPC, pullLambdaTPC; + + Float_t mceta = particle->Eta(); + Float_t mcphi = particle->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = particle->Pt(); + Float_t mcsnp = TMath::Sin(TMath::ATan2(particle->Py(),particle->Px())); + Float_t mctgl = TMath::Tan(TMath::ATan2(particle->Pz(),particle->Pt())); + + //if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + //{ + if(mcpt == 0) return; + + //deltaYTPC= track->GetY()-particle->Vy(); + deltaYTPC= track->GetY(); // it is already rotated + deltaZTPC = track->GetZ()-particle->Vz(); + deltaLambdaTPC = TMath::ATan2(track->Pz(),track->Pt())-TMath::ATan2(particle->Pz(),particle->Pt()); + deltaPhiTPC = TMath::ATan2(track->Py(),track->Px())-TMath::ATan2(particle->Py(),particle->Px()); + deltaPtTPC = (track->Pt()-mcpt) / mcpt; + + /* + printf("------------------------------ \n"); + printf("trY %f, trZ %f, trTheta %f ,trPhi %f, trPt %f \n", track->GetY(), track->GetZ(), TMath::ATan2(track->Pz(),track->Pt()), TMath::ATan2(track->Py(),track->Px()), track->Pt() ); + printf("partY %f, partZ %f, partTheta %f ,partPhi %f, partPt %f \n", particle->Vy(), particle->Vz(), TMath::ATan2(particle->Pz(),particle->Pt()), TMath::ATan2(particle->Py(),particle->Px()), mcpt ); + */ + + + pullYTPC= (track->GetY()-particle->Vy()) / TMath::Sqrt(track->GetSigmaY2()); + pullZTPC = (track->GetZ()-particle->Vz()) / TMath::Sqrt(track->GetSigmaZ2()); + + pullPhiTPC = (track->GetSnp() - mcsnp) / TMath::Sqrt(track->GetSigmaSnp2()); + pullLambdaTPC = (track->GetTgl() - mctgl) / TMath::Sqrt(track->GetSigmaTgl2()); + + if (mcpt) pull1PtTPC = (track->OneOverPt()-1./mcpt) / TMath::Sqrt(track->GetSigma1Pt2()); + else pull1PtTPC = 0.; + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,deltaPtTPC,particle->Vy(),particle->Vz(),mcphi,mceta,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,particle->Vy(),particle->Vz(),mcsnp,mctgl,1./mcpt}; + fPullHisto->Fill(vPullHisto); + //} + if(track) delete track; +} + +//_____________________________________________________________________________ +void AliPerformanceMC::ProcessInnerTPC(AliTrackReference* const refIn, AliTrackReference *const refOut, TParticle *const particle) { + // + // Test propagation from Out to In + // + if(!refIn) return; + if(!refOut) return; + if(!particle) return; + + AliExternalTrackParam *track=MakeTrack(refOut,particle); + if (!track) return; + + Double_t mass = particle->GetMass(); + Double_t step=1; + + Float_t alphaIn= TMath::ATan2(refIn->Y(),refIn->X()); + //Float_t alphaOut= TMath::ATan2(refOut->Y(),refOut->X()); + //track->Rotate(alphaIn-alphaOut); + track->Rotate(alphaIn); + //printf("alphaIn %f, alphaOut %f \n",alphaIn,alphaOut); + + // + //Bool_t isOK = AliTracker::PropagateTrackTo(track, refIn->R(), mass, step, kTRUE,0.99); + //Bool_t isOK = AliTracker::PropagateTrackTo(track, refIn->R(), mass, step, kFALSE,0.99); + Bool_t isOK = AliTracker::PropagateTrackToBxByBz(track, refIn->R(), mass, step, kFALSE,0.99); + if(!isOK) return; + + // calculate alpha angle + //Double_t xyz[3] = {refIn->X(),refIn->Y(),refIn0->Z()}; + //Double_t alpha = TMath::ATan2(xyz[1],xyz[0]); + //if (alpha<0) alpha += TMath::TwoPi(); + + // rotate outer track to inner + // and propagate to the radius of the first track referenco of TPC + //Double_t trRadius = TMath::Sqrt(xyz[1] * xyz[1] + xyz[0] * xyz[0]); + //Bool_t isOK = track->Propagate(alpha,trRadius,AliTracker::GetBz()); + //if(!isOK) return; + + Float_t mceta = -TMath::Log(TMath::Tan(0.5 * refIn->Theta())); + Float_t mcphi = refIn->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = refIn->Pt(); + Float_t mcsnp = TMath::Sin(TMath::ATan2(refIn->Py(),refIn->Px())); + Float_t mctgl = TMath::Tan(TMath::ATan2(refIn->Pz(),refIn->Pt())); + + Float_t deltaPtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC=0., pullYTPC=0., pullZTPC=0., pullPhiTPC=0., pullLambdaTPC=0.; + + if(mcpt == 0) return; + + //deltaYTPC = track->GetY()-refIn->Y(); + deltaYTPC = track->GetY(); + deltaZTPC = track->GetZ()-refIn->Z(); + deltaLambdaTPC = TMath::ATan2(track->Pz(),track->Pt())-TMath::ATan2(refIn->Pz(),refIn->Pt()); + deltaPhiTPC = TMath::ATan2(track->Py(),track->Px())-TMath::ATan2(refIn->Py(),refIn->Px()); + deltaPtTPC = (track->Pt()-mcpt) / mcpt; + + /* + printf("------------------------------ \n"); + printf("trX %f, trY %f, trZ %f, trTheta %f ,trPhi %f, trPt %f \n", track->GetX(), track->GetY(), track->GetZ(), TMath::ATan2(track->Pz(),track->Pt()), TMath::ATan2(track->Py(),track->Px()), track->Pt() ); + printf("partX %f, partY %f, partZ %f, partTheta %f ,partPhi %f, partPt %f \n",refIn->X(), refIn->Y(), refIn->Z(), TMath::ATan2(refIn->Pz(),refIn->Pt()), TMath::ATan2(refIn->Py(),refIn->Px()), mcpt ); + */ + + if(TMath::Sqrt(track->GetSigmaY2())) pullYTPC = track->GetY() / TMath::Sqrt(track->GetSigmaY2()); + if(TMath::Sqrt(track->GetSigmaZ2())) pullZTPC = (track->GetZ()-refIn->Z()) / TMath::Sqrt(track->GetSigmaZ2()); + if(TMath::Sqrt(track->GetSigmaSnp2())) pullPhiTPC = (track->GetSnp() - mcsnp) / TMath::Sqrt(track->GetSigmaSnp2()); + if(TMath::Sqrt(track->GetSigmaTgl2())) pullLambdaTPC = (track->GetTgl() - mctgl) / TMath::Sqrt(track->GetSigmaTgl2()); + if(TMath::Sqrt(track->GetSigma1Pt2())) pull1PtTPC = (track->OneOverPt()-1./mcpt) / TMath::Sqrt(track->GetSigma1Pt2()); + + //printf("pullYTPC %f,pullZTPC %f,pullPhiTPC %f,pullLambdaTPC %f,pull1PtTPC %f,refIn->Y() %f,refIn->Z() %f,mcsnp %f,mctgl %f,1./mcpt %f \n",pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,refIn->Y(),refIn->Z(),mcsnp,mctgl,1./mcpt); + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,deltaPtTPC,refIn->Y(),refIn->Z(),mcphi,mceta,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,refIn->Y(),refIn->Z(),mcsnp,mctgl,1./mcpt}; + fPullHisto->Fill(vPullHisto); + + if(track) delete track; +} + +//_____________________________________________________________________________ +void AliPerformanceMC::ProcessOuterTPCExt(TParticle *const part, TClonesArray * const trefs) +{ + const Int_t kMinRefs=5; + Int_t nrefs = trefs->GetEntries(); + if (nrefsAt(iref); + if (!ref) continue; + Float_t dir = ref->X()*ref->Px()+ref->Y()*ref->Py(); + if (dir<0) break; + if (ref->DetectorId()!=AliTrackReference::kTPC) continue; + if (iref0<0) iref0 = iref; + iref1 = iref; + } + if (iref1-iref0At(iref0); + AliTrackReference * refOut = (AliTrackReference*)trefs->At(iref1); + AliExternalTrackParam *paramPropagate= MakeTrack(refIn,part); + AliExternalTrackParam *paramUpdate = MakeTrack(refIn,part); + paramUpdate->AddCovariance(covar); + + Bool_t isOKP=kTRUE; + Bool_t isOKU=kTRUE; + AliMagF * field = (AliMagF*) TGeoGlobalMagField::Instance()->GetField(); + if(!field) return; + for (Int_t iref = iref0; iref<=iref1; iref++){ + AliTrackReference * ref = (AliTrackReference*)trefs->At(iref); + if(!ref) continue; + Float_t alphaC= TMath::ATan2(ref->Y(),ref->X()); + Double_t pos[3] = {ref->X(), ref->Y(), ref->Z()}; + Double_t mag[3]; + field->Field(pos,mag); + isOKP&=paramPropagate->Rotate(alphaC); + isOKU&=paramUpdate->Rotate(alphaC); + for (Float_t xref= paramPropagate->GetX(); xrefR(); xref++){ + //isOKP&=paramPropagate->PropagateTo(xref, mag[2]); + //isOKU&=paramUpdate->PropagateTo(xref, mag[2]); + isOKP&=paramPropagate->PropagateToBxByBz(xref, mag); + isOKU&=paramUpdate->PropagateToBxByBz(xref, mag); + } + //isOKP&=paramPropagate->PropagateTo(ref->R(), mag[2]); + //isOKU&=paramUpdate->PropagateTo(ref->R(), mag[2]); + isOKP&=paramPropagate->PropagateToBxByBz(ref->R(), mag); + isOKU&=paramUpdate->PropagateToBxByBz(ref->R(), mag); + Double_t clpos[2] = {0, ref->Z()}; + Double_t clcov[3] = { 0.005,0,0.005}; + isOKU&= paramUpdate->Update(clpos, clcov); + } + + Float_t mceta = -TMath::Log(TMath::Tan(0.5 * refOut->Theta())); + Float_t mcphi = refOut->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = refOut->Pt(); + Float_t mcsnp = TMath::Sin(TMath::ATan2(refOut->Py(),refOut->Px())); + Float_t mctgl = TMath::Tan(TMath::ATan2(refOut->Pz(),refOut->Pt())); + + Float_t deltaPtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC=0., pullYTPC=0., pullZTPC=0., pullPhiTPC=0., pullLambdaTPC=0.; + + if(mcpt == 0) return; + + //deltaYTPC = track->GetY()-refIn->Y(); + deltaYTPC = paramPropagate->GetY(); + deltaZTPC = paramPropagate->GetZ()-refOut->Z(); + deltaLambdaTPC = TMath::ATan2(paramPropagate->Pz(),paramPropagate->Pt())-TMath::ATan2(refOut->Pz(),refOut->Pt()); + deltaPhiTPC = TMath::ATan2(paramPropagate->Py(),paramPropagate->Px())-TMath::ATan2(refOut->Py(),refOut->Px()); + deltaPtTPC = (paramPropagate->Pt()-mcpt) / mcpt; + + if(TMath::Sqrt(paramPropagate->GetSigmaY2())) pullYTPC = paramPropagate->GetY() / TMath::Sqrt(paramPropagate->GetSigmaY2()); + if(TMath::Sqrt(paramPropagate->GetSigmaZ2())) pullZTPC = (paramPropagate->GetZ()-refOut->Z()) / TMath::Sqrt(paramPropagate->GetSigmaZ2()); + if(TMath::Sqrt(paramPropagate->GetSigmaSnp2())) pullPhiTPC = (paramPropagate->GetSnp() - mcsnp) / TMath::Sqrt(paramPropagate->GetSigmaSnp2()); + if(TMath::Sqrt(paramPropagate->GetSigmaTgl2())) pullLambdaTPC = (paramPropagate->GetTgl() - mctgl) / TMath::Sqrt(paramPropagate->GetSigmaTgl2()); + if(TMath::Sqrt(paramPropagate->GetSigma1Pt2())) pull1PtTPC = (paramPropagate->OneOverPt()-1./mcpt) / TMath::Sqrt(paramPropagate->GetSigma1Pt2()); + + //printf("pullYTPC %f,pullZTPC %f,pullPhiTPC %f,pullLambdaTPC %f,pull1PtTPC %f,refIn->Y() %f,refIn->Z() %f,mcsnp %f,mctgl %f,1./mcpt %f \n",pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,refIn->Y(),refIn->Z(),mcsnp,mctgl,1./mcpt); + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,deltaPtTPC,refIn->Y(),refIn->Z(),mcphi,mceta,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,refIn->Y(),refIn->Z(),mcsnp,mctgl,1./mcpt}; + fPullHisto->Fill(vPullHisto); +} + +//_____________________________________________________________________________ +AliExternalTrackParam * AliPerformanceMC::MakeTrack(const AliTrackReference* const ref, TParticle* const part) +{ + // + // Make track out of the track ref + // part - TParticle used to determine chargr + // the covariance matrix - equal 0 - starting from ideal MC position + Double_t xyz[3]={ref->X(),ref->Y(),ref->Z()}; + Double_t pxyz[3]={ref->Px(),ref->Py(),ref->Pz()}; + Double_t cv[21]; + for (Int_t i=0; i<21;i++) cv[i]=0; + if (!part->GetPDG()) return 0; + AliExternalTrackParam * param = new AliExternalTrackParam(xyz,pxyz,cv,TMath::Nint(part->GetPDG()->Charge()/3.)); + return param; +} + +//_____________________________________________________________________________ +TH1F* AliPerformanceMC::MakeResol(TH2F * his, Int_t integ, Bool_t type, Int_t cut){ + // Create resolution histograms + + TH1F *hisr, *hism; + if (!gPad) new TCanvas; + hisr = AliTreeDraw::CreateResHistoII(his,&hism,integ,kTRUE,cut); + if (type) return hism; + else + return hisr; +} + +//_____________________________________________________________________________ +void AliPerformanceMC::Analyse() { + // Analyse comparison information and store output histograms + // in the folder "folderRes" + // + TH1::AddDirectory(kFALSE); + TH1F *h=0; + TH2F *h2D=0; + TObjArray *aFolderObj = new TObjArray; + + // write results in the folder + TCanvas * c = new TCanvas("Phi resol Tan","Phi resol Tan"); + c->cd(); + + char name[256]; + char title[256]; + + for(Int_t i=0; i<5; i++) + { + for(Int_t j=5; j<10; j++) + { + //if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window + fResolHisto->GetAxis(9)->SetRangeUser(0.16,10.); // pt threshold + if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(0.,0.9); // eta window + //fResolHisto->GetAxis(9)->SetRangeUser(0.16,3.); // pt window + if(GetAnalysisMode() == 3) fResolHisto->GetAxis(5)->SetRangeUser(-80.,80.); // y range + + h2D = (TH2F*)fResolHisto->Projection(i,j); + + h = AliPerformanceMC::MakeResol(h2D,1,0,20); + sprintf(name,"h_res_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fResolHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fResolHisto->GetAxis(i)->GetTitle(),"(resolution)"); + h->GetYaxis()->SetTitle(title); + sprintf(title,"%s vs %s",title,fResolHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + + h = AliPerformanceMC::MakeResol(h2D,1,1,20); + //h = (TH1F*)arr->At(1); + sprintf(name,"h_mean_res_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fResolHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fResolHisto->GetAxis(i)->GetTitle(),"(mean)"); + h->GetYaxis()->SetTitle(title); + + sprintf(title,"%s vs %s",title,fResolHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + + fResolHisto->GetAxis(8)->SetRangeUser(-1.5,1.5); + fResolHisto->GetAxis(9)->SetRangeUser(0.0,10.); + + // + if(j!=8) fPullHisto->GetAxis(8)->SetRangeUser(-1.0,0.99); // theta window + else fPullHisto->GetAxis(8)->SetRangeUser(-1.5,1.5); // theta window + fPullHisto->GetAxis(9)->SetRangeUser(0.0,10.); // pt threshold + if(GetAnalysisMode() == 3) fPullHisto->GetAxis(5)->SetRangeUser(-80.,80.); // y range + + h2D = (TH2F*)fPullHisto->Projection(i,j); + + h = AliPerformanceMC::MakeResol(h2D,1,0,20); + sprintf(name,"h_pull_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fPullHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fPullHisto->GetAxis(i)->GetTitle(),"(resolution)"); + h->GetYaxis()->SetTitle(title); + sprintf(title,"%s vs %s",title,fPullHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + //if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + + h = AliPerformanceMC::MakeResol(h2D,1,1,20); + sprintf(name,"h_mean_pull_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fPullHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fPullHisto->GetAxis(i)->GetTitle(),"(mean)"); + h->GetYaxis()->SetTitle(title); + sprintf(title,"%s vs %s",title,fPullHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + //if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + } + } + + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceMC::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliPerformanceMC * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + +//_____________________________________________________________________________ +Long64_t AliPerformanceMC::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliPerformanceMC* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fResolHisto->Add(entry->fResolHisto); + fPullHisto->Add(entry->fPullHisto); + + count++; + } + +return count; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceMC::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +// +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} diff --git a/PWG1/TPC/AliPerformanceMC.h b/PWG1/TPC/AliPerformanceMC.h new file mode 100644 index 00000000000..c96c07e5f8a --- /dev/null +++ b/PWG1/TPC/AliPerformanceMC.h @@ -0,0 +1,107 @@ +#ifndef ALIPERFORMANCEMC_H +#define ALIPERFORMANCEMC_H + +//------------------------------------------------------------------------------ +// Class to keep information for MC tracks +// to check propagation algorithm, B-field and material budget. +// +// Author: J.Otwinowski 09/06/2009 +//------------------------------------------------------------------------------ + +class TString; +class TNamed; +class TCanvas; +class TH1F; +class TH2F; +class TParticle; + +class AliESDVertex; +class AliESDtrack; +class AliMCEvent; +class AliStack; +class AliTrackReference; +class AliESDEvent; +class AliESDfriend; +class AliESDfriendTrack; +class AliMCEvent; +class AliMCParticle; +class AliMCInfoCuts; +class AliRecInfoCuts; +class AliExternalTrackParam; + +#include "THnSparse.h" +#include "AliPerformanceObject.h" + +class AliPerformanceMC : public AliPerformanceObject { +public : + AliPerformanceMC(); + AliPerformanceMC(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + virtual ~AliPerformanceMC(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend); + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Process events + void ProcessTPC(AliTrackReference* const refIn, TParticle* const particle); + void ProcessInnerTPC(AliTrackReference* const refIn, AliTrackReference* const refOut, TParticle* const particle); + void ProcessOuterTPCExt(TParticle *const part, TClonesArray * const trefs); + AliExternalTrackParam * MakeTrack(const AliTrackReference* ref, TParticle *const part); + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderMC", TString title = "Analysed MC histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray * array=0); + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + TH1F* MakeResol(TH2F * his, Int_t integ=0, Bool_t type=kFALSE, Int_t cut=0); + + // getters + // + THnSparse *GetResolHisto() const { return fResolHisto; } + THnSparse *GetPullHisto() const { return fPullHisto; } + +private: + // + // Control histograms + // 5 track parameters (details in STEER/AliExternalTrackParam.h) + // + + // resolution histogram + THnSparseF *fResolHisto; //-> res_y:res_z:res_phi:res_lambda:res_pt:y:z:phi:eta:pt + + // pull histogram + THnSparseF *fPullHisto; //-> pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt + + // Global cuts objects + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliPerformanceMC(const AliPerformanceMC&); // not implemented + AliPerformanceMC& operator=(const AliPerformanceMC&); // not implemented + + ClassDef(AliPerformanceMC,1); +}; + +#endif diff --git a/PWG1/TPC/AliPerformanceMatch.cxx b/PWG1/TPC/AliPerformanceMatch.cxx new file mode 100644 index 00000000000..8e89b3b0954 --- /dev/null +++ b/PWG1/TPC/AliPerformanceMatch.cxx @@ -0,0 +1,653 @@ +//------------------------------------------------------------------------------ +// Implementation of AliPerformanceMatch class. It checks the track matching +// quality (residuals, pulls) bewteen tracking detectors TPC-ITS and TPC-TRD +// with TPC as the reference detector. In addition, the ITS and TRD track +// reconstruction efficiency with respect to TPC is calculated. +// +// The matchinig quality parameters are stored in the THnSparse histograms. +// The analysis of these histograms to extract reference information is done in +// the Analyse() function (post-processing). +// +// The histograms with reference information can be exported to the ROOT folder. +// +// Author: J.Otwinowski 17/10/2009 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + + TFile f("Output.root"); + AliPerformanceMatch * compObj = (AliPerformanceMatch*)coutput->FindObject("AliPerformanceMatchTPCTRD"); + + // analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderMatch" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_Match.root","recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include "TCanvas.h" +#include "TH1.h" +#include "TH2.h" +#include "TAxis.h" +#include "TF1.h" + +#include "AliPerformanceMatch.h" +#include "AliESDEvent.h" +#include "AliESDVertex.h" +#include "AliESDtrack.h" +#include "AliESDfriendTrack.h" +#include "AliESDfriend.h" +#include "AliLog.h" +#include "AliMCEvent.h" +#include "AliMCParticle.h" +#include "AliHeader.h" +#include "AliGenEventHeader.h" +#include "AliStack.h" +#include "AliMCInfoCuts.h" +#include "AliRecInfoCuts.h" +#include "AliTracker.h" +#include "AliTRDtrackV1.h" +#include "AliTreeDraw.h" + +using namespace std; + +ClassImp(AliPerformanceMatch) + +//_____________________________________________________________________________ +AliPerformanceMatch::AliPerformanceMatch(): + AliPerformanceObject("AliPerformanceMatch"), + fResolHisto(0), + fPullHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceMatch::AliPerformanceMatch(Char_t* name="AliPerformanceMatch", Char_t* title="AliPerformanceMatch",Int_t analysisMode=0,Bool_t hptGenerator=kFALSE): + AliPerformanceObject(name,title), + fResolHisto(0), + fPullHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + // + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceMatch::~AliPerformanceMatch() +{ + // destructor + + if(fResolHisto) delete fResolHisto; fResolHisto=0; + if(fPullHisto) delete fPullHisto; fPullHisto=0; + + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; +} + +//_____________________________________________________________________________ +void AliPerformanceMatch::Init(){ + + // + // Make performance histogrms + // + + // set pt bins + Int_t nPtBins = 50; + Double_t ptMin = 1.e-2, ptMax = 10.; + + Double_t *binsPt = 0; + if (IsHptGenerator()) { + nPtBins = 100; ptMax = 100.; + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } else { + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } + + Double_t yMin = -0.02, yMax = 0.02; + Double_t zMin = -12.0, zMax = 12.0; + if(GetAnalysisMode() == 0 || GetAnalysisMode() == 1) { + yMin = -100.; yMax = 100.; + zMin = -100.; zMax = 100.; + } + + // res_y:res_z:res_phi,res_lambda:res_pt:y:z:eta:phi:pt:isRec + Int_t binsResolHisto[11]={100,100,100,100,100,25,50,90,30,nPtBins,2}; + Double_t minResolHisto[11]={-1.,-1.,-0.03,-0.03,-0.2, yMin, zMin, 0., -1.5, ptMin,0}; + Double_t maxResolHisto[11]={ 1., 1., 0.03, 0.03, 0.2, yMax, zMax, 2.*TMath::Pi(), 1.5, ptMax,2}; + + fResolHisto = new THnSparseF("fResolHisto","res_y:res_z:res_phi:res_lambda:res_pt:y:z:phi:eta:pt:isRec",11,binsResolHisto,minResolHisto,maxResolHisto); + fResolHisto->SetBinEdges(9,binsPt); + + fResolHisto->GetAxis(0)->SetTitle("y-y_{ref} (cm)"); + fResolHisto->GetAxis(1)->SetTitle("z-z_{ref} (cm)"); + fResolHisto->GetAxis(2)->SetTitle("#phi-#phi_{ref} (rad)"); + fResolHisto->GetAxis(3)->SetTitle("#lambda-#lambda_{ref} (rad)"); + fResolHisto->GetAxis(4)->SetTitle("(p_{T}/p_{Tref}-1)"); + fResolHisto->GetAxis(5)->SetTitle("y_{ref} (cm)"); + fResolHisto->GetAxis(6)->SetTitle("z_{ref} (cm)"); + fResolHisto->GetAxis(7)->SetTitle("#phi_{ref} (rad)"); + fResolHisto->GetAxis(8)->SetTitle("#eta_{ref}"); + fResolHisto->GetAxis(9)->SetTitle("p_{Tref} (GeV/c)"); + fResolHisto->GetAxis(10)->SetTitle("isReconstructed"); + fResolHisto->Sumw2(); + + //pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt:isRec + Int_t binsPullHisto[11]={100,100,100,100,100,50,50,50,50,nPtBins,2}; + Double_t minPullHisto[11]={-5.,-5.,-5.,-5.,-5., yMin, zMin,-1.,-2.0, ptMin,0}; + Double_t maxPullHisto[11]={ 5., 5., 5., 5., 5., yMax, zMax, 1., 2.0, ptMax,2}; + fPullHisto = new THnSparseF("fPullHisto","pull_y:pull_z:pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt:isRec",11,binsPullHisto,minPullHisto,maxPullHisto); + + fPullHisto->GetAxis(0)->SetTitle("(y-y_{ref})/#sigma"); + fPullHisto->GetAxis(1)->SetTitle("(z-z_{ref})/#sigma"); + fPullHisto->GetAxis(2)->SetTitle("(sin#phi-sin#phi_{ref})/#sigma"); + fPullHisto->GetAxis(3)->SetTitle("(tan#lambda-tan#lambda_{ref})/#sigma"); + fPullHisto->GetAxis(4)->SetTitle("(p_{Tref}/p_{T}-1)/#sigma"); + fPullHisto->GetAxis(5)->SetTitle("y_{ref} (cm)"); + fPullHisto->GetAxis(6)->SetTitle("z_{ref} (cm)"); + fPullHisto->GetAxis(7)->SetTitle("sin#phi_{ref}"); + fPullHisto->GetAxis(8)->SetTitle("tan#lambda_{ref}"); + fPullHisto->GetAxis(9)->SetTitle("1/p_{Tref} (GeV/c)^{-1}"); + fPullHisto->GetAxis(10)->SetTitle("isReconstructed"); + fPullHisto->Sumw2(); + + // Init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderRes","Analysis Resolution Folder"); +} + +//_____________________________________________________________________________ +void AliPerformanceMatch::ProcessTPCITS(AliStack* /*const stack*/, AliESDtrack *const esdTrack, AliESDfriendTrack *const esdFriendTrack) +{ + // + // Match TPC and ITS min-bias tracks + // at radius between detectors + // + if(!esdTrack) return; + if(!esdFriendTrack) return; + + // + // Propagate tracks to the radius between TPC-ITS + // using B-field and material budget + // + Double_t radius = fCutsRC->GetTPCITSMatchingRadius(); + Double_t mass = esdTrack->GetMass(); + Double_t step=1.0; // cm + + + // + // Propagate TPCinner (reference detector) + // + Bool_t isTPCOK=kFALSE; + AliExternalTrackParam *innerTPC=NULL; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParametersTPC(dca,cov); + + if( (esdTrack->GetNcls(1)>fCutsRC->GetMinNClustersTPC()) && + (TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) && + (esdTrack->GetTPCInnerParam()) && + (innerTPC=new AliExternalTrackParam(*(esdTrack->GetTPCInnerParam())))) + { + isTPCOK = AliTracker::PropagateTrackToBxByBz(innerTPC,radius,mass,step,kTRUE); + } + if(!isTPCOK) return; + + // + // Propagate ITSouter + // + Bool_t isITSOK=kFALSE; + AliExternalTrackParam *outerITS=NULL; + + if( (esdTrack->GetNcls(0)>fCutsRC->GetMinNClustersITS()) && + (esdFriendTrack->GetITSOut()) && + (outerITS=new AliExternalTrackParam(*(esdFriendTrack->GetITSOut())))) + { + isITSOK = AliTracker::PropagateTrackToBxByBz(outerITS,radius,mass,step,kTRUE); + } + + // + // Fill histograms (TPC reference detector) + // + if(isTPCOK) + FillHistograms(innerTPC,outerITS,isITSOK); + + if(outerITS) delete outerITS; + if(innerTPC) delete innerTPC; +} + +//_____________________________________________________________________________ +void AliPerformanceMatch::ProcessTPCTRD(AliStack* /*const stack*/, AliESDtrack *const esdTrack, AliESDfriendTrack *const esdFriendTrack) +{ + // + // Match TPC and TRD min-bias tracks + // at radius between detectors. TPC is the reference detector. + // + if(!esdTrack) return; + if(!esdFriendTrack) return; + + // + // Propagate tracks to the radius between TPC-TRD + // using B-field and material budget + // + Double_t radius = fCutsRC->GetTPCTRDMatchingRadius(); + Double_t mass = esdTrack->GetMass(); + Double_t step=1.0; // cm + + // + // Propagate TPCouter (reference detector) + // + Bool_t isTPCOK=kFALSE; + AliExternalTrackParam *outerTPC=NULL; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParametersTPC(dca,cov); + + if( (esdTrack->GetNcls(1)>fCutsRC->GetMinNClustersTPC()) && + (TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) && + (esdFriendTrack->GetTPCOut()) && + (outerTPC=new AliExternalTrackParam(*(esdFriendTrack->GetTPCOut())))) + { + isTPCOK = AliTracker::PropagateTrackToBxByBz(outerTPC,radius,mass,step,kTRUE); + } + if(!isTPCOK) return; + + // + // Propagate TRDinner + // + Bool_t isTRDOK = kFALSE; + AliExternalTrackParam *innerTRD=NULL; + + // get TRD track + AliTRDtrackV1 *trdTrack=NULL; //esdFriendTrack = fESDfriend->GetTrack(itrk); + TObject *calObject=NULL; + Int_t icalib = 0; + while((calObject = esdFriendTrack->GetCalibObject(icalib++))) { + if(strcmp(calObject->IsA()->GetName(),"AliTRDtrackV1") != 0) continue; // Look for the TRDtrack + if(!(trdTrack = dynamic_cast(calObject))) break; + } + + //if( (esdTrack->GetNcls(2)>fCutsRC->GetMinNClustersTRD()) && + if( (trdTrack) && + (trdTrack->GetNumberOfTracklets()>fCutsRC->GetMinNTrackletsTRD()) && + (trdTrack->GetTracklet(0)) && + (esdFriendTrack->GetTRDIn()) && + (innerTRD = new AliExternalTrackParam(*(esdFriendTrack->GetTRDIn())))) + { + isTRDOK = AliTracker::PropagateTrackToBxByBz(innerTRD,radius,mass,step,kTRUE); + } + + // + // Fill histograms (TPC reference detector) + // + if(isTPCOK) + FillHistograms(outerTPC,innerTRD,isTRDOK); + + if(outerTPC) delete outerTPC; + if(innerTRD) delete innerTRD; +} + +//_____________________________________________________________________________ +void AliPerformanceMatch::FillHistograms(AliExternalTrackParam *const refParam, AliExternalTrackParam *const param, Bool_t isRec) +{ + // + // fill performance histograms + // (TPC always as reference) + // + if(!refParam) return; + + // + // Deltas (dy,dz,dphi,dtheta,dpt) + // + Float_t delta[5] = {0}; + if(param && isRec) { + delta[0] = param->GetY()-refParam->GetY(); + delta[1] = param->GetZ()-refParam->GetZ(); + delta[2] = TMath::ATan2(param->Py(),param->Px())-TMath::ATan2(refParam->Py(),refParam->Px()); + delta[3] = TMath::ATan2(param->Pz(),param->Pt())-TMath::ATan2(refParam->Pz(),refParam->Pt()); + if(refParam->Pt()) delta[4] = (param->Pt()-refParam->Pt())/refParam->Pt(); + } + // + // Pulls (y,z,snp,tanl,1/pt) + // + Float_t sigma[5] = {0}; + Float_t pull[5] = {0}; + if(param && isRec) { + sigma[0] = TMath::Sqrt(param->GetSigmaY2()+refParam->GetSigmaY2()); + sigma[1] = TMath::Sqrt(param->GetSigmaZ2()+refParam->GetSigmaZ2()); + sigma[2] = TMath::Sqrt(param->GetSigmaSnp2()+refParam->GetSigmaSnp2()); + sigma[3] = TMath::Sqrt(param->GetSigmaTgl2()+refParam->GetSigmaTgl2()); + sigma[4] = TMath::Sqrt(param->GetSigma1Pt2()+refParam->GetSigma1Pt2()); + if(sigma[0]) pull[0] = delta[0] / sigma[0]; + if(sigma[1]) pull[1] = delta[1] / sigma[1]; + if(sigma[2]) pull[2] = (param->GetSnp()-refParam->GetSnp()) / sigma[2]; + if(sigma[3]) pull[3] = (param->GetTgl()-refParam->GetTgl()) / sigma[3]; + if(sigma[4]) pull[4] = (param->OneOverPt()-refParam->OneOverPt()) / sigma[4]; + } + + // Fill histograms + Double_t vResolHisto[11] = {delta[0],delta[1],delta[2],delta[3],delta[4],refParam->GetY(),refParam->GetZ(),refParam->Phi(),refParam->Eta(),refParam->Pt(),isRec}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[11] = {pull[0],pull[1],pull[2],pull[3],pull[4],refParam->GetY(),refParam->GetZ(),refParam->GetSnp(),refParam->GetTgl(),refParam->OneOverPt(),isRec}; + fPullHisto->Fill(vPullHisto); +} + +//_____________________________________________________________________________ +void AliPerformanceMatch::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend) +{ + // Process comparison information + // + if(!esdEvent) + { + Error("Exec","esdEvent not available"); + return; + } + AliHeader* header = 0; + AliGenEventHeader* genHeader = 0; + AliStack* stack = 0; + TArrayF vtxMC(3); + + if(bUseMC) + { + if(!mcEvent) { + Error("Exec","mcEvent not available"); + return; + } + // get MC event header + header = mcEvent->Header(); + if (!header) { + Error("Exec","Header not available"); + return; + } + // MC particle stack + stack = mcEvent->Stack(); + if (!stack) { + Error("Exec","Stack not available"); + return; + } + // get MC vertex + genHeader = header->GenEventHeader(); + if (!genHeader) { + Error("Exec","Could not retrieve genHeader from Header"); + return; + } + genHeader->PrimaryVertex(vtxMC); + } + + // use ESD friends + if(bUseESDfriend) { + if(!esdFriend) { + Error("Exec","esdFriend not available"); + return; + } + } + + // Process events + for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) + { + AliESDtrack *track = esdEvent->GetTrack(iTrack); + if(!track) continue; + + AliESDfriendTrack *friendTrack=0; + if(bUseESDfriend) { + friendTrack=esdFriend->GetTrack(iTrack); + if(!friendTrack) continue; + } + + if(GetAnalysisMode() == 0) ProcessTPCITS(stack,track,friendTrack); + else if(GetAnalysisMode() == 1) ProcessTPCTRD(stack,track,friendTrack); + else { + printf("ERROR: AnalysisMode %d \n",fAnalysisMode); + return; + } + } +} + +//_____________________________________________________________________________ +TH1F* AliPerformanceMatch::MakeResol(TH2F * his, Int_t integ, Bool_t type, Int_t cut){ + // Create resolution histograms + + TH1F *hisr, *hism; + if (!gPad) new TCanvas; + hisr = AliTreeDraw::CreateResHistoII(his,&hism,integ,kTRUE,cut); + if (type) return hism; + else + return hisr; +} + +//_____________________________________________________________________________ +void AliPerformanceMatch::Analyse() { + // Analyse comparison information and store output histograms + // in the folder "folderMatch" + // + TH1::AddDirectory(kFALSE); + TH1F *h=0; + TH1F *h2=0; + TH2F *h2D=0; + TObjArray *aFolderObj = new TObjArray; + + // write results in the folder + TCanvas * c = new TCanvas("Phi resol Tan","Phi resol Tan"); + c->cd(); + + char name[256]; + char title[256]; + + fResolHisto->GetAxis(10)->SetRangeUser(1.0,2.0); // only reconstructed + fPullHisto->GetAxis(10)->SetRangeUser(1.0,2.0); // only reconstructed + for(Int_t i=0; i<5; i++) + { + for(Int_t j=5; j<10; j++) + { + //if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window + if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(0.0,0.89); // eta window + else fResolHisto->GetAxis(8)->SetRangeUser(-1.5,1.49); + fResolHisto->GetAxis(9)->SetRangeUser(0.16,100.); // pt threshold + + h2D = (TH2F*)fResolHisto->Projection(i,j); + + h = AliPerformanceMatch::MakeResol(h2D,1,0,100); + sprintf(name,"h_res_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fResolHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fResolHisto->GetAxis(i)->GetTitle(),"(resolution)"); + h->GetYaxis()->SetTitle(title); + sprintf(title,"%s vs %s",title,fResolHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + + h = AliPerformanceMatch::MakeResol(h2D,1,1,100); + //h = (TH1F*)arr->At(1); + sprintf(name,"h_mean_res_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fResolHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fResolHisto->GetAxis(i)->GetTitle(),"(mean)"); + h->GetYaxis()->SetTitle(title); + + sprintf(title,"%s vs %s",title,fResolHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + + // + //if(j!=8) fPullHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window + if(j!=8) fPullHisto->GetAxis(8)->SetRangeUser(0.0,0.89); // eta window + else fPullHisto->GetAxis(8)->SetRangeUser(-1.5,1.49); // eta window + fPullHisto->GetAxis(9)->SetRangeUser(0.16,100.); // pt threshold + + h2D = (TH2F*)fPullHisto->Projection(i,j); + + h = AliPerformanceMatch::MakeResol(h2D,1,0,100); + sprintf(name,"h_pull_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fPullHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fPullHisto->GetAxis(i)->GetTitle(),"(resolution)"); + h->GetYaxis()->SetTitle(title); + sprintf(title,"%s vs %s",title,fPullHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + //if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + + h = AliPerformanceMatch::MakeResol(h2D,1,1,100); + sprintf(name,"h_mean_pull_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fPullHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fPullHisto->GetAxis(i)->GetTitle(),"(mean)"); + h->GetYaxis()->SetTitle(title); + sprintf(title,"%s vs %s",title,fPullHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + //if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + } + } + + // + // Efficiency plots + // + for(Int_t i=5; i<10; i++) + { + if(i!=8) fResolHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window + else fResolHisto->GetAxis(8)->SetRangeUser(-1.5,1.49); + fResolHisto->GetAxis(9)->SetRangeUser(0.16,100.); // pt threshold + + fResolHisto->GetAxis(10)->SetRange(1,fResolHisto->GetAxis(10)->GetNbins()); // all + h = (TH1F*)fResolHisto->Projection(i); + + fResolHisto->GetAxis(10)->SetRangeUser(1.0,2.0); // only reconstructed + h2 = (TH1F*)fResolHisto->Projection(i); + + TH1F* h2c = (TH1F*)h2->Clone(); + h2c->Divide(h2c,h,1,1,"B"); + + sprintf(name,"h_eff_%d",i); + h2c->SetName(name); + + h2c->GetXaxis()->SetTitle(h2c->GetXaxis()->GetTitle()); + h2c->GetYaxis()->SetTitle("efficiency"); + h2c->SetTitle("matching effciency"); + + aFolderObj->Add(h2c); + } + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceMatch::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliPerformanceMatch * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + +//_____________________________________________________________________________ +Long64_t AliPerformanceMatch::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliPerformanceMatch* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fResolHisto->Add(entry->fResolHisto); + fPullHisto->Add(entry->fPullHisto); + + count++; + } + +return count; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceMatch::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +// +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} diff --git a/PWG1/TPC/AliPerformanceMatch.h b/PWG1/TPC/AliPerformanceMatch.h new file mode 100644 index 00000000000..073341fb0dd --- /dev/null +++ b/PWG1/TPC/AliPerformanceMatch.h @@ -0,0 +1,107 @@ +#ifndef ALIPERFORMANCEMATCH_H +#define ALIPERFORMANCEMATCH_H + +//------------------------------------------------------------------------------ +// Class keeps matching information between +// central barrel detectors. +// +// Author: J.Otwinowski 17/10/2009 +//------------------------------------------------------------------------------ + +class TString; +class TNamed; +class TCanvas; +class TH1F; +class TH2F; + +class AliESDVertex; +class AliESDtrack; +class AliMCEvent; +class AliStack; +class AliTrackReference; +class AliESDEvent; +class AliESDfriend; +class AliESDfriendTrack; +class AliMCEvent; +class AliMCParticle; +class AliMCInfoCuts; +class AliRecInfoCuts; +class AliExternalTrackParam; + +#include "THnSparse.h" +#include "AliPerformanceObject.h" + +class AliPerformanceMatch : public AliPerformanceObject { +public : + AliPerformanceMatch(); + AliPerformanceMatch(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + virtual ~AliPerformanceMatch(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend); + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Process matching + void ProcessTPCITS(AliStack* const stack, AliESDtrack *const esdTrack, AliESDfriendTrack *const friendTrack); + void ProcessTPCTRD(AliStack* const stack, AliESDtrack *const esdTrack, AliESDfriendTrack *const friendTrack); + + // Fill histogrrams + void FillHistograms(AliExternalTrackParam *const refParam, AliExternalTrackParam *const param, Bool_t isRec); + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderRes",TString title = "Analysed Resolution histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray * array=0); + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + TH1F* MakeResol(TH2F * his, Int_t integ=0, Bool_t type=kFALSE, Int_t cut=0); + + // getters + // + THnSparse *GetResolHisto() const { return fResolHisto; } + THnSparse *GetPullHisto() const { return fPullHisto; } +private: + // + // Control histograms + // 5 track parameters (details in STEER/AliExternalTrackParam.h) + // + isRec flag to determine ITS/TRD tracking efficiency + // w.r.t TPC + + // resolution histogram + THnSparseF *fResolHisto; //-> res_y:res_z:res_phi:res_lambda:res_pt:y:z:phi:eta:pt:isRec + + // pull histogram + THnSparseF *fPullHisto; //-> pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt:isRec + + // Global cuts objects + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliPerformanceMatch(const AliPerformanceMatch&); // not implemented + AliPerformanceMatch& operator=(const AliPerformanceMatch&); // not implemented + + ClassDef(AliPerformanceMatch,1); +}; + +#endif diff --git a/PWG1/TPC/AliPerformanceObject.cxx b/PWG1/TPC/AliPerformanceObject.cxx new file mode 100644 index 00000000000..8c416ba93a7 --- /dev/null +++ b/PWG1/TPC/AliPerformanceObject.cxx @@ -0,0 +1,146 @@ +/************************************************************************** +* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +//------------------------------------------------------------------------------ +// Implementation of abstract AliPerformanceObject class. It keeps information from +// comparison of reconstructed and MC particle tracks. +// +// Author: J.Otwinowski 14/04/2008 +//------------------------------------------------------------------------------ + +#include + +#include "TCanvas.h" +#include "TH1.h" +#include "TH2.h" +#include "TAxis.h" +#include "TPostScript.h" +#include "TList.h" +#include "TMath.h" + +#include "AliLog.h" +#include "AliPerformanceObject.h" + +using namespace std; + +ClassImp(AliPerformanceObject) + +//_____________________________________________________________________________ +AliPerformanceObject::AliPerformanceObject(): + TNamed("AliPerformanceObject","AliPerformanceObject"), + fAnalysisMode(-1), + fHptGenerator(kFALSE) +{ + // constructor +} + +//_____________________________________________________________________________ +AliPerformanceObject::AliPerformanceObject(const char* name, const char* title): + TNamed(name,title), + fAnalysisMode(-1), + fHptGenerator(kFALSE) +{ + // constructor +} + +//_____________________________________________________________________________ +AliPerformanceObject::~AliPerformanceObject(){ + // destructor +} + +//_____________________________________________________________________________ +void AliPerformanceObject::PrintHisto(Bool_t logz, Char_t * outFileName) { + // draw all histograms from the folder + // and store them in the output *.ps file + + // use this folder + TFolder *folder = this->GetAnalysisFolder(); + if (!folder) { + AliDebug(AliLog::kError, "folder not available"); + return; + } + + TCanvas *can = new TCanvas("can"); + can->Divide(2,2); + + char fname[256]; + const char* suffix=".ps"; + + if(outFileName) sprintf(fname,"%s",outFileName); + else sprintf(fname,"%s%s",folder->GetName(),suffix); + + TPostScript *ps = new TPostScript(fname,112); + Printf("Histograms are stored in %s", fname); + TIter iter(folder->GetListOfFolders()); + + TH1 *obj = 0; + Int_t count = 0; + Int_t pad_count = 0; + while ((obj = (TH1*)iter()) !=0) { + + // 4 figures per page + if((count%4) == 0) { + pad_count = 0; + ps->NewPage(); + } + + pad_count++; + can->cd(pad_count); + + if(obj->TestBit(TH1::kLogX)) + gPad->SetLogx(1); + else + gPad->SetLogx(0); + + if (obj->GetYaxis() && obj->GetZaxis()) { + if(logz) gPad->SetLogz(); + obj->Draw("colz"); + } + else { + obj->SetMarkerStyle(24); + obj->SetMarkerSize(1.0); + obj->Draw(); + } + + if ((pad_count%4) == 0) { + can->Update(); + } + + //printf("count %d \n",count); + count++; + } + ps->Close(); +} + + +//_____________________________________________________________________________ +Double_t * AliPerformanceObject::CreateLogAxis(Int_t nbins, Double_t xmin, Double_t xmax) { + // retun pointer to the array with log axis + // it is user responsibility to delete the array + + Double_t logxmin = TMath::Log10(xmin); + Double_t logxmax = TMath::Log10(xmax); + Double_t binwidth = (logxmax-logxmin)/nbins; + + Double_t *xbins = new Double_t[nbins+1]; + + xbins[0] = xmin; + for (Int_t i=1;i<=nbins;i++) { + xbins[i] = xmin + TMath::Power(10,logxmin+i*binwidth); + } + +return xbins; +} + diff --git a/PWG1/TPC/AliPerformanceObject.h b/PWG1/TPC/AliPerformanceObject.h new file mode 100644 index 00000000000..776613ee6f1 --- /dev/null +++ b/PWG1/TPC/AliPerformanceObject.h @@ -0,0 +1,72 @@ +#ifndef ALIPERFORMANCEOBJECT_H +#define ALIPERFORMANCEOBJECT_H + +//------------------------------------------------------------------------------ +// Base class to keep information from comparison of +// reconstructed and MC particle tracks. +// +// Author: J.Otwinowski 04/14/2008 +//------------------------------------------------------------------------------ + +#include "TNamed.h" +#include "TFolder.h" + +class AliMCEvent; +class AliESDEvent; +class AliRecInfoCuts; +class AliMCInfoCuts; +class AliESDfriend; + +class AliPerformanceObject : public TNamed { +public : + AliPerformanceObject(); + AliPerformanceObject(const char* name="AliPerformanceObject", const char* title="AliPerformanceObject"); + virtual ~AliPerformanceObject(); + + // Init data members + // call once before event loop + virtual void Init() = 0; + + // Execute analysis + // call in the event loop + virtual void Exec(AliMCEvent* const infoMC=0, AliESDEvent* const infoRC=0, AliESDfriend* const infoFriend=0, const Bool_t bUseMC=kFALSE, const Bool_t bUseESDfriend=kFALSE) = 0; + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list=0) = 0; + + // Analyse output histograms + virtual void Analyse() = 0; + + // Get output folder for analysed histograms + virtual TFolder* GetAnalysisFolder() const = 0; + + // + virtual void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) = 0; + virtual void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) = 0; + + // set and get analysisMode + void SetAnalysisMode(const Int_t analysisMode=0) {fAnalysisMode = analysisMode;} + Int_t GetAnalysisMode() const {return fAnalysisMode;} + + // set and get hpt generator + void SetHptGenerator(const Bool_t hptGenerator=kFALSE) {fHptGenerator = hptGenerator;} + Bool_t IsHptGenerator() const {return fHptGenerator;} + + // draw all histograms from the folder + void PrintHisto(Bool_t logz = kTRUE, Char_t * outFileName = "PerformanceQAHisto.ps"); + + // create log axis + Double_t *CreateLogAxis(Int_t nbins, Double_t xmin, Double_t xmax); + +protected: + + // analysis mode + Int_t fAnalysisMode; // 0-TPC, 1-TPCITS, 2-Constrained, 3-TPC inner wall, 4-TPC outer wall + + // hpt generator + Bool_t fHptGenerator; // hpt event generator + + ClassDef(AliPerformanceObject,1); +}; + +#endif diff --git a/PWG1/TPC/AliPerformanceRes.cxx b/PWG1/TPC/AliPerformanceRes.cxx new file mode 100644 index 00000000000..14148a9c988 --- /dev/null +++ b/PWG1/TPC/AliPerformanceRes.cxx @@ -0,0 +1,1009 @@ +//------------------------------------------------------------------------------ +// Implementation of AliPerformanceRes class. It keeps information from +// comparison of reconstructed and MC particle tracks. In addtion, +// it keeps selection cuts used during comparison. The comparison +// information is stored in the ROOT histograms. Analysis of these +// histograms can be done by using Analyse() class function. The result of +// the analysis (histograms/graphs) are stored in the folder which is +// a data member of AliPerformanceRes. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + + TFile f("Output.root"); + AliPerformanceRes * compObj = (AliPerformanceRes*)coutput->FindObject("AliPerformanceRes"); + + // analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderRes" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_Res.root","recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include "TCanvas.h" +#include "TH1.h" +#include "TH2.h" +#include "TAxis.h" +#include "TF1.h" + +#include "AliPerformanceRes.h" +#include "AliESDEvent.h" +#include "AliESDVertex.h" +#include "AliESDtrack.h" +#include "AliESDfriendTrack.h" +#include "AliESDfriend.h" +#include "AliLog.h" +#include "AliMCEvent.h" +#include "AliMCParticle.h" +#include "AliHeader.h" +#include "AliGenEventHeader.h" +#include "AliStack.h" +#include "AliMCInfoCuts.h" +#include "AliRecInfoCuts.h" +#include "AliTracker.h" +#include "AliTreeDraw.h" + +using namespace std; + +ClassImp(AliPerformanceRes) + +//_____________________________________________________________________________ +AliPerformanceRes::AliPerformanceRes(): + AliPerformanceObject("AliPerformanceRes"), + fResolHisto(0), + fPullHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceRes::AliPerformanceRes(Char_t* name="AliPerformanceRes", Char_t* title="AliPerformanceRes",Int_t analysisMode=0,Bool_t hptGenerator=kFALSE): + AliPerformanceObject(name,title), + fResolHisto(0), + fPullHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + // + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceRes::~AliPerformanceRes() +{ + // destructor + + if(fResolHisto) delete fResolHisto; fResolHisto=0; + if(fPullHisto) delete fPullHisto; fPullHisto=0; + + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; +} + +//_____________________________________________________________________________ +void AliPerformanceRes::Init(){ + + // + // histogram bining + // + + // set pt bins + Int_t nPtBins = 50; + Double_t ptMin = 1.e-2, ptMax = 10.; + + Double_t *binsPt = 0; + if (IsHptGenerator()) { + nPtBins = 100; ptMax = 100.; + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } else { + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } + + Double_t yMin = -0.02, yMax = 0.02; + Double_t zMin = -12.0, zMax = 12.0; + if(GetAnalysisMode() == 3) { // TrackRef coordinate system + yMin = -100.; yMax = 100.; + zMin = -100.; zMax = 100.; + } + + // res_y:res_z:res_phi,res_lambda:res_pt:y:z:eta:phi:pt + Int_t binsResolHisto[10]={100,100,100,100,100,25,50,90,30,nPtBins}; + Double_t minResolHisto[10]={-1.,-1.,-0.03,-0.03,-0.2, yMin, zMin, 0., -1.5, ptMin}; + Double_t maxResolHisto[10]={ 1., 1., 0.03, 0.03, 0.2, yMax, zMax, 2.*TMath::Pi(), 1.5, ptMax}; + + fResolHisto = new THnSparseF("fResolHisto","res_y:res_z:res_phi:res_lambda:res_pt:y:z:phi:eta:pt",10,binsResolHisto,minResolHisto,maxResolHisto); + fResolHisto->SetBinEdges(9,binsPt); + + fResolHisto->GetAxis(0)->SetTitle("y-y_{mc} (cm)"); + fResolHisto->GetAxis(1)->SetTitle("z-z_{mc} (cm)"); + fResolHisto->GetAxis(2)->SetTitle("#phi-#phi_{mc} (rad)"); + fResolHisto->GetAxis(3)->SetTitle("#lambda-#lambda_{mc} (rad)"); + fResolHisto->GetAxis(4)->SetTitle("(p_{T}/p_{Tmc}-1)"); + fResolHisto->GetAxis(5)->SetTitle("y_{mc} (cm)"); + fResolHisto->GetAxis(6)->SetTitle("z_{mc} (cm)"); + fResolHisto->GetAxis(7)->SetTitle("#phi_{mc} (rad)"); + fResolHisto->GetAxis(8)->SetTitle("#eta_{mc}"); + fResolHisto->GetAxis(9)->SetTitle("p_{Tmc} (GeV/c)"); + fResolHisto->Sumw2(); + + ////pull_y:pull_z:pull_phi:pull_lambda:pull_1pt:y:z:eta:phi:pt + //Int_t binsPullHisto[10]={100,100,100,100,100,50,50,30,90,nPtBins}; + //Double_t minPullHisto[10]={-5.,-5.,-5.,-5.,-5.,yMin, zMin,-1.5, 0., ptMin}; + //Double_t maxPullHisto[10]={ 5., 5., 5., 5., 5., yMax, zMax, 1.5, 2.*TMath::Pi(),ptMax}; + //fPullHisto = new THnSparseF("fPullHisto","pull_y:pull_z:pull_phi:pull_lambda:pull_1pt:y:z:eta:phi:pt",10,binsPullHisto,minPullHisto,maxPullHisto); + + //pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt + Int_t binsPullHisto[10]={100,100,100,100,100,50,50,50,50,nPtBins}; + Double_t minPullHisto[10]={-5.,-5.,-5.,-5.,-5.,yMin, zMin,-1., -2.0, ptMin}; + Double_t maxPullHisto[10]={ 5., 5., 5., 5., 5., yMax, zMax, 1., 2.0, ptMax}; + fPullHisto = new THnSparseF("fPullHisto","pull_y:pull_z:pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt",10,binsPullHisto,minPullHisto,maxPullHisto); + + /* + if(!IsHptGenerator()) fPullHisto->SetBinEdges(9,bins1Pt); + fPullHisto->GetAxis(0)->SetTitle("(y-y_{mc})/#sigma"); + fPullHisto->GetAxis(1)->SetTitle("(z-z_{mc})/#sigma"); + fPullHisto->GetAxis(2)->SetTitle("(#phi-#phi_{mc})/#sigma"); + fPullHisto->GetAxis(3)->SetTitle("(#lambda-#lambda_{mc})/#sigma"); + fPullHisto->GetAxis(4)->SetTitle("(p_{Tmc}/p_{T}-1)/#sigma"); + fPullHisto->GetAxis(5)->SetTitle("y_{mc} (cm)"); + fPullHisto->GetAxis(6)->SetTitle("z_{mc} (cm)"); + fPullHisto->GetAxis(7)->SetTitle("#eta_{mc}"); + fPullHisto->GetAxis(8)->SetTitle("#phi_{mc} (rad)"); + fPullHisto->GetAxis(9)->SetTitle("p_{Tmc} (GeV/c)"); + fPullHisto->Sumw2(); + */ + + fPullHisto->GetAxis(0)->SetTitle("(y-y_{mc})/#sigma"); + fPullHisto->GetAxis(1)->SetTitle("(z-z_{mc})/#sigma"); + fPullHisto->GetAxis(2)->SetTitle("(sin#phi-sin#phi_{mc})/#sigma"); + fPullHisto->GetAxis(3)->SetTitle("(tan#lambda-tan#lambda_{mc})/#sigma"); + fPullHisto->GetAxis(4)->SetTitle("(p_{Tmc}/p_{T}-1)/#sigma"); + fPullHisto->GetAxis(5)->SetTitle("y_{mc} (cm)"); + fPullHisto->GetAxis(6)->SetTitle("z_{mc} (cm)"); + fPullHisto->GetAxis(7)->SetTitle("sin#phi_{mc}"); + fPullHisto->GetAxis(8)->SetTitle("tan#lambda_{mc}"); + fPullHisto->GetAxis(9)->SetTitle("1/p_{Tmc} (GeV/c)^{-1}"); + fPullHisto->Sumw2(); + + // Init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderRes","Analysis Resolution Folder"); +} + +//_____________________________________________________________________________ +void AliPerformanceRes::ProcessTPC(AliStack* const stack, AliESDtrack *const esdTrack) +{ + if(!esdTrack) return; + + // Fill TPC only resolution comparison information + const AliExternalTrackParam *track = esdTrack->GetTPCInnerParam(); + if(!track) return; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParametersTPC(dca,cov); + + // + // Fill rec vs MC information + // + if(!stack) return; + Int_t label = TMath::Abs(esdTrack->GetLabel()); + TParticle* particle = stack->Particle(label); + if(!particle) return; + if(!particle->GetPDG()) return; + if(particle->GetPDG()->Charge()==0) return; + //printf("charge %d \n",particle->GetPDG()->Charge()); + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) return; + + // exclude electrons + if (fCutsMC->GetEM()==TMath::Abs(particle->GetPdgCode())) return; + + Float_t deltaPtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC, pullYTPC, pullZTPC, pullPhiTPC, pullLambdaTPC; + + Float_t mceta = particle->Eta(); + Float_t mcphi = particle->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = particle->Pt(); + Float_t mcsnp = TMath::Sin(TMath::ATan2(particle->Py(),particle->Px())); + Float_t mctgl = TMath::Tan(TMath::ATan2(particle->Pz(),particle->Pt())); + + // nb. TPC clusters cut + if (esdTrack->GetTPCNcls()GetMinNClustersTPC()) return; + + // select primaries + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + if(mcpt == 0) return; + + deltaYTPC= track->GetY()-particle->Vy(); + deltaZTPC = track->GetZ()-particle->Vz(); + deltaLambdaTPC = TMath::ATan2(track->Pz(),track->Pt())-TMath::ATan2(particle->Pz(),particle->Pt()); + deltaPhiTPC = TMath::ATan2(track->Py(),track->Px())-TMath::ATan2(particle->Py(),particle->Px()); + //delta1PtTPC = (track->OneOverPt()-1./mcpt)*mcpt; + deltaPtTPC = (track->Pt()-mcpt) / mcpt; + + pullYTPC= (track->GetY()-particle->Vy()) / TMath::Sqrt(track->GetSigmaY2()); + pullZTPC = (track->GetZ()-particle->Vz()) / TMath::Sqrt(track->GetSigmaZ2()); + + //Double_t sigma_lambda = 1./(1.+track->GetTgl()*track->GetTgl()) * TMath::Sqrt(track->GetSigmaTgl2()); + //Double_t sigma_phi = 1./TMath::Sqrt(1-track->GetSnp()*track->GetSnp()) * TMath::Sqrt(track->GetSigmaSnp2()); + pullPhiTPC = (track->GetSnp() - mcsnp) / TMath::Sqrt(track->GetSigmaSnp2()); + pullLambdaTPC = (track->GetTgl() - mctgl) / TMath::Sqrt(track->GetSigmaTgl2()); + + //pullLambdaTPC = deltaLambdaTPC / TMath::Sqrt(track->GetSigmaTgl2()); + //pullPhiTPC = deltaPhiTPC / TMath::Sqrt(track->GetSigmaSnp2()); + if (mcpt) pull1PtTPC = (track->OneOverPt()-1./mcpt) / TMath::Sqrt(track->GetSigma1Pt2()); + else pull1PtTPC = 0.; + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,deltaPtTPC,particle->Vy(),particle->Vz(),mcphi,mceta,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,particle->Vy(),particle->Vz(),mcsnp,mctgl,1./mcpt}; + fPullHisto->Fill(vPullHisto); + } +} + +//_____________________________________________________________________________ +void AliPerformanceRes::ProcessTPCITS(AliStack* const stack, AliESDtrack *const esdTrack) +{ + // Fill resolution comparison information (TPC+ITS) + if(!esdTrack) return; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParameters(dca,cov); + + // + // Fill rec vs MC information + // + if(!stack) return; + + Int_t label = TMath::Abs(esdTrack->GetLabel()); + TParticle* particle = stack->Particle(label); + if(!particle) return; + if(particle->GetPDG()->Charge()==0) return; + //printf("charge %d \n",particle->GetPDG()->Charge()); + + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) return; + + // exclude electrons + if (fCutsMC->GetEM()==TMath::Abs(particle->GetPdgCode())) return; + + Float_t mceta = particle->Eta(); + Float_t mcphi = particle->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = particle->Pt(); + Float_t mcsnp = TMath::Sin(TMath::ATan2(particle->Py(),particle->Px())); + Float_t mctgl = TMath::Tan(TMath::ATan2(particle->Pz(),particle->Pt())); + + if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return; // TPC refit + if (esdTrack->GetTPCNcls()GetMinNClustersTPC()) return; // min. nb. TPC clusters + Int_t clusterITS[200]; + if(esdTrack->GetITSclusters(clusterITS)GetMinNClustersITS()) return; // min. nb. ITS clusters + + Float_t deltaPtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC, pullYTPC, pullZTPC, pullPhiTPC, pullLambdaTPC; + + // select primaries + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + if(mcpt == 0) return; + + deltaYTPC= esdTrack->GetY()-particle->Vy(); + deltaZTPC = esdTrack->GetZ()-particle->Vz(); + deltaLambdaTPC = TMath::ATan2(esdTrack->Pz(),esdTrack->Pt())-TMath::ATan2(particle->Pz(),particle->Pt()); + deltaPhiTPC = TMath::ATan2(esdTrack->Py(),esdTrack->Px())-TMath::ATan2(particle->Py(),particle->Px()); + //delta1PtTPC = (esdTrack->OneOverPt()-1./mcpt)*mcpt; + deltaPtTPC = (esdTrack->Pt()-mcpt) / mcpt; + + pullYTPC= (esdTrack->GetY()-particle->Vy()) / TMath::Sqrt(esdTrack->GetSigmaY2()); + pullZTPC = (esdTrack->GetZ()-particle->Vz()) / TMath::Sqrt(esdTrack->GetSigmaZ2()); + + //Double_t sigma_lambda = 1./(1.+esdTrack->GetTgl()*esdTrack->GetTgl()) * TMath::Sqrt(esdTrack->GetSigmaTgl2()); + //Double_t sigma_phi = 1./TMath::Sqrt(1-esdTrack->GetSnp()*esdTrack->GetSnp()) * TMath::Sqrt(esdTrack->GetSigmaSnp2()); + pullPhiTPC = (esdTrack->GetSnp() - mcsnp) / TMath::Sqrt(esdTrack->GetSigmaSnp2()); + pullLambdaTPC = (esdTrack->GetTgl() - mctgl) / TMath::Sqrt(esdTrack->GetSigmaTgl2()); + + //pullLambdaTPC = deltaLambdaTPC / TMath::Sqrt(esdTrack->GetSigmaTgl2()); + //pullPhiTPC = deltaPhiTPC / TMath::Sqrt(esdTrack->GetSigmaSnp2()); + if (mcpt) pull1PtTPC = (esdTrack->OneOverPt()-1./mcpt) / TMath::Sqrt(esdTrack->GetSigma1Pt2()); + else pull1PtTPC = 0.; + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,deltaPtTPC,particle->Vy(),particle->Vz(),mcphi,mceta,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,particle->Vy(),particle->Vz(),mcsnp,mctgl,1./mcpt}; + fPullHisto->Fill(vPullHisto); + + + /* + deltaYTPC= esdTrack->GetY()-particle->Vy(); + deltaZTPC = esdTrack->GetZ()-particle->Vz(); + deltaLambdaTPC = TMath::ATan2(esdTrack->Pz(),esdTrack->Pt())-TMath::ATan2(particle->Pz(),particle->Pt()); + deltaPhiTPC = TMath::ATan2(esdTrack->Py(),esdTrack->Px())-TMath::ATan2(particle->Py(),particle->Px()); + delta1PtTPC = (esdTrack->OneOverPt()-1./mcpt)*mcpt; + + pullYTPC= (esdTrack->GetY()-particle->Vy()) / TMath::Sqrt(esdTrack->GetSigmaY2()); + pullZTPC = (esdTrack->GetZ()-particle->Vz()) / TMath::Sqrt(esdTrack->GetSigmaZ2()); + + Double_t sigma_lambda = 1./(1.+esdTrack->GetTgl()*esdTrack->GetTgl()) * TMath::Sqrt(esdTrack->GetSigmaTgl2()); + Double_t sigma_phi = 1./TMath::Sqrt(1-esdTrack->GetSnp()*esdTrack->GetSnp()) * TMath::Sqrt(esdTrack->GetSigmaSnp2()); + pullLambdaTPC = deltaLambdaTPC / sigma_lambda; + pullPhiTPC = deltaPhiTPC / sigma_phi; + + //pullLambdaTPC = deltaLambdaTPC / TMath::Sqrt(esdTrack->GetSigmaTgl2()); + //pullPhiTPC = deltaPhiTPC / TMath::Sqrt(esdTrack->GetSigmaSnp2()); + if (mcpt) pull1PtTPC = (esdTrack->OneOverPt()-1./mcpt) / TMath::Sqrt(esdTrack->GetSigma1Pt2()); + else pull1PtTPC = 0.; + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,delta1PtTPC,particle->Vy(),particle->Vz(),mceta,mcphi,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,particle->Vy(),particle->Vz(),mceta,mcphi,mcpt}; + fPullHisto->Fill(vPullHisto); + */ + } +} + +//_____________________________________________________________________________ +void AliPerformanceRes::ProcessConstrained(AliStack* const stack, AliESDtrack *const esdTrack) +{ + // Fill resolution comparison information (constarained parameters) + // + if(!esdTrack) return; + + const AliExternalTrackParam * track = esdTrack->GetConstrainedParam(); + if(!track) return; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParameters(dca,cov); + + // + // Fill rec vs MC information + // + if(!stack) return; + + Int_t label = TMath::Abs(esdTrack->GetLabel()); + TParticle* particle = stack->Particle(label); + if(!particle) return; + if(particle->GetPDG()->Charge()==0) return; + //printf("charge %d \n",particle->GetPDG()->Charge()); + + // Only 5 charged particle species (e,mu,pi,K,p) + if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) return; + + // exclude electrons + if (fCutsMC->GetEM()==TMath::Abs(particle->GetPdgCode())) return; + + Float_t mceta = particle->Eta(); + Float_t mcphi = particle->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = particle->Pt(); + Float_t mcsnp = TMath::Sin(TMath::ATan2(particle->Py(),particle->Px())); + Float_t mctgl = TMath::Tan(TMath::ATan2(particle->Pz(),particle->Pt())); + + if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return; // TPC refit + if (esdTrack->GetTPCNcls()GetMinNClustersTPC()) return; // min. nb. TPC clusters + + Float_t deltaPtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC, pullYTPC, pullZTPC, pullPhiTPC, pullLambdaTPC; + + // select primaries + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + + if(mcpt == 0) return; + + deltaYTPC= track->GetY()-particle->Vy(); + deltaZTPC = track->GetZ()-particle->Vz(); + deltaLambdaTPC = TMath::ATan2(track->Pz(),track->Pt())-TMath::ATan2(particle->Pz(),particle->Pt()); + deltaPhiTPC = TMath::ATan2(track->Py(),track->Px())-TMath::ATan2(particle->Py(),particle->Px()); + //delta1PtTPC = (track->OneOverPt()-1./mcpt)*mcpt; + deltaPtTPC = (track->Pt()-mcpt) / mcpt; + + pullYTPC= (track->GetY()-particle->Vy()) / TMath::Sqrt(track->GetSigmaY2()); + pullZTPC = (track->GetZ()-particle->Vz()) / TMath::Sqrt(track->GetSigmaZ2()); + + //Double_t sigma_lambda = 1./(1.+track->GetTgl()*track->GetTgl()) * TMath::Sqrt(track->GetSigmaTgl2()); + //Double_t sigma_phi = 1./TMath::Sqrt(1-track->GetSnp()*track->GetSnp()) * TMath::Sqrt(track->GetSigmaSnp2()); + pullPhiTPC = (track->GetSnp() - mcsnp) / TMath::Sqrt(track->GetSigmaSnp2()); + pullLambdaTPC = (track->GetTgl() - mctgl) / TMath::Sqrt(track->GetSigmaTgl2()); + + //pullLambdaTPC = deltaLambdaTPC / TMath::Sqrt(track->GetSigmaTgl2()); + //pullPhiTPC = deltaPhiTPC / TMath::Sqrt(track->GetSigmaSnp2()); + if (mcpt) pull1PtTPC = (track->OneOverPt()-1./mcpt) / TMath::Sqrt(track->GetSigma1Pt2()); + else pull1PtTPC = 0.; + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,deltaPtTPC,particle->Vy(),particle->Vz(),mcphi,mceta,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,particle->Vy(),particle->Vz(),mcsnp,mctgl,1./mcpt}; + fPullHisto->Fill(vPullHisto); + + /* + + deltaYTPC= track->GetY()-particle->Vy(); + deltaZTPC = track->GetZ()-particle->Vz(); + deltaLambdaTPC = TMath::ATan2(track->Pz(),track->Pt())-TMath::ATan2(particle->Pz(),particle->Pt()); + deltaPhiTPC = TMath::ATan2(track->Py(),track->Px())-TMath::ATan2(particle->Py(),particle->Px()); + delta1PtTPC = (track->OneOverPt()-1./mcpt)*mcpt; + + pullYTPC= (track->GetY()-particle->Vy()) / TMath::Sqrt(track->GetSigmaY2()); + pullZTPC = (track->GetZ()-particle->Vz()) / TMath::Sqrt(track->GetSigmaZ2()); + + Double_t sigma_lambda = 1./(1.+track->GetTgl()*track->GetTgl()) * TMath::Sqrt(track->GetSigmaTgl2()); + Double_t sigma_phi = 1./TMath::Sqrt(1-track->GetSnp()*track->GetSnp()) * TMath::Sqrt(track->GetSigmaSnp2()); + pullLambdaTPC = deltaLambdaTPC / sigma_lambda; + pullPhiTPC = deltaPhiTPC / sigma_phi; + + //pullLambdaTPC = deltaLambdaTPC / TMath::Sqrt(track->GetSigmaTgl2()); + //pullPhiTPC = deltaPhiTPC / TMath::Sqrt(track->GetSigmaSnp2()); + + if (mcpt) pull1PtTPC = (track->OneOverPt()-1./mcpt) / TMath::Sqrt(track->GetSigma1Pt2()); + else pull1PtTPC = 0.; + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,delta1PtTPC,particle->Vy(),particle->Vz(),mceta,mcphi,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,particle->Vy(),particle->Vz(),mceta,mcphi,mcpt}; + fPullHisto->Fill(vPullHisto); + + */ + } +} + +//_____________________________________________________________________________ +void AliPerformanceRes::ProcessInnerTPC(AliMCEvent *const mcEvent, AliESDtrack *const esdTrack) +{ + // + // Fill resolution comparison information (inner params at TPC reference point) + // + if(!esdTrack) return; + + const AliExternalTrackParam * innerParam = esdTrack->GetInnerParam(); + if(!innerParam) return; + + // create new AliExternalTrackParam + AliExternalTrackParam *track = new AliExternalTrackParam(*innerParam); + if(!track) return; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParametersTPC(dca,cov); + + // + // Fill rec vs MC information + // + if(!mcEvent) return; + + Int_t label = TMath::Abs(esdTrack->GetLabel()); + AliMCParticle *mcParticle = (AliMCParticle*) mcEvent->GetTrack(label); + if(!mcParticle) return; + + // get the first TPC track reference + AliTrackReference *ref0 = GetFirstTPCTrackRef(mcParticle); + if(!ref0) return; + + // Only 5 charged particle species (e,mu,pi,K,p) + TParticle *particle = mcParticle->Particle(); + if(!particle) return; + + if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) return; + + // exclude electrons + if (fCutsMC->GetEM()==TMath::Abs(particle->GetPdgCode())) return; + + // calculate alpha angle + Double_t xyz[3] = {ref0->X(),ref0->Y(),ref0->Z()}; + Double_t alpha = TMath::ATan2(xyz[1],xyz[0]); + //if (alpha<0) alpha += TMath::TwoPi(); + + // rotate inner track to local coordinate system + // and propagate to the radius of the first track referenco of TPC + Double_t trRadius = TMath::Sqrt(xyz[1] * xyz[1] + xyz[0] * xyz[0]); + //Bool_t isOK = track->Propagate(alpha,trRadius,AliTracker::GetBz()); + Double_t field[3]; track->GetBxByBz(field); + Bool_t isOK = track->PropagateBxByBz(alpha,trRadius,field); + if(!isOK) return; + + Float_t mceta = -TMath::Log(TMath::Tan(0.5 * ref0->Theta())); + Float_t mcphi = ref0->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = ref0->Pt(); + Float_t mcsnp = TMath::Sin(TMath::ATan2(ref0->Py(),ref0->Px())); + Float_t mctgl = TMath::Tan(TMath::ATan2(ref0->Pz(),ref0->Pt())); + + if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return; // TPC refit + if (esdTrack->GetTPCNcls()GetMinNClustersTPC()) return; // min. nb. TPC clusters + + Float_t deltaPtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC, pullYTPC, pullZTPC, pullPhiTPC, pullLambdaTPC; + + // select primaries + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + if(mcpt == 0) return; + + deltaYTPC= track->GetY(); // already rotated + deltaZTPC = track->GetZ()-ref0->Z(); + deltaLambdaTPC = TMath::ATan2(track->Pz(),track->Pt())-TMath::ATan2(ref0->Pz(),ref0->Pt()); + deltaPhiTPC = TMath::ATan2(track->Py(),track->Px())-TMath::ATan2(ref0->Py(),ref0->Px()); + //delta1PtTPC = (track->OneOverPt()-1./mcpt)*mcpt; + deltaPtTPC = (track->Pt()-mcpt) / mcpt; + + pullYTPC= track->GetY() / TMath::Sqrt(track->GetSigmaY2()); + pullZTPC = (track->GetZ()-ref0->Z()) / TMath::Sqrt(track->GetSigmaZ2()); + + //Double_t sigma_lambda = 1./(1.+track->GetTgl()*track->GetTgl()) * TMath::Sqrt(track->GetSigmaTgl2()); + //Double_t sigma_phi = 1./TMath::Sqrt(1-track->GetSnp()*track->GetSnp()) * TMath::Sqrt(track->GetSigmaSnp2()); + pullPhiTPC = (track->GetSnp() - mcsnp) / TMath::Sqrt(track->GetSigmaSnp2()); + pullLambdaTPC = (track->GetTgl() - mctgl) / TMath::Sqrt(track->GetSigmaTgl2()); + + //pullLambdaTPC = deltaLambdaTPC / TMath::Sqrt(track->GetSigmaTgl2()); + //pullPhiTPC = deltaPhiTPC / TMath::Sqrt(track->GetSigmaSnp2()); + if (mcpt) pull1PtTPC = (track->OneOverPt()-1./mcpt) / TMath::Sqrt(track->GetSigma1Pt2()); + else pull1PtTPC = 0.; + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,deltaPtTPC,ref0->Y(),ref0->Z(),mcphi,mceta,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,ref0->Y(),ref0->Z(),mcsnp,mctgl,1./mcpt}; + fPullHisto->Fill(vPullHisto); + } + + if(track) delete track; +} + +//_____________________________________________________________________________ +void AliPerformanceRes::ProcessOuterTPC(AliMCEvent *const mcEvent, AliESDtrack *const esdTrack, AliESDfriendTrack *const friendTrack) +{ + // + // Fill resolution comparison information (outer params at TPC reference point) + // + if(!friendTrack) return; + + const AliExternalTrackParam * outerParam = friendTrack->GetTPCOut(); + if(!outerParam) return; + + // create new AliExternalTrackParam + AliExternalTrackParam *track = new AliExternalTrackParam(*outerParam); + if(!track) return; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParametersTPC(dca,cov); + + // + // Fill rec vs MC information + // + if(!mcEvent) return; + + Int_t label = TMath::Abs(esdTrack->GetLabel()); + AliMCParticle *mcParticle = (AliMCParticle*) mcEvent->GetTrack(label); + if(!mcParticle) return; + + // get the last TPC track reference + AliTrackReference *ref0 = GetLastTPCTrackRef(mcParticle); + if(!ref0) return; + + // Only 5 charged particle species (e,mu,pi,K,p) + TParticle *particle = mcParticle->Particle(); + if(!particle) return; + + if (fCutsMC->IsPdgParticle(TMath::Abs(particle->GetPdgCode())) == kFALSE) return; + + // exclude electrons + if (fCutsMC->GetEM()==TMath::Abs(particle->GetPdgCode())) return; + + // calculate alpha angle + Double_t xyz[3] = {ref0->X(),ref0->Y(),ref0->Z()}; + Double_t alpha = TMath::ATan2(xyz[1],xyz[0]); + //if (alpha<0) alpha += TMath::TwoPi(); + + // rotate outer track to local coordinate system + // and propagate to the radius of the last track reference of TPC + Double_t trRadius = TMath::Sqrt(xyz[1] * xyz[1] + xyz[0] * xyz[0]); + //Bool_t isOK = track->Propagate(alpha,trRadius,AliTracker::GetBz()); + Double_t field[3]; track->GetBxByBz(field); + Bool_t isOK = track->PropagateBxByBz(alpha,trRadius,field); + if(!isOK) return; + + Float_t mceta = -TMath::Log(TMath::Tan(0.5 * ref0->Theta())); + Float_t mcphi = ref0->Phi(); + if(mcphi<0) mcphi += 2.*TMath::Pi(); + Float_t mcpt = ref0->Pt(); + Float_t mcsnp = TMath::Sin(TMath::ATan2(ref0->Py(),ref0->Px())); + Float_t mctgl = TMath::Tan(TMath::ATan2(ref0->Pz(),ref0->Pt())); + + if ((esdTrack->GetStatus()&AliESDtrack::kTPCrefit)==0) return; // TPC refit + if (esdTrack->GetTPCNcls()GetMinNClustersTPC()) return; // min. nb. TPC clusters + + Float_t deltaPtTPC, deltaYTPC, deltaZTPC, deltaPhiTPC, deltaLambdaTPC; + Float_t pull1PtTPC, pullYTPC, pullZTPC, pullPhiTPC, pullLambdaTPC; + + // select primaries + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) + { + if(mcpt == 0) return; + + deltaYTPC= track->GetY(); // already rotated + deltaZTPC = track->GetZ()-ref0->Z(); + deltaLambdaTPC = TMath::ATan2(track->Pz(),track->Pt())-TMath::ATan2(ref0->Pz(),ref0->Pt()); + deltaPhiTPC = TMath::ATan2(track->Py(),track->Px())-TMath::ATan2(ref0->Py(),ref0->Px()); + //delta1PtTPC = (track->OneOverPt()-1./mcpt)*mcpt; + deltaPtTPC = (track->Pt()-mcpt) / mcpt; + + pullYTPC= track->GetY() / TMath::Sqrt(track->GetSigmaY2()); + pullZTPC = (track->GetZ()-ref0->Z()) / TMath::Sqrt(track->GetSigmaZ2()); + + //Double_t sigma_lambda = 1./(1.+track->GetTgl()*track->GetTgl()) * TMath::Sqrt(track->GetSigmaTgl2()); + //Double_t sigma_phi = 1./TMath::Sqrt(1-track->GetSnp()*track->GetSnp()) * TMath::Sqrt(track->GetSigmaSnp2()); + pullPhiTPC = (track->GetSnp() - mcsnp) / TMath::Sqrt(track->GetSigmaSnp2()); + pullLambdaTPC = (track->GetTgl() - mctgl) / TMath::Sqrt(track->GetSigmaTgl2()); + + //pullLambdaTPC = deltaLambdaTPC / TMath::Sqrt(track->GetSigmaTgl2()); + //pullPhiTPC = deltaPhiTPC / TMath::Sqrt(track->GetSigmaSnp2()); + if (mcpt) pull1PtTPC = (track->OneOverPt()-1./mcpt) / TMath::Sqrt(track->GetSigma1Pt2()); + else pull1PtTPC = 0.; + + Double_t vResolHisto[10] = {deltaYTPC,deltaZTPC,deltaPhiTPC,deltaLambdaTPC,deltaPtTPC,ref0->Y(),ref0->Z(),mcphi,mceta,mcpt}; + fResolHisto->Fill(vResolHisto); + + Double_t vPullHisto[10] = {pullYTPC,pullZTPC,pullPhiTPC,pullLambdaTPC,pull1PtTPC,ref0->Y(),ref0->Z(),mcsnp,mctgl,1./mcpt}; + fPullHisto->Fill(vPullHisto); + } + + if(track) delete track; +} + +//_____________________________________________________________________________ +AliTrackReference * AliPerformanceRes::GetFirstTPCTrackRef(AliMCParticle *mcParticle) +{ + // return first TPC track reference + if(!mcParticle) return 0; + + // find first track reference + // check direction to select proper reference point for looping tracks + Int_t nTrackRef = mcParticle->GetNumberOfTrackReferences(); + AliTrackReference *ref = 0; + AliTrackReference *refIn = 0; + for (Int_t iref = 0; iref < nTrackRef; iref++) { + ref = mcParticle->GetTrackReference(iref); + if(ref && (ref->DetectorId()==AliTrackReference::kTPC)) + { + Float_t dir = ref->X()*ref->Px()+ref->Y()*ref->Py(); + if(dir < 0.) break; + + refIn = ref; + break; + } + } + +return refIn; +} + +//_____________________________________________________________________________ +AliTrackReference * AliPerformanceRes::GetLastTPCTrackRef(AliMCParticle *mcParticle) +{ + // return last TPC track reference + if(!mcParticle) return 0; + + // find last track reference + // check direction to select proper reference point for looping tracks + Int_t nTrackRef = mcParticle->GetNumberOfTrackReferences(); + AliTrackReference *ref = 0; + AliTrackReference *refOut = 0; + for (Int_t iref = 0; iref < nTrackRef; iref++) { + ref = mcParticle->GetTrackReference(iref); + if(ref && (ref->DetectorId()==AliTrackReference::kTPC)) { + Float_t dir=ref->X()*ref->Px()+ref->Y()*ref->Py(); + if(dir< 0.0) break; + refOut = ref; + } + } + +return refOut; +} + +//_____________________________________________________________________________ +void AliPerformanceRes::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend) +{ + // Process comparison information + // + if(!esdEvent) + { + Error("Exec","esdEvent not available"); + return; + } + AliHeader* header = 0; + AliGenEventHeader* genHeader = 0; + AliStack* stack = 0; + TArrayF vtxMC(3); + + if(bUseMC) + { + if(!mcEvent) { + Error("Exec","mcEvent not available"); + return; + } + // get MC event header + header = mcEvent->Header(); + if (!header) { + Error("Exec","Header not available"); + return; + } + // MC particle stack + stack = mcEvent->Stack(); + if (!stack) { + Error("Exec","Stack not available"); + return; + } + // get MC vertex + genHeader = header->GenEventHeader(); + if (!genHeader) { + Error("Exec","Could not retrieve genHeader from Header"); + return; + } + genHeader->PrimaryVertex(vtxMC); + } + else { + Error("Exec","MC information required!"); + return; + } + + // use ESD friends + if(bUseESDfriend) { + if(!esdFriend) { + Error("Exec","esdFriend not available"); + return; + } + } + + // Process events + for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) + { + AliESDtrack *track = esdEvent->GetTrack(iTrack); + if(!track) continue; + + AliESDfriendTrack *friendTrack=0; + if(bUseESDfriend) { + friendTrack=esdFriend->GetTrack(iTrack); + if(!friendTrack) continue; + } + + if(GetAnalysisMode() == 0) ProcessTPC(stack,track); + else if(GetAnalysisMode() == 1) ProcessTPCITS(stack,track); + else if(GetAnalysisMode() == 2) ProcessConstrained(stack,track); + else if(GetAnalysisMode() == 3) ProcessInnerTPC(mcEvent,track); + else if(GetAnalysisMode() == 4) ProcessOuterTPC(mcEvent,track,friendTrack); + else { + printf("ERROR: AnalysisMode %d \n",fAnalysisMode); + return; + } + } +} + +//_____________________________________________________________________________ +TH1F* AliPerformanceRes::MakeResol(TH2F * his, Int_t integ, Bool_t type, Int_t cut){ + // Create resolution histograms + + TH1F *hisr, *hism; + if (!gPad) new TCanvas; + hisr = AliTreeDraw::CreateResHistoII(his,&hism,integ,kTRUE,cut); + if (type) return hism; + else + return hisr; +} + +//_____________________________________________________________________________ +void AliPerformanceRes::Analyse() { + // Analyse comparison information and store output histograms + // in the folder "folderRes" + // + TH1::AddDirectory(kFALSE); + TH1F *h=0; + TH2F *h2D=0; + TObjArray *aFolderObj = new TObjArray; + + // write results in the folder + TCanvas * c = new TCanvas("Phi resol Tan","Phi resol Tan"); + c->cd(); + + char name[256]; + char title[256]; + + for(Int_t i=0; i<5; i++) + { + for(Int_t j=5; j<10; j++) + { + //if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window + if(j!=8) fResolHisto->GetAxis(8)->SetRangeUser(0.0,0.89); // eta window + else fResolHisto->GetAxis(8)->SetRangeUser(-1.5,1.49); + fResolHisto->GetAxis(9)->SetRangeUser(0.16,100.); // pt threshold + if(GetAnalysisMode() == 3) fResolHisto->GetAxis(5)->SetRangeUser(-80.,80.); // y range + + h2D = (TH2F*)fResolHisto->Projection(i,j); + + h = AliPerformanceRes::MakeResol(h2D,1,0,100); + sprintf(name,"h_res_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fResolHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fResolHisto->GetAxis(i)->GetTitle(),"(resolution)"); + h->GetYaxis()->SetTitle(title); + sprintf(title,"%s vs %s",title,fResolHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + + h = AliPerformanceRes::MakeResol(h2D,1,1,100); + //h = (TH1F*)arr->At(1); + sprintf(name,"h_mean_res_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fResolHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fResolHisto->GetAxis(i)->GetTitle(),"(mean)"); + h->GetYaxis()->SetTitle(title); + + sprintf(title,"%s vs %s",title,fResolHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + + fResolHisto->GetAxis(8)->SetRangeUser(-1.5,1.5); + fResolHisto->GetAxis(9)->SetRangeUser(0.0,10.); + + // + //if(j!=8) fPullHisto->GetAxis(8)->SetRangeUser(-0.9,0.89); // eta window + if(j!=8) fPullHisto->GetAxis(8)->SetRangeUser(0.0,0.89); // eta window + else fPullHisto->GetAxis(8)->SetRangeUser(-1.5,1.49); // eta window + fPullHisto->GetAxis(9)->SetRangeUser(0.16,100.); // pt threshold + if(GetAnalysisMode() == 3) fPullHisto->GetAxis(5)->SetRangeUser(-80.,80.); // y range + + h2D = (TH2F*)fPullHisto->Projection(i,j); + + h = AliPerformanceRes::MakeResol(h2D,1,0,100); + sprintf(name,"h_pull_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fPullHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fPullHisto->GetAxis(i)->GetTitle(),"(resolution)"); + h->GetYaxis()->SetTitle(title); + sprintf(title,"%s vs %s",title,fPullHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + //if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + + h = AliPerformanceRes::MakeResol(h2D,1,1,100); + sprintf(name,"h_mean_pull_%d_vs_%d",i,j); + h->SetName(name); + + h->GetXaxis()->SetTitle(fPullHisto->GetAxis(j)->GetTitle()); + sprintf(title,"%s %s",fPullHisto->GetAxis(i)->GetTitle(),"(mean)"); + h->GetYaxis()->SetTitle(title); + sprintf(title,"%s vs %s",title,fPullHisto->GetAxis(j)->GetTitle()); + h->SetTitle(title); + + //if(j==9) h->SetBit(TH1::kLogX); + aFolderObj->Add(h); + } + } + + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceRes::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliPerformanceRes * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + +//_____________________________________________________________________________ +Long64_t AliPerformanceRes::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliPerformanceRes* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fResolHisto->Add(entry->fResolHisto); + fPullHisto->Add(entry->fPullHisto); + + count++; + } + +return count; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceRes::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +// +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} diff --git a/PWG1/TPC/AliPerformanceRes.h b/PWG1/TPC/AliPerformanceRes.h new file mode 100644 index 00000000000..86b501983c2 --- /dev/null +++ b/PWG1/TPC/AliPerformanceRes.h @@ -0,0 +1,109 @@ +#ifndef ALIPERFORMANCERES_H +#define ALIPERFORMANCERES_H + +//------------------------------------------------------------------------------ +// Class to keep information from comparison of +// reconstructed and MC particle tracks (TPC resolution). +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +class TString; +class TNamed; +class TCanvas; +class TH1F; +class TH2F; + +class AliESDVertex; +class AliESDtrack; +class AliMCEvent; +class AliStack; +class AliTrackReference; +class AliESDEvent; +class AliESDfriend; +class AliESDfriendTrack; +class AliMCEvent; +class AliMCParticle; +class AliMCInfoCuts; +class AliRecInfoCuts; + +#include "THnSparse.h" +#include "AliPerformanceObject.h" + +class AliPerformanceRes : public AliPerformanceObject { +public : + AliPerformanceRes(); + AliPerformanceRes(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + virtual ~AliPerformanceRes(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend); + + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Process events + void ProcessConstrained(AliStack* const stack, AliESDtrack *const esdTrack); + void ProcessTPC(AliStack* const stack, AliESDtrack *const esdTrack); + void ProcessTPCITS(AliStack* const stack, AliESDtrack *const esdTrack); + void ProcessInnerTPC(AliMCEvent *const mcEvent, AliESDtrack *const esdTrack); + void ProcessOuterTPC(AliMCEvent *const mcEvent, AliESDtrack *const esdTrack, AliESDfriendTrack *const friendTrack); + + AliTrackReference *GetFirstTPCTrackRef(AliMCParticle *mcParticle); + AliTrackReference *GetLastTPCTrackRef(AliMCParticle *mcParticle); + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderRes",TString title = "Analysed Resolution histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray * array=0); + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + TH1F* MakeResol(TH2F * his, Int_t integ=0, Bool_t type=kFALSE, Int_t cut=0); + + // getters + // + THnSparse *GetResolHisto() const { return fResolHisto; } + THnSparse *GetPullHisto() const { return fPullHisto; } +private: + // + // Control histograms + // 5 track parameters (details in STEER/AliExternalTrackParam.h) + // + + // resolution histogram + THnSparseF *fResolHisto; //-> res_y:res_z:res_phi:res_lambda:res_pt:y:z:phi:eta:pt + + // pull histogram + //THnSparseF *fPullHisto; //-> pull_y:pull_z:pull_phi:pull_lambda:pull_1pt:y:z:eta:phi:pt + THnSparseF *fPullHisto; //-> pull_y:pull_z:pull_snp:pull_tgl:pull_1pt:y:z:snp:tgl:1pt + + // Global cuts objects + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliPerformanceRes(const AliPerformanceRes&); // not implemented + AliPerformanceRes& operator=(const AliPerformanceRes&); // not implemented + + ClassDef(AliPerformanceRes,1); +}; + +#endif diff --git a/PWG1/TPC/AliPerformanceTPC.cxx b/PWG1/TPC/AliPerformanceTPC.cxx new file mode 100644 index 00000000000..a53a7408f1d --- /dev/null +++ b/PWG1/TPC/AliPerformanceTPC.cxx @@ -0,0 +1,386 @@ +//------------------------------------------------------------------------------ +// Implementation of AliPerformanceTPC class. It keeps information from +// comparison of reconstructed and MC particle tracks. In addtion, +// it keeps selection cuts used during comparison. The comparison +// information is stored in the ROOT histograms. Analysis of these +// histograms can be done by using Analyse() class function. The result of +// the analysis (histograms/graphs) are stored in the folder which is +// a data member of AliPerformanceTPC. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +/* + + // after running comparison task, read the file, and get component + gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C"); + LoadMyLibs(); + + TFile f("Output.root"); + AliPerformanceTPC * compObj = (AliPerformanceTPC*)coutput->FindObject("AliPerformanceTPC"); + + // analyse comparison data + compObj->Analyse(); + + // the output histograms/graphs will be stored in the folder "folderTPC" + compObj->GetAnalysisFolder()->ls("*"); + + // user can save whole comparison object (or only folder with anlysed histograms) + // in the seperate output file (e.g.) + TFile fout("Analysed_TPC.root","recreate"); + compObj->Write(); // compObj->GetAnalysisFolder()->Write(); + fout.Close(); + +*/ + +#include "TCanvas.h" +#include "TH1.h" +#include "TH2.h" +#include "TAxis.h" +#include "TPostScript.h" + +#include "AliPerformanceTPC.h" +#include "AliESDEvent.h" +#include "AliESDVertex.h" +#include "AliESDtrack.h" +#include "AliLog.h" +#include "AliMCEvent.h" +#include "AliHeader.h" +#include "AliGenEventHeader.h" +#include "AliStack.h" +#include "AliMCInfoCuts.h" +#include "AliRecInfoCuts.h" +#include "AliTracker.h" +#include "AliTreeDraw.h" + +using namespace std; + +ClassImp(AliPerformanceTPC) + +//_____________________________________________________________________________ +AliPerformanceTPC::AliPerformanceTPC(): + AliPerformanceObject("AliPerformanceTPC"), + fTPCHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceTPC::AliPerformanceTPC(Char_t* name="AliPerformanceTPC", Char_t* title="AliPerformanceTPC",Int_t analysisMode=0,Bool_t hptGenerator=kFALSE): + AliPerformanceObject(name,title), + fTPCHisto(0), + + // Cuts + fCutsRC(0), + fCutsMC(0), + + // histogram folder + fAnalysisFolder(0) +{ + // named constructor + // + SetAnalysisMode(analysisMode); + SetHptGenerator(hptGenerator); + + Init(); +} + +//_____________________________________________________________________________ +AliPerformanceTPC::~AliPerformanceTPC() +{ + // destructor + + if(fTPCHisto) delete fTPCHisto; fTPCHisto=0; + if(fAnalysisFolder) delete fAnalysisFolder; fAnalysisFolder=0; +} + +//_____________________________________________________________________________ +void AliPerformanceTPC::Init(){ + // + // histogram bining + // + + // set pt bins + Int_t nPtBins = 50; + Double_t ptMin = 1.e-2, ptMax = 10.; + + Double_t *binsPt = 0; + if (IsHptGenerator()) { + nPtBins = 100; ptMax = 100.; + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } else { + binsPt = CreateLogAxis(nPtBins,ptMin,ptMax); + } + + /* + Int_t nPtBins = 31; + Double_t binsPt[32] = {0.,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45,0.5,0.55,0.6,0.7,0.8,0.9,1.0,1.2,1.4,1.6,1.8,2.0,2.25,2.5,2.75,3.,3.5,4.,5.,6.,8.,10.}; + Double_t ptMin = 0., ptMax = 10.; + + if(IsHptGenerator() == kTRUE) { + nPtBins = 100; + ptMin = 0.; ptMax = 100.; + } + */ + + // nTPCClust:chi2PerTPCClust:nTPCClustFindRatio:eta:phi:pt + Int_t binsTPCHisto[6]={160,100,100,30,90,nPtBins}; + Double_t minTPCHisto[6]={0., 0., 0., -1.5, 0., ptMin}; + Double_t maxTPCHisto[6]={160.,10.,1.2, 1.5, 2.*TMath::Pi(), ptMax}; + + fTPCHisto = new THnSparseF("fTPCHisto","nClust:chi2PerClust:nClust/nFindableClust:eta:phi:pt",6,binsTPCHisto,minTPCHisto,maxTPCHisto); + fTPCHisto->SetBinEdges(5,binsPt); + + fTPCHisto->GetAxis(0)->SetTitle("nClust"); + fTPCHisto->GetAxis(1)->SetTitle("chi2PerClust"); + fTPCHisto->GetAxis(2)->SetTitle("nClust/nFindableClust"); + fTPCHisto->GetAxis(3)->SetTitle("#eta"); + fTPCHisto->GetAxis(4)->SetTitle("#phi (rad)"); + fTPCHisto->GetAxis(5)->SetTitle("p_{T} (GeV/c)"); + fTPCHisto->Sumw2(); + + // Init cuts + if(!fCutsMC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliMCInfoCuts object"); + if(!fCutsRC) + AliDebug(AliLog::kError, "ERROR: Cannot find AliRecInfoCuts object"); + + // init folder + fAnalysisFolder = CreateFolder("folderTPC","Analysis Resolution Folder"); +} + +//_____________________________________________________________________________ +void AliPerformanceTPC::ProcessTPC(AliStack* const stack, AliESDtrack *const esdTrack) +{ + if(!esdTrack) return; + + // Fill TPC only resolution comparison information + const AliExternalTrackParam *track = esdTrack->GetTPCInnerParam(); + if(!track) return; + + Float_t dca[2], cov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z + esdTrack->GetImpactParametersTPC(dca,cov); + + //Float_t q = esdTrack->Charge(); + Float_t pt = track->Pt(); + Float_t eta = track->Eta(); + Float_t phi = track->Phi(); + Int_t nClust = esdTrack->GetTPCclusters(0); + Int_t nFindableClust = esdTrack->GetTPCNclsF(); + + Float_t chi2PerCluster = 0.; + if(nClust>0.) chi2PerCluster = esdTrack->GetTPCchi2()/Float_t(nClust); + + Float_t clustPerFindClust = 0.; + if(nFindableClust>0.) clustPerFindClust = Float_t(nClust)/nFindableClust; + + if(TMath::Abs(dca[0])GetMaxDCAToVertexXY() && TMath::Abs(dca[1])GetMaxDCAToVertexZ()) { + Double_t vTPCHisto[6] = {nClust,chi2PerCluster,clustPerFindClust,eta,phi,pt}; + fTPCHisto->Fill(vTPCHisto); + } + + // + // Fill rec vs MC information + // + if(!stack) return; + +} + +//_____________________________________________________________________________ +void AliPerformanceTPC::ProcessTPCITS(AliStack* const /*stack*/, AliESDtrack *const /*esdTrack*/) +{ + // Fill comparison information (TPC+ITS) + AliDebug(AliLog::kWarning, "Warning: Not implemented"); +} + +//_____________________________________________________________________________ +void AliPerformanceTPC::ProcessConstrained(AliStack* const /*stack*/, AliESDtrack *const /*esdTrack*/) +{ + // Fill comparison information (constarained parameters) + AliDebug(AliLog::kWarning, "Warning: Not implemented"); +} + +//_____________________________________________________________________________ +void AliPerformanceTPC::Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend) +{ + // Process comparison information + // + if(!esdEvent) + { + Error("Exec","esdEvent not available"); + return; + } + AliHeader* header = 0; + AliGenEventHeader* genHeader = 0; + AliStack* stack = 0; + TArrayF vtxMC(3); + + if(bUseMC) + { + if(!mcEvent) { + Error("Exec","mcEvent not available"); + return; + } + // get MC event header + header = mcEvent->Header(); + if (!header) { + Error("Exec","Header not available"); + return; + } + // MC particle stack + stack = mcEvent->Stack(); + if (!stack) { + Error("Exec","Stack not available"); + return; + } + // get MC vertex + genHeader = header->GenEventHeader(); + if (!genHeader) { + Error("Exec","Could not retrieve genHeader from Header"); + return; + } + genHeader->PrimaryVertex(vtxMC); + } + + // use ESD friends + if(bUseESDfriend) { + if(!esdFriend) { + Error("Exec","esdFriend not available"); + return; + } + } + + // Process events + for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++) + { + AliESDtrack*track = esdEvent->GetTrack(iTrack); + if(!track) continue; + + if(GetAnalysisMode() == 0) ProcessTPC(stack,track); + else if(GetAnalysisMode() == 1) ProcessTPCITS(stack,track); + else if(GetAnalysisMode() == 2) ProcessConstrained(stack,track); + else { + printf("ERROR: AnalysisMode %d \n",fAnalysisMode); + return; + } + } +} + +//_____________________________________________________________________________ +void AliPerformanceTPC::Analyse() { + // + // Analyse comparison information and store output histograms + // in the folder "folderTPC" + // + TH1::AddDirectory(kFALSE); + //TH1F *h=0; + TH2F *h2D=0; + TObjArray *aFolderObj = new TObjArray; + + char name[256]; + char title[256]; + for(Int_t i=0; i<5; i++) + { + for(Int_t j=i+1; j<6; j++) + { + if(j==5) fTPCHisto->GetAxis(5)->SetRangeUser(0.1,10.); + h2D = (TH2F*)fTPCHisto->Projection(i,j); + sprintf(name,"h_tpc_%d_vs_%d",i,j); + h2D->SetName(name); + h2D->GetXaxis()->SetTitle(fTPCHisto->GetAxis(j)->GetTitle()); + h2D->GetYaxis()->SetTitle(fTPCHisto->GetAxis(i)->GetTitle()); + sprintf(title,"%s vs %s",fTPCHisto->GetAxis(j)->GetTitle(),fTPCHisto->GetAxis(i)->GetTitle()); + h2D->SetTitle(title); + + if(j==5) h2D->SetBit(TH1::kLogX); + aFolderObj->Add(h2D); + } + } + + // export objects to analysis folder + fAnalysisFolder = ExportToFolder(aFolderObj); + + // delete only TObjArray + if(aFolderObj) delete aFolderObj; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceTPC::ExportToFolder(TObjArray * array) +{ + // recreate folder avery time and export objects to new one + // + AliPerformanceTPC * comp=this; + TFolder *folder = comp->GetAnalysisFolder(); + + TString name, title; + TFolder *newFolder = 0; + Int_t i = 0; + Int_t size = array->GetSize(); + + if(folder) { + // get name and title from old folder + name = folder->GetName(); + title = folder->GetTitle(); + + // delete old one + delete folder; + + // create new one + newFolder = CreateFolder(name.Data(),title.Data()); + newFolder->SetOwner(); + + // add objects to folder + while(i < size) { + newFolder->Add(array->At(i)); + i++; + } + } + +return newFolder; +} + +//_____________________________________________________________________________ +Long64_t AliPerformanceTPC::Merge(TCollection* const list) +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + // collection of generated histograms + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliPerformanceTPC* entry = dynamic_cast(obj); + if (entry == 0) continue; + + fTPCHisto->Add(entry->fTPCHisto); + + count++; + } + +return count; +} + +//_____________________________________________________________________________ +TFolder* AliPerformanceTPC::CreateFolder(TString name,TString title) { +// create folder for analysed histograms +// +TFolder *folder = 0; + folder = new TFolder(name.Data(),title.Data()); + + return folder; +} diff --git a/PWG1/TPC/AliPerformanceTPC.h b/PWG1/TPC/AliPerformanceTPC.h new file mode 100644 index 00000000000..a2af1284535 --- /dev/null +++ b/PWG1/TPC/AliPerformanceTPC.h @@ -0,0 +1,88 @@ +#ifndef ALIPERFORMANCETPC_H +#define ALIPERFORMANCETPC_H + +//------------------------------------------------------------------------------ +// Class to keep information from comparison of +// reconstructed and MC particle tracks (TPC resolution). +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +class TString; +class TNamed; +class TCanvas; +class TH1F; +class TH2F; + +class AliESDVertex; +class AliESDtrack; +class AliMCEvent; +class AliStack; +class AliESDEvent; +class AliESDfriend; +class AliMCInfoCuts; +class AliRecInfoCuts; + +#include "THnSparse.h" +#include "AliPerformanceObject.h" + +class AliPerformanceTPC : public AliPerformanceObject { +public : + AliPerformanceTPC(); + AliPerformanceTPC(Char_t* name, Char_t* title, Int_t analysisMode, Bool_t hptGenerator); + virtual ~AliPerformanceTPC(); + + // Init data members + virtual void Init(); + + // Execute analysis + virtual void Exec(AliMCEvent* const mcEvent, AliESDEvent *const esdEvent, AliESDfriend *const esdFriend, const Bool_t bUseMC, const Bool_t bUseESDfriend); + // Merge output objects (needed by PROOF) + virtual Long64_t Merge(TCollection* const list); + + // Analyse output histograms + virtual void Analyse(); + + // Get analysis folder + virtual TFolder* GetAnalysisFolder() const {return fAnalysisFolder;} + + // Process events + void ProcessConstrained(AliStack* const stack, AliESDtrack *const esdTrack); + void ProcessTPC(AliStack* const stack, AliESDtrack *const esdTrack); + void ProcessTPCITS(AliStack* const stack, AliESDtrack *const esdTrack); + + // Create folder for analysed histograms + TFolder *CreateFolder(TString folder = "folderTPC",TString title = "Analysed TPC performance histograms"); + + // Export objects to folder + TFolder *ExportToFolder(TObjArray * array=0); + + // Selection cuts + void SetAliRecInfoCuts(AliRecInfoCuts* const cuts=0) {fCutsRC = cuts;} + void SetAliMCInfoCuts(AliMCInfoCuts* const cuts=0) {fCutsMC = cuts;} + + AliRecInfoCuts* GetAliRecInfoCuts() const {return fCutsRC;} + AliMCInfoCuts* GetAliMCInfoCuts() const {return fCutsMC;} + + // getters + // + THnSparse *GetTPCHisto() const { return fTPCHisto; } +private: + + // TPC histogram + THnSparseF *fTPCHisto; //-> nClust:chi2PerClust:nClust/nFindableClust:eta:phi:pt + + // Global cuts objects + AliRecInfoCuts* fCutsRC; // selection cuts for reconstructed tracks + AliMCInfoCuts* fCutsMC; // selection cuts for MC tracks + + // analysis folder + TFolder *fAnalysisFolder; // folder for analysed histograms + + AliPerformanceTPC(const AliPerformanceTPC&); // not implemented + AliPerformanceTPC& operator=(const AliPerformanceTPC&); // not implemented + + ClassDef(AliPerformanceTPC,1); +}; + +#endif diff --git a/PWG1/TPC/AliPerformanceTask.cxx b/PWG1/TPC/AliPerformanceTask.cxx new file mode 100644 index 00000000000..17d6c477331 --- /dev/null +++ b/PWG1/TPC/AliPerformanceTask.cxx @@ -0,0 +1,238 @@ +/************************************************************************** +* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +//------------------------------------------------------------------------------ +// Implementation of the AliPerformanceTask class. It checks reconstruction performance +// for the reconstructed vs MC particle tracks under several conditions. For real data +// the control QA histograms are filled. +// +// The comparison output objects deriving from AliPerformanceObject +// (e.g. AliPerformanceRes, AliPerformanceEff, AliPerformanceDEdx, AliPerformanceDCA ...) +// are stored in the output file (details in description of these classes). +// +// Author: J.Otwinowski 01/04/2009 +//------------------------------------------------------------------------------ + +#include "iostream" + +#include "TChain.h" +#include "TTree.h" +#include "TH1F.h" +#include "TCanvas.h" +#include "TList.h" +#include "TFile.h" + +#include "AliAnalysisTask.h" +#include "AliAnalysisManager.h" +#include "AliESDEvent.h" +#include "AliESDfriend.h" +#include "AliMCEvent.h" +#include "AliESDInputHandler.h" +#include "AliMCEventHandler.h" +#include "AliESDVertex.h" +#include "AliMagF.h" +#include "AliTracker.h" +#include "AliGeomManager.h" + +#include "AliMCInfo.h" +#include "AliESDRecInfo.h" +#include "AliMCInfoCuts.h" +#include "AliRecInfoCuts.h" +#include "AliComparisonObject.h" +#include "AliPerformanceObject.h" +#include "AliPerformanceTask.h" + +using namespace std; + +ClassImp(AliPerformanceTask) + +//_____________________________________________________________________________ +AliPerformanceTask::AliPerformanceTask() + : AliAnalysisTask("Performance","Detector Performance") + , fESD(0) + , fESDfriend(0) + , fMC(0) + , fOutput(0) + , fPitList(0) + , fCompList(0) + , fUseMCInfo(kFALSE) + , fUseESDfriend(kFALSE) +{ + // Dummy Constructor + // should not be used +} + +//_____________________________________________________________________________ +AliPerformanceTask::AliPerformanceTask(const char *name, const char *title) + : AliAnalysisTask(name, title) + , fESD(0) + , fESDfriend(0) + , fMC(0) + , fOutput(0) + , fPitList(0) + , fCompList(0) + , fUseMCInfo(kFALSE) + , fUseESDfriend(kFALSE) +{ + // Constructor + + // Define input and output slots here + DefineInput(0, TChain::Class()); + DefineOutput(0, TList::Class()); + + // create the list for comparison objects + fCompList = new TList; +} + +//_____________________________________________________________________________ +AliPerformanceTask::~AliPerformanceTask() +{ + if(fOutput) delete fOutput; fOutput =0; + if(fCompList) delete fCompList; fCompList =0; +} + +//_____________________________________________________________________________ +void AliPerformanceTask::ConnectInputData(Option_t *) +{ + // Connect input data + // Called once + + TTree *tree = dynamic_cast (GetInputData(0)); + if (!tree) { + Printf("ERROR: Could not read chain from input slot 0"); + return; + } + + AliESDInputHandler *esdH = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if (!esdH) { + Printf("ERROR: Could not get ESDInputHandler"); + } else { + fESD = esdH->GetEvent(); + + if(fUseESDfriend) + { + fESDfriend = static_cast(fESD->FindListObject("AliESDfriend")); + if(!fESDfriend) { + Printf("ERROR: ESD friends not available"); + } + } + } + + // use MC information + if(fUseMCInfo) { + AliMCEventHandler* eventHandler = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); + if (!eventHandler) { + Printf("ERROR: Could not retrieve MC event handler"); + } else { + fMC = eventHandler->MCEvent(); + } + } +} + +//_____________________________________________________________________________ +Bool_t AliPerformanceTask::AddPerformanceObject(AliPerformanceObject *pObj) +{ + // add comparison object to the list + if(pObj == 0) { + Printf("ERROR: Could not add comparison object"); + return kFALSE; + } + + // add object to the list + fCompList->AddLast(pObj); + +return kTRUE; +} + +//_____________________________________________________________________________ +void AliPerformanceTask::CreateOutputObjects() +{ + // Create histograms + // Called once + + // create output list + fOutput = new TList; + fOutput->SetOwner(); + fPitList = fOutput->MakeIterator(); + + // add comparison objects to the output + AliPerformanceObject *pObj=0; + Int_t count=0; + TIterator *pitCompList = fCompList->MakeIterator(); + pitCompList->Reset(); + while(( pObj = (AliPerformanceObject *)pitCompList->Next()) != NULL) { + fOutput->Add(pObj); + count++; + } + Printf("CreateOutputObjects(): Number of output comparison objects: %d \n", count); +} + +//_____________________________________________________________________________ +void AliPerformanceTask::Exec(Option_t *) +{ + // Main loop + // Called for each event + + AliPerformanceObject *pObj=0; + + if (!fESD) { + Printf("ERROR: ESD event not available"); + return; + } + + if (fUseMCInfo && !fMC) { + Printf("ERROR: MC event not available"); + return; + } + + if(fUseESDfriend) + { + if(!fESDfriend) { + Printf("ERROR: ESD friends not available"); + } + } + + // Process comparison + fPitList->Reset(); + while(( pObj = (AliPerformanceObject *)fPitList->Next()) != NULL) { + pObj->Exec(fMC,fESD,fESDfriend,fUseMCInfo,fUseESDfriend); + } + + // Post output data. + PostData(0, fOutput); +} + +//_____________________________________________________________________________ +void AliPerformanceTask::Terminate(Option_t *) +{ + // Called one at the end + + // check output data + fOutput = dynamic_cast (GetOutputData(0)); + if (!fOutput) { + Printf("ERROR: AliPerformanceTask::Terminate(): Output data not avaiable GetOutputData(0)==0x0 ..." ); + return; + } +} + +//_____________________________________________________________________________ +Bool_t AliPerformanceTask::Notify() +{ + static Int_t count = 0; + count++; + Printf("Processing %d. file", count); + + return kTRUE; +} diff --git a/PWG1/TPC/AliPerformanceTask.h b/PWG1/TPC/AliPerformanceTask.h new file mode 100644 index 00000000000..d9a8003278b --- /dev/null +++ b/PWG1/TPC/AliPerformanceTask.h @@ -0,0 +1,58 @@ +#ifndef AliPERFORMANCETASK_H +#define AliPERFORMANCETASK_H + +//------------------------------------------------------------------------------ +// Task to run reconstruction performance. +// +// Author: J.Otwinowski 01/04/2009 +//------------------------------------------------------------------------------ + +class AliESDEvent; +class AliESDfriend; +class AliMCEvent; +class AliPerformanceObject; +class AliMagF; +class TList; + +#include "AliAnalysisTask.h" + +class AliPerformanceTask : public AliAnalysisTask { + public: + AliPerformanceTask(); + AliPerformanceTask(const char *name, const char *title); + virtual ~AliPerformanceTask(); + + virtual void ConnectInputData(Option_t *); + virtual void CreateOutputObjects(); + virtual void Exec(Option_t *option); + virtual void Terminate(Option_t *); + virtual Bool_t Notify(); + + // Add comparison objects + Bool_t AddPerformanceObject(AliPerformanceObject* comp); + + // Use MC + void SetUseMCInfo(Bool_t useMCInfo = kFALSE) {fUseMCInfo = useMCInfo;} + + // Use ESD friend + void SetUseESDfriend(Bool_t useESDFriend = kFALSE) {fUseESDfriend = useESDFriend;} + + private: + AliESDEvent *fESD; //! ESD event + AliESDfriend *fESDfriend; //! ESD friend event + AliMCEvent *fMC; //! MC event + + TList *fOutput; //! list send on output slot 0 + TIterator *fPitList; //! iterator over the output objetcs + TList *fCompList; // list of comparison objects + + Bool_t fUseMCInfo; // use MC information + Bool_t fUseESDfriend; // use ESD friend + + AliPerformanceTask(const AliPerformanceTask&); // not implemented + AliPerformanceTask& operator=(const AliPerformanceTask&); // not implemented + + ClassDef(AliPerformanceTask, 1); // example of analysis +}; + +#endif diff --git a/PWG1/TPC/AliRecInfoCuts.cxx b/PWG1/TPC/AliRecInfoCuts.cxx new file mode 100644 index 00000000000..8b06f2cb48a --- /dev/null +++ b/PWG1/TPC/AliRecInfoCuts.cxx @@ -0,0 +1,81 @@ +/************************************************************************** +* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * +* * +* Author: The ALICE Off-line Project. * +* Contributors are mentioned in the code where appropriate. * +* * +* Permission to use, copy, modify and distribute this software and its * +* documentation strictly for non-commercial purposes is hereby granted * +* without fee, provided that the above copyright notice appears in all * +* copies and that both the copyright notice and this permission notice * +* appear in the supporting documentation. The authors make no claims * +* about the suitability of this software for any purpose. It is * +* provided "as is" without express or implied warranty. * +**************************************************************************/ + +//------------------------------------------------------------------------------ +// Implementation of the AliRecInfoCuts class. It keeps selection cuts for +// reconstructed tracks. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +#include "AliRecInfoCuts.h" + +ClassImp(AliRecInfoCuts) + +//_____________________________________________________________________________ +AliRecInfoCuts::AliRecInfoCuts(const Char_t* name,const Char_t *title) : AliESDtrackCuts(name, title) +, fMinTPCsignalN(0) +, fMaxAbsTanTheta(0) +, fMinNClustersTRD(0) +, fTPCITSMatchingRadius(0) +, fTPCTRDMatchingRadius(0) +, fMinNTrackletsTRD(0) +{ + // init data members with defaults + Init(); +} + +//_____________________________________________________________________________ +void AliRecInfoCuts::Init() +{ + // set default values + SetMinTPCsignalN(); + SetMaxAbsTanTheta(); + SetMinNClustersTRD(); + SetMinNTrackletsTRD(); + SetTPCITSMatchingRadius(); + SetTPCTRDMatchingRadius(); +} + + +//_____________________________________________________________________________ +/* +Long64_t AliRecInfoCuts::Merge(TCollection* list) const +{ + // Merge list of objects (needed by PROOF) + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj = 0; + + Int_t count=0; + while((obj = iter->Next()) != 0) + { + AliRecInfoCuts* entry = dynamic_cast(obj); + if (entry == 0) + continue; + + count++; + } + +return count; +} +*/ + diff --git a/PWG1/TPC/AliRecInfoCuts.h b/PWG1/TPC/AliRecInfoCuts.h new file mode 100644 index 00000000000..bec93e9d630 --- /dev/null +++ b/PWG1/TPC/AliRecInfoCuts.h @@ -0,0 +1,57 @@ +#ifndef ALIRECINFOCUTS_H +#define ALIRECINFOCUTS_H + +//------------------------------------------------------------------------------ +// Class to keep selection cuts for reconstructed tracks. +// +// Author: J.Otwinowski 04/02/2008 +//------------------------------------------------------------------------------ + +#include "AliESDtrackCuts.h" + +class AliRecInfoCuts : public AliESDtrackCuts +{ +public: + AliRecInfoCuts(const Char_t* name ="AliRecInfoCuts", const Char_t *title =""); + virtual ~AliRecInfoCuts() {;} + + // setters + void SetMinTPCsignalN(const Int_t min=0) {fMinTPCsignalN = min;} + void SetMaxAbsTanTheta(const Float_t max=1e99) {fMaxAbsTanTheta = max;} + void SetMinNClustersTRD(const Int_t min=0) {fMinNClustersTRD = min;} + void SetMinNTrackletsTRD(const Int_t min=0) {fMinNTrackletsTRD = min;} + void SetTPCITSMatchingRadius(const Float_t radius=70.) {fTPCITSMatchingRadius = radius;} + void SetTPCTRDMatchingRadius(const Float_t radius=260.) {fTPCTRDMatchingRadius = radius;} + + // getters + Int_t GetMinTPCsignalN() const {return fMinTPCsignalN;} + Float_t GetMaxAbsTanTheta() const {return fMaxAbsTanTheta;} + + // getters for selected AliESDtrackCuts data members + Float_t GetPtMin() const {return fPtMin;} + Float_t GetPtMax() const {return fPtMax;} + Int_t GetMinNClustersTPC() const {return fCutMinNClusterTPC;} + Int_t GetMinNClustersITS() const {return fCutMinNClusterITS;} + Int_t GetMinNClustersTRD() const {return fMinNClustersTRD;} + Int_t GetMinNTrackletsTRD() const {return fMinNTrackletsTRD;} + Float_t GetTPCITSMatchingRadius() const {return fTPCITSMatchingRadius;} + Float_t GetTPCTRDMatchingRadius() const {return fTPCTRDMatchingRadius;} + + // cuts init function + void Init(); + +private: + Int_t fMinTPCsignalN; // min. number of TPC hits + Float_t fMaxAbsTanTheta; // max. absolute value of tan(theta) + Int_t fMinNClustersTRD; // min number of TRD clusters + Float_t fTPCITSMatchingRadius; // TPC-ITS matching radius + Float_t fTPCTRDMatchingRadius; // TPC-TRD matching radius + Int_t fMinNTrackletsTRD; // min number of TRD tracklets + + AliRecInfoCuts(const AliRecInfoCuts&); // not implemented + AliRecInfoCuts& operator=(const AliRecInfoCuts&); // not implemented + + ClassDef(AliRecInfoCuts, 1) +}; + +#endif //ALIRECINFOCUTS_H diff --git a/PWG1/TPC/AliRecInfoMaker.cxx b/PWG1/TPC/AliRecInfoMaker.cxx new file mode 100644 index 00000000000..93c93eb165b --- /dev/null +++ b/PWG1/TPC/AliRecInfoMaker.cxx @@ -0,0 +1,1256 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////////// +// // +// Time Projection Chamber // +// Comparison macro for ESD // +// responsible: +// marian.ivanov@cern.ch // +// +// + +/* +marian.ivanov@cern.ch +Usage: + + + +gSystem->Load("libPWG1.so"); +// +AliRecInfoMaker *t2 = new AliRecInfoMaker("genTracks.root","cmpESDTracks.root","galice.root",0,0); +t2->Exec(); + + +TFile f("cmpESDTracks.root"); +TTree * tree = (TTree*)f.Get("ESDcmpTracks"); + +AliTreeDraw comp; +comp.SetTree(tree) + + + +// +//some cuts definition +TCut cprim("cprim","TMath::Sqrt(MC.fVDist[0]**2+MC.fVDist[1]**2)<0.01&&abs(MC.fVDist[2])<0.01") +//TCut cprim("cprim","TMath::Sqrt(MC.fVDist[0]**2+MC.fVDist[1]**2)<0.5&&abs(MC.fVDist[2])<0.5") +//TCut citsin("citsin","TMath::Sqrt(MC.fVDist[0]**2+MC.fVDist[1]**2)<3.9"); +TCut citsin("citsin","TMath::Sqrt(MC.fVDist[0]**2+MC.fVDist[1]**2)<5"); +TCut csec("csec","TMath::Sqrt(MC.fVDist[0]**2+MC.fVDist[1]**2)>0.5"); + + +TCut crec("crec","fReconstructed==1"); +TCut cteta1("cteta1","abs(MC.fParticle.Theta()/3.1415-0.5)<0.25"); +TCut cteta05("cteta05","abs(MC.fParticle.Theta()/3.1415-0.5)<0.1"); + +TCut cpos1("cpos1","abs(MC.fParticle.fVz/sqrt(MC.fParticle.fVx*MC.fParticle.fVx+MC.fParticle.fVy*MC.fParticle.fVy))<1"); +TCut csens("csens","abs(sqrt(fVDist[0]**2+fVDist[1]**2)-170)<50"); +TCut cmuon("cmuon","abs(MC.fParticle.fPdgCode==-13)"); +TCut cchi2("cchi2","fESDtrack.fITSchi2MIP[0]<7.&&fESDtrack.fITSchi2MIP[1]<5.&&fESDtrack.fITSchi2MIP[2]<7.&&fESDtrack.fITSchi2MIP[3]<7.5&&fESDtrack.fITSchi2MIP[4]<6.") + + +// +//example +comp.T()->SetAlias("radius","TMath::Sqrt(MC.fVDist[0]**2+MC.fVDist[1]**2)"); +comp.T()->SetAlias("direction","MC.fParticle.fVx*MC.fParticle.fPx+MC.fParticle.fVy*MC.fParticle.fPy"); +comp.T()->SetAlias("decaydir","MC.fTRdecay.fX*MC.fTRdecay.fPx+MC.fTRdecay.fY*MC.fTRdecay.fPy"); +comp.T()->SetAlias("theta","MC.fTrackRef.Theta()"); +comp.T()->SetAlias("primdca","sqrt(RC.fITStrack.fD[0]**2+RC.fITStrack.fD[1]**2)"); +comp.T()->SetAlias("trdchi2","fTRDtrack.fChi2/fTRDtrack.fN"); +comp.T()->SetAlias("trdchi2","fTRDtrack.fChi2/fTRDtrack.fN"); + + +TH1F his("his","his",100,0,20); +TH1F hpools("hpools","hpools",100,-7,7); +TH1F hfake("hfake","hfake",1000,0,150); +TProfile profp0("profp0","profp0",20,-0.4,0.9) + +comp.DrawXY("fTPCinP0[3]","fTPCDelta[4]/fTPCinP1[3]","fReconstructed==1"+cprim,"1",4,0.2,1.5,-0.06,0.06) +comp.fRes->Draw(); +comp.fMean->Draw(); + +comp.DrawXY("fITSinP0[3]","fITSDelta[4]/fITSinP1[3]","fReconstructed==1&&fITSOn"+cprim,"1",4,0.2,1.5,-0.06,0.06) +comp.fRes->Draw(); + +comp.Eff("fTPCinP0[3]","fRowsWithDigits>120"+cteta1+cpos1+cprim,"fTPCOn",20,0.2,1.5) +comp.fRes->Draw(); + +comp.Eff("fTPCinP0[3]","fRowsWithDigits>120"+cteta1+cpos1+cprim,"fTPCOn&&fITSOn&&fESDtrack.fITSFakeRatio<0.1",10,0.2,1.5) +comp.fRes->Draw(); +comp.Eff("fTPCinP0[3]","fRowsWithDigits>120"+cteta1+cpos1+cprim,"fTPCOn&&fITSOn&&fESDtrack.fITSFakeRatio>0.1",10,0.2,1.5) +comp.fRes->Draw(); + +comp.T()->Draw("fESDtrack.fITSsignal/fESDtrack.fTPCsignal","fITSOn&&fTPCOn&&fESDtrack.fITSFakeRatio==0") + +TH1F his("his","his",100,0,20); +TH1F hpools("hpools","hpools",100,-7,7); + +TH2F * hdedx0 = new TH2F("dEdx0","dEdx0",100, 0,2,200,0,550); hdedx0->SetMarkerColor(1); +TH2F * hdedx1 = new TH2F("dEdx1","dEdx1",100, 0,2,200,0,550); hdedx1->SetMarkerColor(4); +TH2F * hdedx2 = new TH2F("dEdx2","dEdx2",100, 0,2,200,0,550); hdedx2->SetMarkerColor(3); +TH2F * hdedx3 = new TH2F("dEdx3","dEdx3",100, 0,2,200,0,550); hdedx3->SetMarkerColor(2); + +comp.T()->Draw("fESDtrack.fITSsignal:MC.fParticle.P()>>dEdx0","fITSOn&&abs(fPdg)==211&&fITStrack.fN==6"+cprim) +comp.T()->Draw("fESDtrack.fITSsignal:MC.fParticle.P()>>dEdx1","fITSOn&&abs(fPdg)==2212&&fITStrack.fN==6"+cprim) +comp.T()->Draw("fESDtrack.fITSsignal:MC.fParticle.P()>>dEdx2","fITSOn&&abs(fPdg)==321&&fITStrack.fN==6"+cprim) +comp.T()->Draw("fESDtrack.fITSsignal:MC.fParticle.P()>>dEdx3","fITSOn&&abs(fPdg)==11&&fITStrack.fN==6"+cprim) + + +comp.T()->Draw("fESDtrack.fTRDsignal:MC.fParticle.P()>>dEdx0","fTRDOn&&abs(fPdg)==211&&fTRDtrack.fN>40&&fStatus[2]>1") +comp.T()->Draw("fESDtrack.fTRDsignal:MC.fParticle.P()>>dEdx1","fTRDOn&&abs(fPdg)==2212&&fTRDtrack.fN>40&&fStatus[2]>1") +comp.T()->Draw("fESDtrack.fTRDsignal:MC.fParticle.P()>>dEdx2","fTRDOn&&abs(fPdg)==321&&fTRDtrack.fN>40&&fStatus[2]>1") +comp.T()->Draw("fESDtrack.fTRDsignal:MC.fParticle.P()>>dEdx3","fTRDOn&&abs(fPdg)==11&&fTRDtrack.fN>40&&fStatus[2]>1") + +comp.T()->Draw("fESDtrack.fTPCsignal:fTPCinP0[4]>>dEdx0","fTPCOn&&abs(fPdg)==211&&fESDtrack.fTPCncls>180&&fESDtrack.fTPCsignal>10"+cteta1); +comp.T()->Draw("fESDtrack.fTPCsignal:fTPCinP0[4]>>dEdx1","fTPCOn&&abs(fPdg)==2212&&fESDtrack.fTPCncls>180&&fESDtrack.fTPCsignal>10"+cteta1); +comp.T()->Draw("fESDtrack.fTPCsignal:fTPCinP0[4]>>dEdx2","fTPCOn&&abs(fPdg)==321&&fESDtrack.fTPCncls>180&&fESDtrack.fTPCsignal>10"+cteta1); +comp.T()->Draw("fESDtrack.fTPCsignal:fTPCinP0[4]>>dEdx3","fTPCOn&&abs(fPdg)==11&&fESDtrack.fTPCncls>180&&fESDtrack.fTPCsignal>10"+cteta1); + +hdedx3->SetXTitle("P(GeV/c)"); +hdedx3->SetYTitle("dEdx(unit)"); +hdedx3->Draw(); hdedx1->Draw("same"); hdedx2->Draw("same"); hdedx0->Draw("same"); + +comp.DrawXY("fITSinP0[3]","fITSPools[4]","fReconstructed==1&&fPdg==-211&&fITSOn"+cprim,"1",4,0.2,1.0,-8,8) + +TProfile prof("prof","prof",10,0.5,5); + + + + +*/ + + +#include +#include +//ROOT includes +#include "Rtypes.h" +#include "TFile.h" +#include "TTree.h" +#include "TStopwatch.h" +#include "TVector3.h" +#include "TGeoManager.h" +//#include "Getline.h" +// +//ALIROOT includes +// +#include "AliRun.h" +#include "AliESDtrack.h" +#include "AliTPCParam.h" +#include "AliTPC.h" +#include "AliTrackReference.h" +#include "AliTPCParamSR.h" +#include "AliTracker.h" +#include "AliESDEvent.h" +#include "AliESD.h" +#include "AliESDfriend.h" +#include "AliESDtrack.h" +#include "AliTPCseed.h" +#include "AliITStrackMI.h" +#include "AliESDVertex.h" +#include "AliExternalTrackParam.h" +#include "AliESDkink.h" +#include "AliESDv0.h" +#include "AliV0.h" +// +#include "AliTreeDraw.h" +#include "AliMCInfo.h" +#include "AliGenKinkInfo.h" +#include "AliGenV0Info.h" + + +#include "AliESDRecInfo.h" +#include "AliESDRecV0Info.h" +#include "AliESDRecKinkInfo.h" +#include "AliRecInfoMaker.h" + + + +ClassImp(AliRecInfoMaker) + + + + +AliTPCParam * AliRecInfoMaker::GetTPCParam(){ + // + // create TPC param + // + AliTPCParamSR * par = new AliTPCParamSR; + par->Update(); + return par; +} + + + +void AliRecInfoMaker::MakeAliases(TTree * tree) +{ + // + // aliases definition + // + tree->SetAlias("radius","TMath::Sqrt(MC.fVDist[0]**2+MC.fVDist[1]**2)"); + tree->SetAlias("direction","MC.fParticle.fVx*MC.fParticle.fPx+MC.fParticle.fVy*MC.fParticle.fPy"); + tree->SetAlias("decaydir","MC.fTRdecay.fX*MC.fTRdecay.fPx+MC.fTRdecay.fY*MC.fTRdecay.fPy"); + tree->SetAlias("theta","MC.fTrackRef.Theta()"); + tree->SetAlias("primdca","sqrt(RC.fITStrack.fD[0]**2+RC.fITStrack.fD[1]**2)"); + tree->SetAlias("trdchi2","fTRDtrack.fChi2/fTRDtrack.fN"); + tree->SetAlias("trdchi2","fTRDtrack.fChi2/fTRDtrack.fN"); + + tree->SetAlias("trddedx","(RC.fESDtrack.fTRDsignals[0]+RC.fESDtrack.fTRDsignals[1]+RC.fESDtrack.fTRDsignals[2]+RC.fESDtrack.fTRDsignals[3]+RC.fESDtrack.fTRDsignals[4]+RC.fESDtrack.fTRDsignals[5])/6."); + + tree->SetAlias("dtofmc2","fESDtrack.fTrackTime[2]-(10^12*MC.fTOFReferences[0].fTime)"); + tree->SetAlias("dtofrc2","(fESDtrack.fTrackTime[2]-fESDtrack.fTOFsignal)"); + + tree->SetAlias("psum","fESDtrack.fTOFr[4]+fESDtrack.fTOFr[3]+fESDtrack.fTOFr[2]+fESDtrack.fTOFr[1]+fESDtrack.fTOFr[0]"); + tree->SetAlias("P0","fESDtrack.fTOFr[0]/psum"); + tree->SetAlias("P1","fESDtrack.fTOFr[1]/psum"); + tree->SetAlias("P2","fESDtrack.fTOFr[2]/psum"); + tree->SetAlias("P3","fESDtrack.fTOFr[3]/psum"); + tree->SetAlias("P4","fESDtrack.fTOFr[4]/psum"); + tree->SetAlias("MaxP","max(max(max(P0,P1),max(P2,P3)),P4)"); +} + + +//////////////////////////////////////////////////////////////////////// +AliRecInfoMaker::AliRecInfoMaker(const char* fnGenTracks, + const char* fnCmp, + const char* fnGalice, + Int_t nEvents, Int_t firstEvent): + + fEventNr(0), //! current event number + fNEvents(0), //! number of events to process + fFirstEventNr(0), //! first event to process + fFileCmp(0), //! output file with cmp tracks + fTreeCmp(0), //! output tree with cmp tracks + fTreeCmpKinks(0), //! output tree with cmp Kinks + fTreeCmpV0(0), //! output tree with cmp V0 + // + fFileGenTracks(0), //! input files with generated tracks + fTreeGenTracks(0), //! tree with generated tracks + fTreeGenKinks(0), // tree with gen kinks + fTreeGenV0(0), // tree with gen V0 + // + fLoader(0), //! pointer to the run loader + // + fIndexRecTracks(0), //! index of particle label in the TreeT_ESD + fFakeRecTracks(0), //! number of fake tracks + fMultiRecTracks(0), //! number of multiple reconstructions + // + fIndexRecKinks(0), //! index of particle label in treeesd + fMultiRecKinks(0), //! number of multiple reconstructions + fSignedKinks(0), //! indicator that kink was not fake + // + fIndexRecV0(0), //! index of particle label in treeesd + fMultiRecV0(0), //! number of multiple reconstructions + fSignedV0(0), //! indicator that kink was not fake + // + fRecArray(0), // container with rec infos + fEvent(0), //!event + fESDfriend(0), //!event friend + // + fParamTPC(0), //! AliTPCParam + fNParticles(0), //! number of particles in the input tree genTracks + fDebug(0), //! debug flag + fNextTreeGenEntryToRead(0), //! last entry already read from genTracks tree + fNextKinkToRead(0), //! last entry already read from genKinks tree + fNextV0ToRead(0), //! last entry already read from genV0 tree + // + fMCInfo(0), //! MC information writen per particle + fGenKinkInfo(0), //! MC information writen per Kink + fGenV0Info(0), //! MC information writen per Kink + fRecInfo(0), //! Rec. information writen per particle + fFriend(0), //! friend track + fRecKinkInfo(0), //! reconstructed kink info + fRecV0Info(0) //! reconstructed kink info +{ + // AliRecInfoMaker - connencts the MC information with reconstructed information + // fnGenTracks - file with MC to be created before using AliGenInfoMaker + // fnCmp - file name to be created + // fnGalice - file with Loaders - usualy galice.root + // + // nEvent - number of event s to be analyzed + // AliRecInfoMaker *t2 = new AliRecInfoMaker("genTracks.root","cmpESDTracks.root","galice.root",0,0); + // + + + Reset(); + // fFnGenTracks = fnGenTracks; + // fFnCmp = fnCmp; + sprintf(fFnGenTracks,"%s",fnGenTracks); + sprintf(fFnCmp,"%s",fnCmp); + + fFirstEventNr = firstEvent; + fEventNr = firstEvent; + fNEvents = nEvents; + // + fLoader = AliRunLoader::Open(fnGalice); + if (gAlice){ + //delete AliRunLoader::Instance(); + delete gAlice; + gAlice = 0x0; + } + if (fLoader->LoadgAlice()){ + cerr<<"Error occured while l"<GetNumberOfEvents(); + if (nEvents==0) { + nEvents =nall; + fNEvents=nall; + fFirstEventNr=0; + } + + if (nall<=0){ + cerr<<"no events available"<nall) { + fEventNr = nall-firstEvent; + cerr<<"restricted number of events availaible"<SetBranchStatus("*",1); + fEvent = new AliESDEvent; + + if (tree->GetBranch("ESD")){ + // tree->SetBranchAddress("ESD", &fEvent); + // tree->SetBranchAddress("ESDfriend.",&fESDfriend); + // tree->GetEntry(eventNr); + // fEvent->SetESDfriend(fESDfriend); + }else{ + fEvent->ReadFromTree(tree); + fESDfriend = (AliESDfriend*)fEvent->FindListObject("AliESDfriend"); + tree->GetEntry(eventNr); + fEvent->SetESDfriend(fESDfriend); + } + + + + if (!fEvent) return 1; + + return 0; +} + + + +//////////////////////////////////////////////////////////////////////// +void AliRecInfoMaker::Reset() +{ + // + // Reset the class + // + fEventNr = 0; + fNEvents = 0; + fTreeCmp = 0; + fTreeCmpKinks =0; + fTreeCmpV0 =0; + // fFnCmp = "cmpTracks.root"; + fFileGenTracks = 0; + fDebug = 0; + // + fParamTPC = 0; + fEvent =0; +} + +//////////////////////////////////////////////////////////////////////// +Int_t AliRecInfoMaker::Exec(Int_t nEvents, Int_t firstEventNr) +{ + // + // Exec comparison for subrange of events + // + fNEvents = nEvents; + fFirstEventNr = firstEventNr; + return Exec(); +} + +//////////////////////////////////////////////////////////////////////// +Int_t AliRecInfoMaker::Exec() +{ + // + // Exec comparison + // + TStopwatch timer; + timer.Start(); + + if (SetIO()==1) + return 1; + + fNextTreeGenEntryToRead = 0; + fNextKinkToRead = 0; + fNextV0ToRead =0; + cerr<<"fFirstEventNr, fNEvents: "<GetEvent(fEventNr); + + fIndexRecTracks = new Short_t[fNParticles*20]; //write at maximum 4 tracks corresponding to particle + fIndexRecKinks = new Short_t[fNParticles*20]; //write at maximum 20 tracks corresponding to particle + fIndexRecV0 = new Short_t[fNParticles*20]; //write at maximum 20 tracks corresponding to particle + + fFakeRecTracks = new Short_t[fNParticles]; + fMultiRecTracks = new Short_t[fNParticles]; + fMultiRecKinks = new Short_t[fNParticles]; + fMultiRecV0 = new Short_t[fNParticles]; + + for (Int_t i = 0; i0) return 1; + + if (fDebug>2) cout<<"\tStart loop over tree genTracks"<0) return 1; + //BuildKinkInfo0(eventNr); + BuildV0Info(eventNr); // no V0 info for a moment + fRecArray->Delete(); + + if (fDebug>2) cout<<"\tEnd loop over tree genTracks"<Get("genTracksTree"); + if (!fTreeGenTracks) { + cerr<<"Error in ConnectGenTree: cannot find genTracksTree in the file " + <SetBranchAddress("MC",&fMCInfo); + // + // + fTreeGenKinks = (TTree*)fFileGenTracks->Get("genKinksTree"); + if (!fTreeGenKinks) { + cerr<<"Error in ConnectGenTree: cannot find genTracksTree in the file " + <SetBranchAddress("MC",&fGenKinkInfo); + } + + fTreeGenV0 = (TTree*)fFileGenTracks->Get("genV0Tree"); + if (!fTreeGenV0) { + cerr<<"Error in ConnectGenTree: cannot find genTracksTree in the file " + <SetBranchAddress("MC",&fGenV0Info); + } + // + if (fDebug > 1) { + cout<<"Number of gen. tracks with TR: "<GetEntries()<Branch("MC","AliMCInfo",&fMCInfo,256000); + fTreeCmp->Branch("RC","AliESDRecInfo",&fRecInfo,256000); + // fTreeCmp->Branch("ITS","AliITStrackMI",&itsTrack); + delete esdTrack; + // + // + fTreeCmpKinks = new TTree("ESDcmpKinks","ESDcmpKinks"); + fGenKinkInfo = new AliGenKinkInfo; + fRecKinkInfo = new AliESDRecKinkInfo; + fTreeCmpKinks->Branch("MC.","AliGenKinkInfo",&fGenKinkInfo,256000); + fTreeCmpKinks->Branch("RC.","AliESDRecKinkInfo",&fRecKinkInfo,256000); + // + // + fTreeCmpV0 = new TTree("ESDcmpV0","ESDcmpV0"); + fGenV0Info = new AliGenV0Info; + fRecV0Info = new AliESDRecV0Info; + fTreeCmpV0->Branch("MC.","AliGenV0Info", &fGenV0Info,256000); + fTreeCmpV0->Branch("RC.","AliESDRecV0Info",&fRecV0Info,256000); + // + fTreeCmp->AutoSave(); + fTreeCmpKinks->AutoSave(); + fTreeCmpV0->AutoSave(); +} + +//////////////////////////////////////////////////////////////////////// +void AliRecInfoMaker::CloseOutputFile() +{ + // + // Close output file + // + + if (!fFileCmp) { + cerr<<"File "<cd(); + fTreeCmp->Write(); + delete fTreeCmp; + + fFileCmp->Close(); + delete fFileCmp; + return; +} +//////////////////////////////////////////////////////////////////////// + +TVector3 AliRecInfoMaker::TR2Local(AliTrackReference *trackRef, + AliTPCParam *paramTPC) { + + // + // Transform position to the local coord frame + // + + Float_t x[3] = { trackRef->X(),trackRef->Y(),trackRef->Z()}; + Int_t index[4]; + paramTPC->Transform0to1(x,index); + paramTPC->Transform1to2Ideal(x,index); + return TVector3(x); +} +//////////////////////////////////////////////////////////////////////// + +Int_t AliRecInfoMaker::TreeTLoop() +{ + // + // loop over all ESD reconstructed tracks and store info in memory + // + // + loop over all reconstructed kinks + TStopwatch timer; + timer.Start(); + // + Int_t nEntries = (Int_t)fEvent->GetNumberOfTracks(); + Int_t nKinks = (Int_t) fEvent->GetNumberOfKinks(); + Int_t nV0MIs = (Int_t) fEvent->GetNumberOfV0s(); + fSignedKinks = new Short_t[nKinks]; + fSignedV0 = new Short_t[nV0MIs]; + // + // load kinks to the memory + for (Int_t i=0; iGetKink(i); + fSignedKinks[i]=0; + } + // + for (Int_t i=0; iGetV0(i); + fSignedV0[i]=0; + } + + // + // + AliESDtrack * track=0; + for (Int_t iEntry=0; iEntryGetTrack(iEntry); + // + Int_t label = track->GetLabel(); + Int_t absLabel = abs(label); + if (absLabel < fNParticles) { + // fIndexRecTracks[absLabel] = iEntry; + if (label < 0) fFakeRecTracks[absLabel]++; + if (fMultiRecTracks[absLabel]>0){ + if (fMultiRecTracks[absLabel]<20) + fIndexRecTracks[absLabel*20+fMultiRecTracks[absLabel]] = iEntry; + } + else + fIndexRecTracks[absLabel*20] = iEntry; + fMultiRecTracks[absLabel]++; + } + } + // sort reconstructed kinks + // + AliESDkink * kink=0; + for (Int_t iEntry=0; iEntryGetKink(iEntry); + if (!kink) continue; + // + Int_t label0 = TMath::Abs(kink->GetLabel(0)); + Int_t label1 = TMath::Abs(kink->GetLabel(1)); + Int_t absLabel = TMath::Min(label0,label1); + if (absLabel < fNParticles) { + if (fMultiRecKinks[absLabel]>0){ + if (fMultiRecKinks[absLabel]<20) + fIndexRecKinks[absLabel*20+fMultiRecKinks[absLabel]] = iEntry; + } + else + fIndexRecKinks[absLabel*20] = iEntry; + fMultiRecKinks[absLabel]++; + } + } + // --sort reconstructed V0 + // + AliV0 * v0MI=0; + for (Int_t iEntry=0; iEntryGetV0(iEntry); + if (!v0MI) continue; + // + // + // + //Int_t label0 = TMath::Abs(v0MI->GetLabel(0)); + //Int_t label1 = TMath::Abs(v0MI->GetLabel(1)); + AliESDtrack * trackn = fEvent->GetTrack((v0MI->GetNindex())); + AliESDtrack * trackp = fEvent->GetTrack((v0MI->GetPindex())); + Int_t labels[2]={-1,-1}; + labels[0] = (trackn==0) ? -1 : TMath::Abs(trackn->GetLabel()); + labels[1] = (trackp==0) ? -1 : TMath::Abs(trackp->GetLabel()); + // + for (Int_t i=0;i<2;i++){ + Int_t absLabel = TMath::Abs(labels[i]); + if (absLabel < fNParticles) { + if (fMultiRecV0[absLabel]>0){ + if (fMultiRecV0[absLabel]<20) + fIndexRecV0[absLabel*20+fMultiRecV0[absLabel]] = iEntry; + } + else + fIndexRecV0[absLabel*20] = iEntry; + fMultiRecV0[absLabel]++; + } + } + } + + + printf("Time spended in TreeTLoop\n"); + timer.Print(); + + if (fDebug > 2) cerr<<"end of TreeTLoop"<GetEntriesFast(); + cerr<<"fNParticles, nParticlesTR, fNextTreeGenEntryToRead: "<GetBranch("RC"); + // TBranch * branchF = fTreeCmp->GetBranch("F"); + + branch->SetAddress(&fRecInfo); // set all pointers + fRecArray = new TObjArray(fNParticles); + AliESDtrack dummytrack; // + AliESDfriendTrack dummytrackF; // + + while (entry < nParticlesTR) { + fTreeGenTracks->GetEntry(entry); + entry++; + if (eventNr < fMCInfo->fEventNr) continue; + if (eventNr > fMCInfo->fEventNr) continue; + if (fMCInfo->GetCharge()==0) continue; + // + fNextTreeGenEntryToRead = entry-1; + if (fDebug > 2 && fMCInfo->fLabel < 10) { + cerr<<"Fill track with a label "<fLabel<fNTPCRef<1) continue; // not TPCref + // + fRecInfo->Reset(); + AliESDtrack * track=0; + fRecInfo->fReconstructed =0; + TVector3 local = TR2Local(&(fMCInfo->fTrackRef),fParamTPC); + local.GetXYZ(fRecInfo->fTRLocalCoord); + // + if (fIndexRecTracks[fMCInfo->fLabel*20] >= 0) { + track= (AliESDtrack*)fEvent->GetTrack(fIndexRecTracks[fMCInfo->fLabel*20]); + // + // + // find nearest track if multifound + //Int_t sign = Int_t(track->GetSign()*fMCInfo->fCharge); + // + Int_t status = 0; + if ((track->GetStatus()&AliESDtrack::kITSrefit)>0) status++; + if ((track->GetStatus()&AliESDtrack::kTPCrefit)>0) status++; + if ((track->GetStatus()&AliESDtrack::kTRDrefit)>0) status++; + + // + if (fIndexRecTracks[fMCInfo->fLabel*20+1]>0){ + // + Double_t p[3]; + track->GetInnerPxPyPz(p); + Float_t maxp = p[0]*p[0]+p[1]*p[1]+p[2]*p[2]; + // + for (Int_t i=1;i<20;i++){ + if (fIndexRecTracks[fMCInfo->fLabel*20+i]>=0){ + AliESDtrack * track2 = (AliESDtrack*)fEvent->GetTrack(fIndexRecTracks[fMCInfo->fLabel*20+i]); + if (!track2) continue; + //Int_t sign2 = track->GetSign()*fMCInfo->fCharge; // + //if (sign2<0) continue; + track2->GetInnerPxPyPz(p); + Float_t mom = p[0]*p[0]+p[1]*p[1]+p[2]*p[2]; + /* + if (sign<0){ + sign = sign2; + track = track2; + maxp = mom; + continue; + } + */ + // + Int_t status2 = 0; + if ((track2->GetStatus()&AliESDtrack::kITSrefit)>0) status2++; + if ((track2->GetStatus()&AliESDtrack::kTPCrefit)>0) status2++; + if ((track2->GetStatus()&AliESDtrack::kTRDrefit)>0) status2++; + if (status2SetESDtrack(track); + }else{ + fRecInfo->SetESDtrack(&dummytrack); + } + // + + fRecInfo->fReconstructed = 1; + fRecInfo->fFake = fFakeRecTracks[fMCInfo->fLabel]; + fRecInfo->fMultiple = fMultiRecTracks[fMCInfo->fLabel]; + // + fRecInfo->Update(fMCInfo,fParamTPC,kTRUE); + } + else{ + fRecInfo->SetESDtrack(&dummytrack); + fRecInfo->Update(fMCInfo,fParamTPC,kFALSE); + } + fRecArray->AddAt(new AliESDRecInfo(*fRecInfo),fMCInfo->fLabel); + fTreeCmp->Fill(); + } + fTreeCmp->AutoSave(); + printf("Time spended in TreeGenLoop\n"); + timer.Print(); + if (fDebug > 2) cerr<<"end of TreeGenLoop"<GetEntriesFast(); + cerr<<"fNParticles, nParticlesTR, fNextKinkToRead: "<GetBranch("RC."); + branch->SetAddress(&fRecKinkInfo); // set all pointers + + // + while (entry < nParticlesTR) { + fTreeGenKinks->GetEntry(entry); + entry++; + if (eventNr < fGenKinkInfo->GetMinus().fEventNr) continue; + if (eventNr > fGenKinkInfo->GetMinus().fEventNr) continue;; + // + fNextKinkToRead = entry-1; + // + // + AliESDRecInfo* fRecInfo1 = (AliESDRecInfo*)fRecArray->At(fGenKinkInfo->GetMinus().fLabel); + AliESDRecInfo* fRecInfo2 = (AliESDRecInfo*)fRecArray->At(fGenKinkInfo->GetPlus().fLabel); + fRecKinkInfo->fT1 = (*fRecInfo1); + fRecKinkInfo->fT2 = (*fRecInfo2); + fRecKinkInfo->fStatus =0; + if (fRecInfo1 && fRecInfo1->fTPCOn) fRecKinkInfo->fStatus+=1; + if (fRecInfo2 && fRecInfo2->fTPCOn) fRecKinkInfo->fStatus+=2; + if (fRecKinkInfo->fStatus==3&&fRecInfo1->fSign!=fRecInfo2->fSign) fRecKinkInfo->fStatus*=-1; + + if (fRecKinkInfo->fStatus==3){ + fRecKinkInfo->Update(); + } + Int_t label = TMath::Min(fGenKinkInfo->GetMinus().fLabel,fGenKinkInfo->GetPlus().fLabel); + Int_t label2 = TMath::Max(fGenKinkInfo->GetMinus().fLabel,fGenKinkInfo->GetPlus().fLabel); + + AliESDkink *kink=0; + fRecKinkInfo->fRecStatus =0; + fRecKinkInfo->fMultiple = fMultiRecKinks[label]; + fRecKinkInfo->fKinkMultiple=0; + // + if (fMultiRecKinks[label]>0){ + + // for (Int_t j=0;j=0;j--){ + Int_t index = fIndexRecKinks[label*20+j]; + //AliESDkink *kink2 = (AliESDkink*)fKinks->At(index); + AliESDkink *kink2 = (AliESDkink*)fEvent->GetKink(index); + if (TMath::Abs(kink2->GetLabel(0))==label &&TMath::Abs(kink2->GetLabel(1))==label2) { + fRecKinkInfo->fKinkMultiple++; + fSignedKinks[index]=1; + Int_t c0=0; + if (kink){ + // if (kink->fTRDOn) c0++; + //if (kink->fITSOn) c0++; + if (kink->GetStatus(2)>0) c0++; + if (kink->GetStatus(0)>0) c0++; + } + Int_t c2=0; + // if (kink2->fTRDOn) c2++; + //if (kink2->fITSOn) c2++; + if (kink2->GetStatus(2)>0) c2++; + if (kink2->GetStatus(0)>0) c2++; + + if (c2GetLabel(1))==label &&TMath::Abs(kink2->GetLabel(0))==label2) { + fRecKinkInfo->fKinkMultiple++; + fSignedKinks[index]=1; + Int_t c0=0; + if (kink){ + //if (kink->fTRDOn) c0++; + //if (kink->fITSOn) c0++; + if (kink->GetStatus(2)>0) c0++; + if (kink->GetStatus(0)>0) c0++; + + } + Int_t c2=0; + // if (kink2->fTRDOn) c2++; + //if (kink2->fITSOn) c2++; + if (kink2->GetStatus(2)>0) c2++; + if (kink2->GetStatus(0)>0) c2++; + + if (c2fKink = *kink; + fRecKinkInfo->fRecStatus=1; + } + fTreeCmpKinks->Fill(); + } + // Int_t nkinks = fKinks->GetEntriesFast(); + Int_t nkinks = fEvent->GetNumberOfKinks(); + for (Int_t i=0;iAt(i); + AliESDkink *kink = (AliESDkink*)fEvent->GetKink(i); + if (!kink) continue; + // + fRecKinkInfo->fKink = *kink; + fRecKinkInfo->fRecStatus =-2; + // + AliESDRecInfo* fRecInfo1 = (AliESDRecInfo*)fRecArray->At(TMath::Abs(kink->GetLabel(0))); + AliESDRecInfo* fRecInfo2 = (AliESDRecInfo*)fRecArray->At(TMath::Abs(kink->GetLabel(1))); + if (fRecInfo1 && fRecInfo2){ + fRecKinkInfo->fT1 = (*fRecInfo1); + fRecKinkInfo->fT2 = (*fRecInfo2); + fRecKinkInfo->fRecStatus =-1; + } + fTreeCmpKinks->Fill(); + } + } + + + fTreeCmpKinks->AutoSave(); + printf("Time spended in BuilKinkInfo Loop\n"); + timer.Print(); + if (fDebug > 2) cerr<<"end of BuildKinkInfo Loop"<GetEntriesFast(); + cerr<<"fNParticles, nParticlesTR, fNextV0ToRead: "<GetBranch("RC."); + branch->SetAddress(&fRecV0Info); // set all pointers + const AliESDVertex * esdvertex = fEvent->GetVertex(); + Float_t vertex[3]= {esdvertex->GetXv(), esdvertex->GetYv(),esdvertex->GetZv()}; + + // + while (entry < nParticlesTR) { + fTreeGenV0->GetEntry(entry); + entry++; + fRecV0Info->Reset(); //reset all variables + if (eventNr < fGenV0Info->GetMinus().fEventNr) continue; + if (eventNr > fGenV0Info->GetMinus().fEventNr) continue;; + // + fNextV0ToRead = entry-1; + // + // + AliESDRecInfo* fRecInfo1 = (AliESDRecInfo*)fRecArray->At(fGenV0Info->GetMinus().fLabel); + AliESDRecInfo* fRecInfo2 = (AliESDRecInfo*)fRecArray->At(fGenV0Info->GetPlus().fLabel); + if (fGenV0Info->GetMinus().fCharge*fGenV0Info->GetPlus().fCharge>0) continue; // interactions + if (!fRecInfo1 || !fRecInfo2) continue; + fRecV0Info->fT1 = (*fRecInfo1); + fRecV0Info->fT2 = (*fRecInfo2); + fRecV0Info->fV0Status =0; + if (fRecInfo1 && fRecInfo1->fStatus[1]>0) fRecV0Info->fV0Status+=1; + if (fRecInfo2 && fRecInfo2->fStatus[1]>0) fRecV0Info->fV0Status+=2; + + if (fRecV0Info->fV0Status==3&&fRecInfo1->fSign==fRecInfo2->fSign) fRecV0Info->fV0Status*=-1; + + + if (abs(fRecV0Info->fV0Status)==3){ + fRecV0Info->Update(vertex); + { + // + // TPC V0 Info + Double_t x,alpha, param[5],cov[15]; + if ( fRecV0Info->fT1.GetESDtrack()->GetInnerParam() && fRecV0Info->fT2.GetESDtrack()->GetInnerParam()){ + fRecV0Info->fT1.GetESDtrack()->GetInnerExternalParameters(alpha,x,param); + fRecV0Info->fT1.GetESDtrack()->GetInnerExternalCovariance(cov); + AliExternalTrackParam paramP(x,alpha,param,cov); + // + fRecV0Info->fT2.GetESDtrack()->GetInnerExternalParameters(alpha,x,param); + fRecV0Info->fT2.GetESDtrack()->GetInnerExternalCovariance(cov); + AliExternalTrackParam paramM(x,alpha,param,cov); + // + fRecV0Info->fV0tpc->SetParamN(paramM); + fRecV0Info->fV0tpc->SetParamP(paramP); + Double_t pid1[5],pid2[5]; + fRecV0Info->fT1.GetESDtrack()->GetESDpid(pid1); + fRecV0Info->fT1.GetESDtrack()->GetESDpid(pid2); + // + //fRecV0Info->fV0tpc.UpdatePID(pid1,pid2); + fRecV0Info->fV0tpc->Update(vertex); + + // + // + fRecV0Info->fT1.GetESDtrack()->GetExternalParameters(x,param); + fRecV0Info->fT1.GetESDtrack()->GetExternalCovariance(cov); + alpha = fRecV0Info->fT1.GetESDtrack()->GetAlpha(); + new (¶mP) AliExternalTrackParam(x,alpha,param,cov); + // + fRecV0Info->fT2.GetESDtrack()->GetExternalParameters(x,param); + fRecV0Info->fT2.GetESDtrack()->GetExternalCovariance(cov); + alpha = fRecV0Info->fT2.GetESDtrack()->GetAlpha(); + new (¶mM) AliExternalTrackParam(x,alpha,param,cov); + // + fRecV0Info->fV0its->SetParamN(paramM); + fRecV0Info->fV0its->SetParamP(paramP); + // fRecV0Info->fV0its.UpdatePID(pid1,pid2); + fRecV0Info->fV0its->Update(vertex); + } + } + // + // ???? + // + if (TMath::Abs(fGenV0Info->GetMinus().fPdg)==11 &&TMath::Abs(fGenV0Info->GetPlus().fPdg)==11){ + if (fRecV0Info->fDist2>10){ + fRecV0Info->Update(vertex); + } + if (fRecV0Info->fDist2>10){ + fRecV0Info->Update(vertex); + } + } + } + // + // take the V0 from reconstruction + + Int_t label = TMath::Min(fGenV0Info->GetMinus().fLabel,fGenV0Info->GetPlus().fLabel); + Int_t label2 = TMath::Max(fGenV0Info->GetMinus().fLabel,fGenV0Info->GetPlus().fLabel); + AliV0 *v0MI=0; + AliV0 *v0MIOff=0; + fRecV0Info->fRecStatus =0; + fRecV0Info->fMultiple = fMultiRecV0[label]; + fRecV0Info->fV0MultipleOn=0; + fRecV0Info->fV0MultipleOff=0; + // + if (fMultiRecV0[label]>0 || fMultiRecV0[label2]>0){ + + // for (Int_t j=0;j=0;j--){ + Int_t index = fIndexRecV0[label*20+j]; + if (index<0) continue; + AliV0 *v0MI2 = (AliV0*)fEvent->GetV0(index); + // get track labels + AliESDtrack * trackn = fEvent->GetTrack((v0MI2->GetNindex())); + AliESDtrack * trackp = fEvent->GetTrack((v0MI2->GetPindex())); + Int_t vlabeln = (trackn==0) ? -1 : trackn->GetLabel(); + Int_t vlabelp = (trackp==0) ? -1 : trackp->GetLabel(); + fRecV0Info->fLab[0]=TMath::Abs(vlabelp); + fRecV0Info->fLab[1]=TMath::Abs(vlabeln); + // + if (TMath::Abs(vlabeln)==label &&TMath::Abs(vlabelp)==label2) { + if (v0MI2->GetOnFlyStatus()) { + v0MI =v0MI2; + fRecV0Info->fV0MultipleOn++; + }else { + v0MIOff = v0MI2; + fRecV0Info->fV0MultipleOff++; + } + fSignedV0[index]=1; + } + if (TMath::Abs(vlabelp)==label &&TMath::Abs(vlabeln)==label2) { + if (v0MI2->GetOnFlyStatus()){ + v0MI =v0MI2; + fRecV0Info->fV0MultipleOn++; + }else { + v0MIOff = v0MI2; + fRecV0Info->fV0MultipleOff++; + } + fSignedV0[index]=1; + } + } + } + if (v0MI){ + new (fRecV0Info->fV0rec) AliV0(*v0MI); + fRecV0Info->fRecStatus=1; + } + if (v0MIOff){ + new (fRecV0Info->fV0recOff) AliV0(*v0MIOff); + fRecV0Info->fRecStatus=1; + } + Int_t mpdg = fGenV0Info->GetMother().GetPdgCode(); + Float_t mass = ( pdgtable.GetParticle(mpdg)==0) ? 0 :pdgtable.GetParticle(mpdg)->Mass(); + fRecV0Info->UpdateKF(*esdvertex, + fGenV0Info->GetPlus().GetPdg(), + fGenV0Info->GetMinus().GetPdg(), + mass); + fTreeCmpV0->Fill(); + } + // + // write fake v0s + // + Int_t nV0MIs = fEvent->GetNumberOfV0s(); + for (Int_t i=0;iGetV0(i); + if (!v0MI) continue; + fRecV0Info->Reset(); //reset all variables + // + new (fRecV0Info->fV0rec) AliV0(*v0MI); + fRecV0Info->fV0Status =-10; + fRecV0Info->fRecStatus =-2; + // + AliESDtrack * trackn = fEvent->GetTrack((v0MI->GetNindex())); + AliESDtrack * trackp = fEvent->GetTrack((v0MI->GetPindex())); + Int_t vlabeln = (trackn==0) ? -1 : trackn->GetLabel(); + Int_t vlabelp = (trackp==0) ? -1 : trackp->GetLabel(); + fRecV0Info->fLab[0]=TMath::Abs(vlabelp); + fRecV0Info->fLab[1]=TMath::Abs(vlabeln); + if (TMath::Abs(fRecV0Info->fLab[0] - fRecV0Info->fLab[1])<2) continue; + AliESDRecInfo* fRecInfo1 = (AliESDRecInfo*)fRecArray->At(TMath::Abs(vlabeln)); + AliESDRecInfo* fRecInfo2 = (AliESDRecInfo*)fRecArray->At(TMath::Abs(vlabelp)); + if (fRecInfo1 && fRecInfo2){ + fRecV0Info->fT1 = (*fRecInfo1); + fRecV0Info->fT2 = (*fRecInfo2); + fRecV0Info->fRecStatus =-1; + } + fRecV0Info->Update(vertex); + fRecV0Info->UpdateKF(*esdvertex,211,211,0.49767); + fTreeCmpV0->Fill(); + } + } + + + + fTreeCmpV0->AutoSave(); + printf("Time spended in BuilV0Info Loop\n"); + timer.Print(); + if (fDebug > 2) cerr<<"end of BuildV0Info Loop"< +#include +#include +#include +#include +#include + +// ALIROOT includes +#include +#include +#include +#include "AliStack.h" +#include "AliMCEvent.h" +#include "AliMCEventHandler.h" +#include "AliMathBase.h" + +#include +#include "AliExternalTrackParam.h" +#include "AliTracker.h" +#include "AliTPCseed.h" +// +#include "AliTPCComparisonPID.h" +// +#include + +// + +// STL includes +#include + +using namespace std; + +ClassImp(AliTPCComparisonPID) + +//________________________________________________________________________ +AliTPCComparisonPID::AliTPCComparisonPID() : + AliAnalysisTask(), + fMCinfo(0), //! MC event handler + fESD(0), + fTPCsignal(0), + fTPCsignalNorm(0), + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(0), + fDebugOutputPath() +{ + // + // Default constructor (should not be used) + // +} + +AliTPCComparisonPID::AliTPCComparisonPID(const AliTPCComparisonPID& info) : + AliAnalysisTask(info), + fMCinfo(info.fMCinfo), //! MC event handler + fESD(info.fESD), //! + fTPCsignal(0), + fTPCsignalNorm(0), + // + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(), + fDebugOutputPath() +{ + // + // Dummy Copy constructor - no copy constructor for THnSparse + // +} + + + +//________________________________________________________________________ +AliTPCComparisonPID::AliTPCComparisonPID(const char *name) : + AliAnalysisTask(name, "AliTPCComparisonPID"), + fMCinfo(0), //! MC event handler + fESD(0), + fTPCsignal(0), + fTPCsignalNorm(0), + fDebugStreamer(0), + fStreamLevel(0), + fDebugLevel(0), + fDebugOutputPath() +{ + // + // Normal constructor + // + // Input slot #0 works with a TChain + DefineInput(0, TChain::Class()); + // Output slot #0 writes into a TList + DefineOutput(0, AliTPCComparisonPID::Class()); + // + //make histos + Init(); +} + +void AliTPCComparisonPID::Init(){ + // + // Init dEdx histogram + // Dimensions + // 0 - particle specie as defined in the AliPID - negatives+5 <0,9> + // 1 - momenta - at the entrance of the TPC + // 2 - tan lambda- fP[3] + // 3 - betagamma + // 4 - measurement - dEdx or dEdx/BB + // + Double_t xmin[5], xmax[5]; + Int_t nbins[5]; + // pid + nbins[0]=10; + xmin[0]=0; xmax[0]=10; + // momenta + nbins[1]=30; + xmin[1]=0.1; xmax[1]=3; + //P3 + nbins[2]=20; + xmin[2]=-1.5; xmax[2]=1.5; + // + // log (betagamma) + // + nbins[3]=50; + xmin[3]=0.1; xmax[3]=100; + // + // + nbins[4]=400; + xmin[4]=20; xmax[4]=400; + fTPCsignal = new THnSparseF("TPC signal","TPC signal",5,nbins,xmin,xmax); + nbins[4]=100; + xmin[4]=25; xmax[4]=75; + fTPCsignal = new THnSparseF("TPC signal Norm","TPC signal Norm",5,nbins,xmin,xmax); + // +} + + + + + +AliTPCComparisonPID::~AliTPCComparisonPID(){ + // + // + // + if (fDebugLevel>0) printf("AliTPCComparisonPID::~AliTPCComparisonPID\n"); + if (fDebugStreamer) delete fDebugStreamer; + fDebugStreamer=0; + delete fTPCsignal; + delete fTPCsignalNorm; +} + + +//________________________________________________________________________ +void AliTPCComparisonPID::ConnectInputData(Option_t *) +{ + // + // Connect the input data + // + if(fDebugLevel>3) + cout << "AnalysisTaskTPCCluster::ConnectInputData()" << endl; + + TTree* tree=dynamic_cast(GetInputData(0)); + if (!tree) { + //Printf("ERROR: Could not read chain from input slot 0"); + } + else { + AliESDInputHandler *esdH = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if (!esdH) { + //Printf("ERROR: Could not get ESDInputHandler"); + } + else { + fESD = esdH->GetEvent(); + //Printf("*** CONNECTED NEW EVENT ****"); + } + } + AliMCEventHandler* mcinfo = (AliMCEventHandler*) (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); + mcinfo->SetReadTR(kTRUE); + + fMCinfo = mcinfo->MCEvent(); + + +} + + + + + + +//________________________________________________________________________ +void AliTPCComparisonPID::CreateOutputObjects() +{ + // + // Connect the output objects + // + if(fDebugLevel>3) + cout << "AnalysisTaskTPCCluster::CreateOutputObjects()" << endl; + +} + + +//________________________________________________________________________ +void AliTPCComparisonPID::Exec(Option_t *) { + // + // Execute analysis for current event + // + + if(fDebugLevel>3) + cout << "AliTPCComparisonPID::Exec()" << endl; + + + // If MC has been connected + + if (!fMCinfo){ + cout << "Not MC info\n" << endl; + }else{ + ProcessMCInfo(); + //mcinfo->Print(); + //DumpInfo(); + } + // + PostData(0, this); +} + + + + +//________________________________________________________________________ +void AliTPCComparisonPID::Terminate(Option_t *) { + // + // Terminate loop + // + if(fDebugLevel>3) + printf("AliTPCComparisonPID: Terminate() \n"); + // + if (fDebugLevel>0) printf("AliMCtrackingTestTask::Terminate\n"); + if (fDebugStreamer) delete fDebugStreamer; + fDebugStreamer = 0; + return; +} + + + +TTreeSRedirector *AliTPCComparisonPID::GetDebugStreamer(){ + // + // Get Debug streamer + // In case debug streamer not yet initialized and StreamLevel>0 create new one + // + if (fStreamLevel==0) return 0; + if (fDebugStreamer) return fDebugStreamer; + TString dsName; + dsName=GetName(); + dsName+="Debug.root"; + dsName.ReplaceAll(" ",""); + fDebugStreamer = new TTreeSRedirector(dsName.Data()); + return fDebugStreamer; +} + + + + +void AliTPCComparisonPID::ProcessMCInfo(){ + // + // + // + // + Int_t npart = fMCinfo->GetNumberOfTracks(); + Int_t ntracks = fESD->GetNumberOfTracks(); + if (npart<=0) return; + if (ntracks<=0) return; + // + // + TParticle * particle= new TParticle; + TClonesArray * trefs = new TClonesArray("AliTrackReference"); + + for (Int_t itrack=0;itrackGetTrack(itrack); + const AliExternalTrackParam *in=track->GetInnerParam(); + if (!in) continue; + Int_t ipart = TMath::Abs(track->GetLabel()); + // + Int_t status = fMCinfo->GetParticleAndTR(ipart, particle, trefs); + if (status<0) continue; + if (!particle) continue; + if (!trefs) continue; + // + // + Double_t mom = in->GetP(); + Double_t dedx=track->GetTPCsignal(); + Double_t mass = particle->GetMass(); + Double_t bg =mom/mass; + Double_t betheBloch = AliMathBase::BetheBlochAleph(bg); + // + // Fill histos + // + Double_t x[5]; + //PID + Int_t pdg = particle->GetPdgCode(); + for (Int_t iType=0;iType<5;iType++) { + if (AliPID::ParticleCode(iType)==TMath::Abs(pdg)){ + x[0]=iType; + if (pdg<0) x[0]+=5; + } + } + x[1]= mom; + x[2]= track->GetTgl(); + x[3]= TMath::Log(bg); + x[4]= dedx; + fTPCsignal->Fill(x); + x[4]=dedx/betheBloch; + fTPCsignalNorm->Fill(x); + } +} + + + + +void AliTPCComparisonPID::FinishTaskOutput() +{ + // + // According description in AliAnalisysTask this method is call + // on the slaves before sending data + // + Terminate("slave"); + gSystem->Exec("pwd"); + RegisterDebugOutput(); + +} + + +void AliTPCComparisonPID::RegisterDebugOutput(){ + // + // + // + // + // store - copy debug output to the destination position + // currently ONLY for local copy + TString dsName; + dsName=GetName(); + dsName+="Debug.root"; + dsName.ReplaceAll(" ",""); + TString dsName2=fDebugOutputPath.Data(); + gSystem->MakeDirectory(dsName2.Data()); + dsName2+=gSystem->HostName(); + gSystem->MakeDirectory(dsName2.Data()); + dsName2+="/"; + dsName2+=gSystem->BaseName(gSystem->pwd()); + dsName2+="/"; + gSystem->MakeDirectory(dsName2.Data()); + dsName2+=dsName; + AliInfo(Form("copy %s\t%s\n",dsName.Data(),dsName2.Data())); + printf("copy %s\t%s\n",dsName.Data(),dsName2.Data()); + TFile::Cp(dsName.Data(),dsName2.Data()); +} diff --git a/PWG1/TPC/AliTPCComparisonPID.h b/PWG1/TPC/AliTPCComparisonPID.h new file mode 100644 index 00000000000..9df34b72e87 --- /dev/null +++ b/PWG1/TPC/AliTPCComparisonPID.h @@ -0,0 +1,72 @@ +#ifndef ALITPCOMPARISONPID_H +#define ALITPCOMPARISONPID_H + +// ROOT includes +#include +#include +#include + +// AliRoot includes +#include +#include +#include +#include +#include +#include +#include +class AliGenInfoMaker; +class TTreeSRedirector; +class AliMCEventHadnler; +class TParticle; +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliMCEvent; +class THnSparse; + +class AliTPCComparisonPID : public AliAnalysisTask { +public: + AliTPCComparisonPID(); + AliTPCComparisonPID(const char *name); + AliTPCComparisonPID(const AliTPCComparisonPID& info); + virtual ~AliTPCComparisonPID(); + virtual void ConnectInputData(Option_t *); + virtual void CreateOutputObjects(); + virtual void Exec(Option_t *option); + virtual void Terminate(Option_t *); + virtual void FinishTaskOutput(); + void SetDebugOuputhPath(const char * name){fDebugOutputPath=name;} + void Init(); + // + void ProcessMCInfo(); + // + THnSparse * GetTPCsignal(){return fTPCsignal;} + THnSparse * GetTPCsignalNorm(){return fTPCsignalNorm;} + // + // debug streamer part + // + TTreeSRedirector *GetDebugStreamer(); + void SetStreamLevel(Int_t streamLevel){fStreamLevel=streamLevel;} + void SetDebugLevel(Int_t level) {fDebugLevel = level;} + Int_t GetStreamLevel() const {return fStreamLevel;} + Int_t GetDebugLevel() const {return fDebugLevel;} + // +protected: + void RegisterDebugOutput(); + AliTPCComparisonPID& operator=(const AliTPCComparisonPID& /*info*/) { return *this;} + AliMCEvent * fMCinfo; //! MC event handler + AliESDEvent * fESD; //! current esd event + // + // + // + THnSparse * fTPCsignal; //raw tpc signal - dEdx + THnSparse * fTPCsignalNorm; //normalized TPC signal + // + TTreeSRedirector *fDebugStreamer; //! debug streamer + Int_t fStreamLevel; // debug stream level + Int_t fDebugLevel; // debug level + TString fDebugOutputPath; // debug output path + ClassDef(AliTPCComparisonPID, 1); // Analysis task base class for tracks +}; + +#endif diff --git a/PWG1/TPC/AliTPCtaskPID.cxx b/PWG1/TPC/AliTPCtaskPID.cxx new file mode 100644 index 00000000000..3e6f5739fef --- /dev/null +++ b/PWG1/TPC/AliTPCtaskPID.cxx @@ -0,0 +1,410 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ +// +// +// +//Task for analysis if TPC dEdx and PID information +// +//----------------------------------------------------------------------- +// Author : M.Ivanov marian.ivanov@cern.ch - +//----------------------------------------------------------------------- + + +// 3 6D histograms - THnSparse created in the task: +// TPC raw dEdx +// TPC normalized dEdx (dEdx_rec/dNdx_mc) +// TPC PID probabilities +// +// The values are binned in following variables: +// Some of them are correlated - but THnSpase handle it +// ~ 14 MBy per object needed +// +// 0 - MC particle species as defined in the AliPID - negatives+5 <0,9> +// 1 - momenta - at the entrance of the TPC +// 2 - tan lambda- fP[3] +// 3 - betagamma +// 4 - npoints +// 5 - measurement - dEdx, dEdx/BB resp. PID probability +// 6 - BB resp. rec particle + + +// +// ROOT includes +#include +#include +#include +#include +#include +#include + +// ALIROOT includes +#include +#include +#include "AliStack.h" +#include "AliMCEvent.h" +#include "AliMCEventHandler.h" +#include "AliMathBase.h" + +#include +#include "AliExternalTrackParam.h" +#include "AliTracker.h" +#include "AliTPCseed.h" +// +#include "AliTPCtaskPID.h" +// +#include + +// + +// STL includes +#include + +using namespace std; + + +ClassImp(AliTPCtaskPID) + +//________________________________________________________________________ +AliTPCtaskPID::AliTPCtaskPID() : + AliAnalysisTask(), + fMCinfo(0), //! MC event handler + fESD(0), + fList(0), + fTPCsignal(0), + fTPCsignalNorm(0), + fTPCr(0) +{ + // + // Default constructor (should not be used) + // +} + +AliTPCtaskPID::AliTPCtaskPID(const AliTPCtaskPID& info) : + AliAnalysisTask(info), + fMCinfo(info.fMCinfo), //! MC event handler + fESD(info.fESD), //! + fList(0), + fTPCsignal(0), + fTPCsignalNorm(0), + fTPCr(0) +{ + // + // Dummy Copy constructor - no copy constructor for THnSparse + // + fList = (TObjArray*)(info.fList->Clone()); +} + + + +//________________________________________________________________________ +AliTPCtaskPID::AliTPCtaskPID(const char *name) : + AliAnalysisTask(name, "AliTPCtaskPID"), + fMCinfo(0), //! MC event handler + fESD(0), + fList(0), + fTPCsignal(0), + fTPCsignalNorm(0), + fTPCr(0) +{ + // + // Normal constructor + // + // Input slot #0 works with a TChain + DefineInput(0, TChain::Class()); + // Output slot #0 writes into a TList + DefineOutput(0, TObjArray::Class()); + // + //make histos + Init(); +} + +void AliTPCtaskPID::Init(){ + // + // Init dEdx histogram + // Dimensions + // 0 - particle specie as defined in the AliPID - negatives+5 <0,9> + // 1 - momenta - at the entrance of the TPC + // 2 - tan lambda- fP[3] + // 3 - betagamma + // 4 - npoints + // 5 - measurement - dEdx or dEdx/BB + // 6 - BB + // + Double_t xmin[7], xmax[7]; + Int_t nbins[7]; + // pid + nbins[0]=10; + xmin[0]=0; xmax[0]=10; + // momenta + nbins[1]=50; + xmin[1]=0.1; xmax[1]=100; + //pseudorapidity + nbins[2]=40; + xmin[2]=-1.4; xmax[2]=1.4; + // + // betagamma + // + nbins[3]=100; + xmin[3]=0.1; xmax[3]=1000; + // + nbins[4]=11; + xmin[4] =50; xmax[4]=160; + // + // + nbins[6]=60; + xmin[6]=0.5; xmax[6]=6; + + nbins[5]=400; + xmin[5]=20; xmax[5]=400; + fTPCsignal = new THnSparseF("TPC signal","TPC signal",7,nbins,xmin,xmax); + nbins[5]=100; + xmin[5]=25; xmax[5]=75; + fTPCsignalNorm = new THnSparseF("TPC signal Norm","TPC signal Norm",7,nbins,xmin,xmax); + // + nbins[5]=256; + xmin[5]=-0.1; xmax[5]=1.1; + nbins[6]=10; + xmin[6]=0; xmax[6]=10; + fTPCr = new THnSparseF("TPC pid probability ","TPC pid probability",7,nbins,xmin,xmax); + // + // + BinLogX(fTPCsignal->GetAxis(1)); + BinLogX(fTPCsignal->GetAxis(3)); + BinLogX(fTPCsignal->GetAxis(6)); + BinLogX(fTPCsignalNorm->GetAxis(1)); + BinLogX(fTPCsignalNorm->GetAxis(3)); + BinLogX(fTPCsignalNorm->GetAxis(6)); + BinLogX(fTPCr->GetAxis(1)); + BinLogX(fTPCr->GetAxis(3)); + + char *hisAxisName[7] ={"pid","p (GeV/c)","#eta","#beta#gamma","Number of cluster","dEdx_{rec},dedx_{mc}"}; + char *hisAxisNameNorm[7] ={"pid","p (GeV/c)","#eta","#beta#gamma","Number of cluster","dEdx_{rec}/dEdx_{mc},dedx_{mc}"}; + char *hisAxisNameR[7] ={"pid","p (GeV/c)","#eta","#beta#gamma","Number of cluster","TPCr","pid2"}; + // + for (Int_t i=0;i<7;i++) { + fTPCsignal->GetAxis(i)->SetTitle(hisAxisName[i]); + fTPCsignal->GetAxis(i)->SetName(hisAxisName[i]); + fTPCsignalNorm->GetAxis(i)->SetTitle(hisAxisNameNorm[i]); + fTPCsignalNorm->GetAxis(i)->SetName(hisAxisNameNorm[i]); + fTPCr->GetAxis(i)->SetTitle(hisAxisNameR[i]); + fTPCr->GetAxis(i)->SetName(hisAxisNameR[i]); + } + + fList = new TObjArray(3); + fList->AddAt(fTPCsignal,0); + fList->AddAt(fTPCsignalNorm,1); + fList->AddAt(fTPCr,2); +} + + + + +AliTPCtaskPID::~AliTPCtaskPID(){ + // + // + // + delete fTPCsignal; + delete fTPCsignalNorm; + delete fTPCr; +} + + +//________________________________________________________________________ +void AliTPCtaskPID::ConnectInputData(Option_t *) +{ + // + // Connect the input data + // + + TTree* tree=dynamic_cast(GetInputData(0)); + if (!tree) { + //Printf("ERROR: Could not read chain from input slot 0"); + } + else { + AliESDInputHandler *esdH = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if (!esdH) { + //Printf("ERROR: Could not get ESDInputHandler"); + } + else { + fESD = esdH->GetEvent(); + //Printf("*** CONNECTED NEW EVENT ****"); + } + } + AliMCEventHandler* mcinfo = (AliMCEventHandler*) (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); + mcinfo->SetReadTR(kTRUE); + + fMCinfo = mcinfo->MCEvent(); + + +} + + + + + + +//________________________________________________________________________ +void AliTPCtaskPID::CreateOutputObjects() +{ + // + // Connect the output objects + // + +} + + +//________________________________________________________________________ +void AliTPCtaskPID::Exec(Option_t *) { + // + // Execute analysis for current event + // + + + // If MC has been connected + + if (!fMCinfo){ + cout << "Not MC info\n" << endl; + }else{ + ProcessMCInfo(); + //mcinfo->Print(); + //DumpInfo(); + } + // + PostData(0, fList); +} + + + + +//________________________________________________________________________ +void AliTPCtaskPID::Terminate(Option_t *) { + // + // Terminate loop + // + // + return; +} + + + + + + + +void AliTPCtaskPID::ProcessMCInfo(){ + // + // + // + // + + if (!fTPCsignal) Init(); + Int_t npart = fMCinfo->GetNumberOfTracks(); + Int_t ntracks = fESD->GetNumberOfTracks(); + if (npart<=0) return; + if (ntracks<=0) return; + // + // + TParticle * particle= new TParticle; + TClonesArray * trefs = new TClonesArray("AliTrackReference"); + + for (Int_t itrack=0;itrackGetTrack(itrack); + const AliExternalTrackParam *in=track->GetInnerParam(); + const AliExternalTrackParam *out=track->GetOuterParam(); + if (!in) continue; + Int_t ipart = TMath::Abs(track->GetLabel()); + // + Int_t status = fMCinfo->GetParticleAndTR(ipart, particle, trefs); + if (status<0) continue; + if (!particle) continue; + if (!trefs) continue; + // + // + Double_t mom = in->GetP(); + if (track->GetP()>5) mom= track->GetP(); + if (out&&out->GetX()<260&&TMath::Abs(out->GetZ())<250) mom= (in->GetP()+out->GetP())*0.5; + // + Double_t dedx=track->GetTPCsignal(); + Double_t mass = particle->GetMass(); + Double_t bg =mom/mass; + Double_t betheBloch = AliMathBase::BetheBlochAleph(bg); + // + // Fill histos + // + Double_t x[5]; + //PID + Int_t pdg = particle->GetPdgCode(); + for (Int_t iType=0;iType<5;iType++) { + if (AliPID::ParticleCode(iType)==TMath::Abs(pdg)){ + x[0]=iType; + if (TDatabasePDG::Instance()->GetParticle(pdg)->Charge()<0) x[0]+=5; + } + } + x[1]= mom; + x[2]= -0.5*TMath::Log((track->P()+track->Pz())/(track->P()-track->Pz())); + x[3]= bg; + x[4]=track->GetTPCsignalN(); + x[5]= dedx; + x[6]= betheBloch; + // + fTPCsignal->Fill(x); + // + x[5]=dedx/betheBloch; + fTPCsignalNorm->Fill(x); + for (Int_t ipart2=0;ipart2<5;ipart2++){ + x[6]=ipart2; + Double_t tpcpid[AliPID::kSPECIES]; + track->GetTPCpid(tpcpid); + x[5]=tpcpid[ipart2]; + fTPCr->Fill(x); + } + } +} + + + + +void AliTPCtaskPID::FinishTaskOutput() +{ + // + // According description in AliAnalisysTask this method is call + // on the slaves before sending data + // + Terminate("slave"); + gSystem->Exec("pwd"); +} + + + + +void AliTPCtaskPID::BinLogX(TAxis *axis) { + // + // + // + Int_t bins = axis->GetNbins(); + + Double_t from = axis->GetXmin(); + Double_t to = axis->GetXmax(); + Double_t *new_bins = new Double_t[bins + 1]; + + new_bins[0] = from; + Double_t factor = pow(to/from, 1./bins); + + for (Int_t i = 1; i <= bins; i++) { + new_bins[i] = factor * new_bins[i-1]; + } + axis->Set(bins, new_bins); + delete new_bins; +} diff --git a/PWG1/TPC/AliTPCtaskPID.h b/PWG1/TPC/AliTPCtaskPID.h new file mode 100644 index 00000000000..f45a0d1aec7 --- /dev/null +++ b/PWG1/TPC/AliTPCtaskPID.h @@ -0,0 +1,61 @@ +#ifndef ALITPCTASKPID_H +#define ALITPCTASKPID_H + +// ROOT includes +#include +#include +#include + +// AliRoot includes +#include +#include +#include +#include +#include +#include +#include +class AliMCEventHadnler; +class TParticle; +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliMCEvent; +class THnSparse; +class TObjArray; + +class AliTPCtaskPID : public AliAnalysisTask { +public: + AliTPCtaskPID(); + AliTPCtaskPID(const char *name); + AliTPCtaskPID(const AliTPCtaskPID& info); + virtual ~AliTPCtaskPID(); + virtual void ConnectInputData(Option_t *); + virtual void CreateOutputObjects(); + virtual void Exec(Option_t *option); + virtual void Terminate(Option_t *); + virtual void FinishTaskOutput(); + void Init(); + // + void ProcessMCInfo(); + // + THnSparse * GetTPCsignal(){return fTPCsignal;} + THnSparse * GetTPCsignalNorm(){return fTPCsignalNorm;} + THnSparse * GetTPCr(){return fTPCr;} + // + static void BinLogX(TAxis *axis); +protected: + void RegisterDebugOutput(); + AliTPCtaskPID& operator=(const AliTPCtaskPID& /*info*/) { return *this;} + AliMCEvent * fMCinfo; //! MC event handler + AliESDEvent * fESD; //! current esd event + // + // + // + TObjArray *fList; //TList output object + THnSparse * fTPCsignal; //raw tpc signal - dEdx + THnSparse * fTPCsignalNorm; //normalized TPC signal + THnSparse * fTPCr; //TPC pid info from ESD + ClassDef(AliTPCtaskPID, 1); // Analysis task base class for tracks +}; + +#endif diff --git a/PWG1/TPC/AliTPCtaskQA.cxx b/PWG1/TPC/AliTPCtaskQA.cxx new file mode 100644 index 00000000000..b4e5d0c64e3 --- /dev/null +++ b/PWG1/TPC/AliTPCtaskQA.cxx @@ -0,0 +1,349 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ +// +// +// +//Task for analysis if TPC base QA + +// QA histogram +// Dimensions +// 0 - chi2 +// 1 - number of clusters +// 2 - number of findable clusters +// 3 - number of clusters/ findable clusters +// 4 - pt - at the entrance of the TPC +// 5 - eta - at the entrance of the TPC +// 6 - phi - at the entrance of the TPC + +//----------------------------------------------------------------------- +// Author : M.Ivanov marian.ivanov@cern.ch - +//----------------------------------------------------------------------- + + + +// +// ROOT includes +#include +#include +#include +#include +#include +#include + +// ALIROOT includes +#include +#include +#include "AliStack.h" +#include "AliMCEvent.h" +#include "AliMCEventHandler.h" +#include "AliMathBase.h" + +#include +#include "AliExternalTrackParam.h" +#include "AliTracker.h" +#include "AliTPCseed.h" +// +#include "AliTPCtaskQA.h" +// +#include + +// + +// STL includes +#include + +using namespace std; + + +ClassImp(AliTPCtaskQA) + +//________________________________________________________________________ +AliTPCtaskQA::AliTPCtaskQA() : + AliAnalysisTask(), + fMCinfo(0), //! MC event handler + fESD(0), + fList(0), + fTPCqa(0) +{ + // + // Default constructor (should not be used) + // +} + +AliTPCtaskQA::AliTPCtaskQA(const AliTPCtaskQA& info) : + AliAnalysisTask(info), + fMCinfo(info.fMCinfo), //! MC event handler + fESD(info.fESD), //! + fList(0), + fTPCqa(0) +{ + // + // Dummy Copy constructor - no copy constructor for THnSparse + // + fList = (TObjArray*)(info.fList->Clone()); +} + + + +//________________________________________________________________________ +AliTPCtaskQA::AliTPCtaskQA(const char *name) : + AliAnalysisTask(name, "AliTPCtaskQA"), + fMCinfo(0), //! MC event handler + fESD(0), + fList(0), + fTPCqa(0) +{ + // + // Normal constructor + // + // Input slot #0 works with a TChain + DefineInput(0, TChain::Class()); + // Output slot #0 writes into a TList + DefineOutput(0, TObjArray::Class()); + // + //make histos + Init(); +} + +void AliTPCtaskQA::Init(){ + // + // Init qa histogram + // Dimensions + // + // 0 - chi2 + // 1 - number of clusters + // 2 - number of findable clusters + // 3 - number of clusters/ findable clusters + // 4 - pt - at the entrance of the TPC + // 5 - eta - at the entrance of the TPC + // 6 - phi - at the entrance of the TPC + + + + Double_t xmin[7], xmax[7]; + Int_t nbins[7]; + // + nbins[0]=100; // chi2 + xmin[0]=0; xmax[0]=10; + // + nbins[1]=80; // ncls + xmin[1]=0; xmax[1]=160; + // + nbins[2]=80; // nclsf + xmin[2]=0; xmax[2]=160; + // + nbins[3]=40; // ncls/nclsf + xmin[3] =-0.1; xmax[3]=1.1; + // + nbins[4]=50; // pt + xmin[4] =0.1; xmax[4]=100; + + nbins[5]=40; // eta + xmin[5] =-2; xmax[5]=2; + + nbins[6]= 360; // phi - 10 bins per sector + xmin[6] = -TMath::Pi(); xmax[6]=TMath::Pi(); + + + + fTPCqa = new THnSparseS("TPC qa","TPC qa",7,nbins,xmin,xmax); + // + // + BinLogX(fTPCqa->GetAxis(4)); + + char *hisAxisName[7] ={"chi2/N_{cl}","N_{cl}","N_{clF}","N_{clR}","p_{t}","#eta","#phi"}; + // + for (Int_t i=0;i<7;i++) { + fTPCqa->GetAxis(i)->SetTitle(hisAxisName[i]); + fTPCqa->GetAxis(i)->SetName(hisAxisName[i]); + } + fList = new TObjArray(3); + fList->AddAt(fTPCqa,0); +} + + + + +AliTPCtaskQA::~AliTPCtaskQA(){ + // + // + // + delete fTPCqa; +} + + +//________________________________________________________________________ +void AliTPCtaskQA::ConnectInputData(Option_t *) +{ + // + // Connect the input data + // + + TTree* tree=dynamic_cast(GetInputData(0)); + if (!tree) { + //Printf("ERROR: Could not read chain from input slot 0"); + } + else { + AliESDInputHandler *esdH = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if (!esdH) { + //Printf("ERROR: Could not get ESDInputHandler"); + } + else { + fESD = esdH->GetEvent(); + //Printf("*** CONNECTED NEW EVENT ****"); + } + } + AliMCEventHandler* mcinfo = (AliMCEventHandler*) (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); + mcinfo->SetReadTR(kTRUE); + + fMCinfo = mcinfo->MCEvent(); + + +} + + + + + + +//________________________________________________________________________ +void AliTPCtaskQA::CreateOutputObjects() +{ + // + // Connect the output objects + // + +} + + +//________________________________________________________________________ +void AliTPCtaskQA::Exec(Option_t *) { + // + // Execute analysis for current event + // + + + // If MC has been connected + + if (!fMCinfo){ + cout << "Not MC info\n" << endl; + }else{ + ProcessMCInfo(); + } + // + PostData(0, fList); +} + + + + + + + + + + +void AliTPCtaskQA::ProcessMCInfo(){ + // + // + // + // + + if (!fTPCqa) Init(); + Int_t npart = fMCinfo->GetNumberOfTracks(); + Int_t ntracks = fESD->GetNumberOfTracks(); + if (npart<=0) return; + if (ntracks<=0) return; + // + // + TParticle * particle= new TParticle; + TClonesArray * trefs = new TClonesArray("AliTrackReference"); + + for (Int_t itrack=0;itrackGetTrack(itrack); + // + if ((track->GetStatus()&AliESDtrack::kTPCrefit)==0) continue; // only refited tracks + Int_t ipart = TMath::Abs(track->GetLabel()); + // + Int_t status = fMCinfo->GetParticleAndTR(ipart, particle, trefs); + if (status<0) continue; + if (!particle) continue; + if (!trefs) continue; + // + // + AliTrackReference *tpcRef=0; + for (Int_t iref=0; irefGetEntries(); iref++){ + AliTrackReference *ref = (AliTrackReference*)trefs->At(iref); + if (ref->DetectorId()== AliTrackReference::kTPC){ + tpcRef=ref; + break; + } + } + if (!tpcRef) continue; + + // + // Fill histos + // + Double_t x[7]; + x[0]= track->GetTPCchi2()/track->GetTPCNcls(); + x[1]= track->GetTPCNcls(); + x[2]= track->GetTPCNclsF(); + x[3]= Float_t(track->GetTPCNcls())/Float_t(track->GetTPCNclsF()); + x[4]= tpcRef->Pt(); + x[5]= -0.5*TMath::Log((tpcRef->P()+tpcRef->Pz())/(tpcRef->P()-tpcRef->Pz())); + x[6]= TMath::ATan2(tpcRef->Y(),tpcRef->X()); + // + fTPCqa->Fill(x); + } +} + + + + + + +void AliTPCtaskQA::BinLogX(TAxis *axis) { + // + // + // + Int_t bins = axis->GetNbins(); + + Double_t from = axis->GetXmin(); + Double_t to = axis->GetXmax(); + Double_t *new_bins = new Double_t[bins + 1]; + + new_bins[0] = from; + Double_t factor = pow(to/from, 1./bins); + + for (Int_t i = 1; i <= bins; i++) { + new_bins[i] = factor * new_bins[i-1]; + } + axis->Set(bins, new_bins); + delete new_bins; +} + + +AliTPCtaskQA* AliTPCtaskQA::ReadFromFile(const char *fname){ + // + // + // + AliTPCtaskQA *qa = new AliTPCtaskQA; + TFile *f = new TFile(fname); + TObjArray *array= (TObjArray*)f->Get("tpcTaskQA"); + qa->fTPCqa = (THnSparse*)array->At(0); + delete f; + return qa; +} + diff --git a/PWG1/TPC/AliTPCtaskQA.h b/PWG1/TPC/AliTPCtaskQA.h new file mode 100644 index 00000000000..852cc093023 --- /dev/null +++ b/PWG1/TPC/AliTPCtaskQA.h @@ -0,0 +1,56 @@ +#ifndef ALITPCTASKQA_H +#define ALITPCTASKQA_H + +// ROOT includes +#include +#include +#include + +// AliRoot includes +#include +#include +#include +#include +#include +#include +#include +class AliMCEventHadnler; +class TParticle; +class AliMCInfo; +class AliESDRecInfo; +class AliESDEvent; +class AliMCEvent; +class THnSparse; +class TObjArray; +class TClonesArray; + +class AliTPCtaskQA : public AliAnalysisTask { +public: + AliTPCtaskQA(); + AliTPCtaskQA(const char *name); + AliTPCtaskQA(const AliTPCtaskQA& info); + virtual ~AliTPCtaskQA(); + virtual void ConnectInputData(Option_t *); + virtual void CreateOutputObjects(); + virtual void Exec(Option_t *option); + void Init(); + // + void ProcessMCInfo(); + // + THnSparse * GetTPCqa(){return fTPCqa;} + static AliTPCtaskQA* ReadFromFile(const char *fname="OutputPID.root"); + // + static void BinLogX(TAxis *axis); +protected: + AliTPCtaskQA& operator=(const AliTPCtaskQA& /*info*/) { return *this;} + AliMCEvent * fMCinfo; //! MC event handler + AliESDEvent * fESD; //! current esd event + // + // + // + TObjArray *fList; //TList output object + THnSparse * fTPCqa; //raw tpc QA + ClassDef(AliTPCtaskQA, 1); // Analysis task base class for tracks +}; + +#endif diff --git a/PWG1/TPC/AliTreeDraw.cxx b/PWG1/TPC/AliTreeDraw.cxx new file mode 100644 index 00000000000..f282253decb --- /dev/null +++ b/PWG1/TPC/AliTreeDraw.cxx @@ -0,0 +1,659 @@ +/************************************************************************** + * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * * + * Author: The ALICE Off-line Project. * + * Contributors are mentioned in the code where appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + + +/////////////////////////////////////////////////////////////////////////// +/* + +Origin: marian.ivanov@cern.ch +Frequenlty used function for visualization +marian.ivanov@cern.ch +*/ + +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +#include +//ROOT includes +#include "TROOT.h" +#include "Rtypes.h" +#include "TFile.h" +#include "TTree.h" +#include "TChain.h" +#include "TCut.h" +#include "TString.h" +#include "TBenchmark.h" +#include "TStopwatch.h" +#include "TParticle.h" +#include "TSystem.h" +#include "TTimer.h" +#include "TVector3.h" +#include "TH1F.h" +#include "TH2F.h" +#include "TCanvas.h" +#include "TPad.h" +#include "TF1.h" +#include "TView.h" +#include "TView3D.h" +#include "TPolyLine3D.h" +#include "TPolyMarker3D.h" +#include "TObjString.h" + + +//ALIROOT includes +#include "AliTrackPointArray.h" +#include "AliTreeDraw.h" + +#endif + +// +// Class for visualization and some statistacal analysis using tree +// To be used in comparisons +// and calib viewers based on tree + + +ClassImp(AliTreeDraw) + + +AliTreeDraw::AliTreeDraw(): + fTree(0), + fRes(0), + fMean(0), + fPoints(0){ + // + // default constructor + // +} + +void AliTreeDraw::ClearHisto(){ + // + // + delete fRes; + delete fMean; + fRes=0; + fMean=0; +} + + + +TH1F * AliTreeDraw::DrawXY(const char * chx, const char *chy, const char* selection, + const char * quality, Int_t nbins, Float_t minx, Float_t maxx, Float_t miny, Float_t maxy, Int_t nBinsRes) +{ + // + Double_t* bins = CreateLogBins(nbins, minx, maxx); + TH2F* hRes2 = new TH2F("hRes2", "residuals", nbins, minx, maxx, nBinsRes, miny, maxy); + char cut[1000]; + sprintf(cut,"%s&&%s",selection,quality); + char expression[1000]; + sprintf(expression,"%s:%s>>hRes2",chy,chx); + fTree->Draw(expression, cut, "groff"); + TH1F* hMean=0; + TH1F* hRes = CreateResHisto(hRes2, &hMean); + AliLabelAxes(hRes, chx, chy); + // + delete hRes2; + delete[] bins; + ClearHisto(); + fRes = hRes; + fMean = hMean; + return hRes; +} + + + +TH1F * AliTreeDraw::DrawLogXY(const char * chx, const char *chy, const char* selection, + const char * quality, Int_t nbins, Float_t minx, Float_t maxx, Float_t miny, Float_t maxy, Int_t nBinsRes) +{ + // + // + // + Double_t* bins = CreateLogBins(nbins, minx, maxx); + TH2F* hRes2 = new TH2F("hRes2", "residuals", nbins, bins, nBinsRes, miny, maxy); + char cut[1000]; + sprintf(cut,"%s&&%s",selection,quality); + char expression[1000]; + sprintf(expression,"%s:%s>>hRes2",chy,chx); + fTree->Draw(expression, cut, "groff"); + TH1F* hMean=0; + TH1F* hRes = CreateResHisto(hRes2, &hMean); + AliLabelAxes(hRes, chx, chy); + // + delete hRes2; + delete[] bins; + ClearHisto(); + fRes = hRes; + fMean = hMean; + return hRes; +} + +/////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////////// +TH1F * AliTreeDraw::Eff(const char *variable, const char* selection, const char * quality, + Int_t nbins, Float_t min, Float_t max) +{ + // + // + TH1F* hGen = new TH1F("hGen", "gen. tracks", nbins, min, max); + TH1F* hRec = new TH1F("hRec", "rec. tracks", nbins, min, max); + char inputGen[1000]; + sprintf(inputGen,"%s>>hGen", variable); + fTree->Draw(inputGen, selection, "groff"); + char selectionRec[256]; + sprintf(selectionRec, "%s && %s", selection, quality); + char inputRec[1000]; + sprintf(inputRec,"%s>>hRec", variable); + fTree->Draw(inputRec, selectionRec, "groff"); + // + TH1F* hEff = CreateEffHisto(hGen, hRec); + AliLabelAxes(hEff, variable, "#epsilon [%]"); + fRes = hEff; + delete hRec; + delete hGen; + return hEff; +} + + + +/////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////////// +TH1F * AliTreeDraw::EffLog(const char *variable, const char* selection, const char * quality, + Int_t nbins, Float_t min, Float_t max) +{ + // + // + Double_t* bins = CreateLogBins(nbins, min, max); + TH1F* hGen = new TH1F("hGen", "gen. tracks", nbins, bins); + TH1F* hRec = new TH1F("hRec", "rec. tracks", nbins, bins); + char inputGen[1000]; + sprintf(inputGen,"%s>>hGen", variable); + fTree->Draw(inputGen, selection, "groff"); + char selectionRec[256]; + sprintf(selectionRec, "%s && %s", selection, quality); + char inputRec[1000]; + sprintf(inputRec,"%s>>hRec", variable); + fTree->Draw(inputRec, selectionRec, "groff"); + // + TH1F* hEff = CreateEffHisto(hGen, hRec); + AliLabelAxes(hEff, variable, "#epsilon [%]"); + fRes = hEff; + delete hRec; + delete hGen; + delete[] bins; + return hEff; +} + + +/////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////////// + +Double_t* AliTreeDraw::CreateLogBins(Int_t nBins, Double_t xMin, Double_t xMax) +{ + Double_t* bins = new Double_t[nBins+1]; + bins[0] = xMin; + Double_t factor = pow(xMax/xMin, 1./nBins); + for (Int_t i = 1; i <= nBins; i++) + bins[i] = factor * bins[i-1]; + return bins; +} + + + + +void AliTreeDraw::AliLabelAxes(TH1* histo, const char* xAxisTitle, const char* yAxisTitle) +{ + // + histo->GetXaxis()->SetTitle(xAxisTitle); + histo->GetYaxis()->SetTitle(yAxisTitle); +} + + +TH1F* AliTreeDraw::CreateEffHisto(TH1F* hGen, TH1F* hRec) +{ + // + Int_t nBins = hGen->GetNbinsX(); + TH1F* hEff = (TH1F*) hGen->Clone("hEff"); + hEff->SetTitle(""); + hEff->SetStats(kFALSE); + hEff->SetMinimum(0.); + hEff->SetMaximum(110.); + // + for (Int_t iBin = 0; iBin <= nBins; iBin++) { + Double_t nGen = hGen->GetBinContent(iBin); + Double_t nRec = hRec->GetBinContent(iBin); + if (nGen > 0) { + Double_t eff = nRec/nGen; + hEff->SetBinContent(iBin, 100. * eff); + Double_t error = sqrt((eff*(1.-eff)+0.01) / nGen); + // if (error == 0) error = sqrt(0.1/nGen); + // + if (error == 0) error = 0.0001; + hEff->SetBinError(iBin, 100. * error); + } else { + hEff->SetBinContent(iBin, 100. * 0.5); + hEff->SetBinError(iBin, 100. * 0.5); + } + } + return hEff; +} + + + +TH1F* AliTreeDraw::CreateResHisto(TH2F* hRes2, TH1F **phMean, Bool_t drawBinFits, + Bool_t overflowBinFits) +{ + TVirtualPad* currentPad = gPad; + TAxis* axis = hRes2->GetXaxis(); + Int_t nBins = axis->GetNbins(); + TH1F* hRes, *hMean; + if (axis->GetXbins()->GetSize()){ + hRes = new TH1F("hRes", "", nBins, axis->GetXbins()->GetArray()); + hMean = new TH1F("hMean", "", nBins, axis->GetXbins()->GetArray()); + } + else{ + hRes = new TH1F("hRes", "", nBins, axis->GetXmin(), axis->GetXmax()); + hMean = new TH1F("hMean", "", nBins, axis->GetXmin(), axis->GetXmax()); + + } + hRes->SetStats(false); + hRes->SetOption("E"); + hRes->SetMinimum(0.); + // + hMean->SetStats(false); + hMean->SetOption("E"); + + // create the fit function + TF1 * fitFunc = new TF1("G","[0]*exp(-(x-[1])*(x-[1])/(2.*[2]*[2]))",-3,3); + + fitFunc->SetLineWidth(2); + fitFunc->SetFillStyle(0); + // create canvas for fits + TCanvas* canBinFits = NULL; + Int_t nPads = (overflowBinFits) ? nBins+2 : nBins; + Int_t nx = Int_t(sqrt(nPads-1.));// + 1; + Int_t ny = (nPads-1) / nx + 1; + if (drawBinFits) { + canBinFits = (TCanvas*)gROOT->FindObject("canBinFits"); + if (canBinFits) delete canBinFits; + canBinFits = new TCanvas("canBinFits", "fits of bins", 200, 100, 500, 700); + canBinFits->Divide(nx, ny); + } + + // loop over x bins and fit projection + Int_t dBin = ((overflowBinFits) ? 1 : 0); + for (Int_t bin = 1-dBin; bin <= nBins+dBin; bin++) { + if (drawBinFits) canBinFits->cd(bin + dBin); + TH1D* hBin = hRes2->ProjectionY("hBin", bin, bin); + // + if (hBin->GetEntries() > 5) { + fitFunc->SetParameters(hBin->GetMaximum(),hBin->GetMean(),hBin->GetRMS()); + hBin->Fit(fitFunc,"s"); + Double_t sigma = TMath::Abs(fitFunc->GetParameter(2)); + + if (sigma > 0.){ + hRes->SetBinContent(bin, TMath::Abs(fitFunc->GetParameter(2))); + hMean->SetBinContent(bin, fitFunc->GetParameter(1)); + } + else{ + hRes->SetBinContent(bin, 0.); + hMean->SetBinContent(bin,0); + } + hRes->SetBinError(bin, fitFunc->GetParError(2)); + hMean->SetBinError(bin, fitFunc->GetParError(1)); + + // + // + + } else { + hRes->SetBinContent(bin, 0.); + hRes->SetBinError(bin, 0.); + hMean->SetBinContent(bin, 0.); + hMean->SetBinError(bin, 0.); + } + + + if (drawBinFits) { + char name[256]; + if (bin == 0) { + sprintf(name, "%s < %.4g", axis->GetTitle(), axis->GetBinUpEdge(bin)); + } else if (bin == nBins+1) { + sprintf(name, "%.4g < %s", axis->GetBinLowEdge(bin), axis->GetTitle()); + } else { + sprintf(name, "%.4g < %s < %.4g", axis->GetBinLowEdge(bin), + axis->GetTitle(), axis->GetBinUpEdge(bin)); + } + canBinFits->cd(bin + dBin); + hBin->SetTitle(name); + hBin->SetStats(kTRUE); + hBin->DrawCopy("E"); + canBinFits->Update(); + canBinFits->Modified(); + canBinFits->Update(); + } + + delete hBin; + } + + delete fitFunc; + currentPad->cd(); + *phMean = hMean; + return hRes; +} + +TH1F* AliTreeDraw::CreateResHistoI(TH2F* hRes2, TH1F **phMean, Int_t integ, Bool_t drawBinFits) +{ + TVirtualPad* currentPad = gPad; + TAxis* axis = hRes2->GetXaxis(); + Int_t nBins = axis->GetNbins(); + Bool_t overflowBinFits = kFALSE; + TH1F* hRes, *hMean; + if (axis->GetXbins()->GetSize()){ + hRes = new TH1F("hRes", "", nBins, axis->GetXbins()->GetArray()); + hMean = new TH1F("hMean", "", nBins, axis->GetXbins()->GetArray()); + } + else{ + hRes = new TH1F("hRes", "", nBins, axis->GetXmin(), axis->GetXmax()); + hMean = new TH1F("hMean", "", nBins, axis->GetXmin(), axis->GetXmax()); + + } + hRes->SetStats(false); + hRes->SetOption("E"); + hRes->SetMinimum(0.); + // + hMean->SetStats(false); + hMean->SetOption("E"); + + // create the fit function + TF1 * fitFunc = new TF1("G","[0]*exp(-(x-[1])*(x-[1])/(2.*[2]*[2]))",-3,3); + + fitFunc->SetLineWidth(2); + fitFunc->SetFillStyle(0); + // create canvas for fits + TCanvas* canBinFits = NULL; + Int_t nPads = (overflowBinFits) ? nBins+2 : nBins; + Int_t nx = Int_t(sqrt(nPads-1.));// + 1; + Int_t ny = (nPads-1) / nx + 1; + if (drawBinFits) { + canBinFits = (TCanvas*)gROOT->FindObject("canBinFits"); + if (canBinFits) delete canBinFits; + canBinFits = new TCanvas("canBinFits", "fits of bins", 200, 100, 500, 700); + canBinFits->Divide(nx, ny); + } + + // loop over x bins and fit projection + Int_t dBin = ((overflowBinFits) ? 1 : 0); + for (Int_t bin = 1-dBin; bin <= nBins+dBin; bin++) { + if (drawBinFits) canBinFits->cd(bin + dBin); + Int_t bin0=TMath::Max(bin-integ,0); + Int_t bin1=TMath::Min(bin+integ,nBins); + TH1D* hBin = hRes2->ProjectionY("hBin", bin0, bin1); + // + if (hBin->GetEntries() > 5) { + fitFunc->SetParameters(hBin->GetMaximum(),hBin->GetMean(),hBin->GetRMS()); + hBin->Fit(fitFunc,"s"); + Double_t sigma = TMath::Abs(fitFunc->GetParameter(2)); + + if (sigma > 0.){ + hRes->SetBinContent(bin, TMath::Abs(fitFunc->GetParameter(2))); + hMean->SetBinContent(bin, fitFunc->GetParameter(1)); + } + else{ + hRes->SetBinContent(bin, 0.); + hMean->SetBinContent(bin,0); + } + hRes->SetBinError(bin, fitFunc->GetParError(2)); + hMean->SetBinError(bin, fitFunc->GetParError(1)); + + // + // + + } else { + hRes->SetBinContent(bin, 0.); + hRes->SetBinError(bin, 0.); + hMean->SetBinContent(bin, 0.); + hMean->SetBinError(bin, 0.); + } + + + if (drawBinFits) { + char name[256]; + if (bin == 0) { + sprintf(name, "%s < %.4g", axis->GetTitle(), axis->GetBinUpEdge(bin)); + } else if (bin == nBins+1) { + sprintf(name, "%.4g < %s", axis->GetBinLowEdge(bin), axis->GetTitle()); + } else { + sprintf(name, "%.4g < %s < %.4g", axis->GetBinLowEdge(bin), + axis->GetTitle(), axis->GetBinUpEdge(bin)); + } + canBinFits->cd(bin + dBin); + hBin->SetTitle(name); + hBin->SetStats(kTRUE); + hBin->DrawCopy("E"); + canBinFits->Update(); + canBinFits->Modified(); + canBinFits->Update(); + } + + delete hBin; + } + + delete fitFunc; + currentPad->cd(); + *phMean = hMean; + return hRes; +} + +TH1F* AliTreeDraw::CreateResHistoII(TH2F* hRes2, TH1F **phMean, Int_t integ, Bool_t drawBinFits, Int_t cut) +{ + TVirtualPad* currentPad = gPad; + TAxis* axis = hRes2->GetXaxis(); + Int_t nBins = axis->GetNbins(); + Bool_t overflowBinFits = kFALSE; + TH1F* hRes, *hMean; + if (axis->GetXbins()->GetSize()){ + hRes = new TH1F("hRes", "", nBins, axis->GetXbins()->GetArray()); + hMean = new TH1F("hMean", "", nBins, axis->GetXbins()->GetArray()); + } + else{ + hRes = new TH1F("hRes", "", nBins, axis->GetXmin(), axis->GetXmax()); + hMean = new TH1F("hMean", "", nBins, axis->GetXmin(), axis->GetXmax()); + + } + hRes->SetStats(false); + hRes->SetOption("E"); + hRes->SetMinimum(0.); + // + hMean->SetStats(false); + hMean->SetOption("E"); + + // create the fit function + TF1 * fitFunc = new TF1("G","[0]*exp(-(x-[1])*(x-[1])/(2.*[2]*[2]))",-3,3); + + fitFunc->SetLineWidth(2); + fitFunc->SetFillStyle(0); + // create canvas for fits + TCanvas* canBinFits = NULL; + Int_t nPads = (overflowBinFits) ? nBins+2 : nBins; + Int_t nx = Int_t(sqrt(nPads-1.));// + 1; + Int_t ny = (nPads-1) / nx + 1; + if (drawBinFits) { + canBinFits = (TCanvas*)gROOT->FindObject("canBinFits"); + if (canBinFits) delete canBinFits; + canBinFits = new TCanvas("canBinFits", "fits of bins", 200, 100, 500, 700); + canBinFits->Divide(nx, ny); + } + + // loop over x bins and fit projection + Int_t dBin = ((overflowBinFits) ? 1 : 0); + for (Int_t bin = 1-dBin; bin <= nBins+dBin; bin++) { + if (drawBinFits) canBinFits->cd(bin + dBin); + Int_t bin0=TMath::Max(bin-integ,0); + Int_t bin1=TMath::Min(bin+integ,nBins); + TH1D* hBin = hRes2->ProjectionY("hBin", bin0, bin1); + // + if (hBin->GetEntries() > cut) { + fitFunc->SetParameters(hBin->GetMaximum(),hBin->GetMean(),hBin->GetRMS()); + hBin->Fit(fitFunc,"s"); + Double_t sigma = TMath::Abs(fitFunc->GetParameter(2)); + + if (sigma > 0.){ + hRes->SetBinContent(bin, TMath::Abs(fitFunc->GetParameter(2))); + hMean->SetBinContent(bin, fitFunc->GetParameter(1)); + } + else{ + hRes->SetBinContent(bin, 0.); + hMean->SetBinContent(bin,0); + } + hRes->SetBinError(bin, fitFunc->GetParError(2)); + hMean->SetBinError(bin, fitFunc->GetParError(1)); + + // + // + + } else { + hRes->SetBinContent(bin, 0.); + hRes->SetBinError(bin, 0.); + hMean->SetBinContent(bin, 0.); + hMean->SetBinError(bin, 0.); + } + + + if (drawBinFits) { + char name[256]; + if (bin == 0) { + sprintf(name, "%s < %.4g", axis->GetTitle(), axis->GetBinUpEdge(bin)); + } else if (bin == nBins+1) { + sprintf(name, "%.4g < %s", axis->GetBinLowEdge(bin), axis->GetTitle()); + } else { + sprintf(name, "%.4g < %s < %.4g", axis->GetBinLowEdge(bin), + axis->GetTitle(), axis->GetBinUpEdge(bin)); + } + canBinFits->cd(bin + dBin); + hBin->SetTitle(name); + hBin->SetStats(kTRUE); + hBin->DrawCopy("E"); + canBinFits->Update(); + canBinFits->Modified(); + canBinFits->Update(); + } + + delete hBin; + } + + delete fitFunc; + currentPad->cd(); + *phMean = hMean; + return hRes; +} + + + + +void AliTreeDraw::GetPoints3D(const char * label, const char * chpoints, + const char* selection, TTree * tpoints, Int_t color,Float_t rmin){ + // + // load selected points from tree + // + if (!fPoints) fPoints = new TObjArray; + if (tpoints->GetIndex()==0) tpoints->BuildIndex("fLabel","Label"); + TBranch * br = tpoints->GetBranch(chpoints); + if (!br) return; + AliTrackPointArray * points = new AliTrackPointArray; + br->SetAddress(&points); + + Int_t npoints = fTree->Draw(label,selection); + Float_t xyz[30000]; + rmin*=rmin; + for (Int_t ii=0;iiGetV1()[ii]; + tpoints->GetEntryWithIndex(index,index); + if (points->GetNPoints()<2) continue; + Int_t goodpoints=0; + for (Int_t i=0;iGetNPoints(); i++){ + xyz[goodpoints*3] = points->GetX()[i]; + xyz[goodpoints*3+1] = points->GetY()[i]; + xyz[goodpoints*3+2] = points->GetZ()[i]; + if ( points->GetX()[i]*points->GetX()[i]+points->GetY()[i]*points->GetY()[i]>rmin) goodpoints++; + } + TPolyMarker3D * marker = new TPolyMarker3D(goodpoints,xyz); + marker->SetMarkerColor(color); + marker->SetMarkerStyle(1); + fPoints->AddLast(marker); + } +} + + + + +TString* AliTreeDraw::FitPlane(const char* drawCommand, const char* formula, const char* cuts, Double_t & chi2, TVectorD &fitParam, TMatrixD &covMatrix, Int_t start, Int_t stop){ + // + // fit an arbitrary function, specified by formula into the data, specified by drawCommand and cuts + // returns chi2, fitParam and covMatrix + // returns TString with fitted formula + // + + TString formulaStr(formula); + TString drawStr(drawCommand); + TString cutStr(cuts); + + formulaStr.ReplaceAll("++", "~"); + TObjArray* formulaTokens = formulaStr.Tokenize("~"); + Int_t dim = formulaTokens->GetEntriesFast(); + + fitParam.ResizeTo(dim); + covMatrix.ResizeTo(dim,dim); + + TLinearFitter* fitter = new TLinearFitter(dim+1, Form("hyp%d",dim)); + fitter->StoreData(kTRUE); + fitter->ClearPoints(); + + Int_t entries = fTree->Draw(drawStr.Data(), cutStr.Data(), "goff", stop-start, start); + if (entries == -1) return new TString("An ERROR has occured during fitting!"); + Double_t **values = new Double_t*[dim+1] ; + + for (Int_t i = 0; i < dim + 1; i++){ + Int_t centries = 0; + if (i < dim) centries = fTree->Draw(((TObjString*)formulaTokens->At(i))->GetName(), cutStr.Data(), "goff", stop-start,start); + else centries = fTree->Draw(drawStr.Data(), cutStr.Data(), "goff", stop-start,start); + + if (entries != centries) return new TString("An ERROR has occured during fitting!"); + values[i] = new Double_t[entries]; + memcpy(values[i], fTree->GetV1(), entries*sizeof(Double_t)); + } + + // add points to the fitter + for (Int_t i = 0; i < entries; i++){ + Double_t x[1000]; + for (Int_t j=0; jAddPoint(x, values[dim][i], 1); + } + + fitter->Eval(); + fitter->GetParameters(fitParam); + fitter->GetCovarianceMatrix(covMatrix); + chi2 = fitter->GetChisquare(); + chi2 = chi2; + + TString *preturnFormula = new TString(Form("( %f+",fitParam[0])), &returnFormula = *preturnFormula; + + for (Int_t iparam = 0; iparam < dim; iparam++) { + returnFormula.Append(Form("%s*(%f)",((TObjString*)formulaTokens->At(iparam))->GetName(),fitParam[iparam+1])); + if (iparam < dim-1) returnFormula.Append("+"); + } + returnFormula.Append(" )"); + delete formulaTokens; + delete fitter; + delete[] values; + return preturnFormula; +} + diff --git a/PWG1/TPC/AliTreeDraw.h b/PWG1/TPC/AliTreeDraw.h new file mode 100644 index 00000000000..fbb57ee4864 --- /dev/null +++ b/PWG1/TPC/AliTreeDraw.h @@ -0,0 +1,78 @@ +#ifndef ALITREEDRAW_H +#define ALITREEDRAW_H +/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + + + +////////////////////////////////////////////////////////////////////////////// +// Class AliTreeDraw // +// // +// marian.ivanov@cern.ch // +////////////////////////////////////////////////////////////////////////////// + + + +#include +#include +#include "TLinearFitter.h" + +class TH1; +class TH1F; +class TH2F; +class TTree; +class TString; + +class AliTreeDraw: public TObject{ +public: + AliTreeDraw(); + ~AliTreeDraw(){;} + TTree * T() { return fTree;} + void SetTree(TTree *tree){fTree=tree;} + const TH1 * GetRes() const{ return (TH1*)fRes;} + const TH1 * GetMean() const{ return (TH1*)fMean;} + const TObjArray* GetPoints() const {return fPoints;} + void ClearHisto(); + void ClearPoints(){if (fPoints) fPoints->Clear();} + TString* FitPlane(const char* drawCommand, const char* formula, const char* cuts, Double_t & chi2, TVectorD &fitParam, TMatrixD &covMatrix, Int_t start=0, Int_t stop=10000000); + + + // + TH1F * DrawXY(const char * chx, const char *chy, const char* selection, + const char * quality,Int_t nbins, Float_t minx, Float_t maxx, + Float_t miny, Float_t maxy, Int_t nBinsRes=30); + TH1F * DrawLogXY(const char * chx, const char *chy, const char* selection, + const char * quality, Int_t nbins,Float_t minx, Float_t maxx, + Float_t miny, Float_t maxy, Int_t nBinsRes=30); + TH1F * Eff(const char *variable, const char* selection, const char * quality, + Int_t nbins,Float_t min, Float_t max); + TH1F * EffLog(const char *variable, const char* selection, const char * quality, + Int_t nbins,Float_t min, Float_t max); + // + void GetPoints3D(const char * label, const char * chpoints, const char* selection, TTree * tpoints, Int_t color=6, Float_t rmin=4.); + + static void AliLabelAxes(TH1* histo, const char* xAxisTitle, const char* yAxisTitle); + static Double_t* CreateLogBins(Int_t nBins, Double_t xMin, Double_t xMax); + static TH1F* CreateEffHisto(TH1F* hGen, TH1F* hRec); + static TH1F* CreateResHisto(TH2F* hRes2, TH1F **phMean, + Bool_t drawBinFits = kTRUE,Bool_t overflowBinFits = kFALSE); + + static TH1F* CreateResHistoI(TH2F* hRes2, TH1F **phMean, Int_t integ=0, + Bool_t drawBinFits = kTRUE); + static TH1F* CreateResHistoII(TH2F* hRes2, TH1F **phMean, Int_t integ=0, + Bool_t drawBinFits = kTRUE, Int_t cut=0); + + + +private: + AliTreeDraw(const AliTreeDraw& /*t*/):TObject(),fTree(0),fRes(0),fMean(0),fPoints(0){;} + AliTreeDraw & operator=(const AliTreeDraw & /*t*/){return *this;} + + TTree * fTree; //the tree for visualization - NOT OWNER + TH1F * fRes; //temporary histogram - OWNER + TH1F * fMean; //temporary histogram - OWNER + TObjArray *fPoints;// - OWNER + ClassDef(AliTreeDraw,0) +}; + +#endif -- 2.39.3