From a10ed3751c6b6f3c2c3a93e0d6b37825b888c5ef Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Mon, 14 Aug 2023 11:50:45 +0200 Subject: [PATCH 01/19] create Ptresolution, add efficiency of sec study --- .../ITS/postprocessing/studies/CMakeLists.txt | 1 + .../ITSStudies/ITSStudiesConfigParam.h | 8 + .../studies/include/ITSStudies/PtResolution.h | 39 ++ .../studies/src/ITSStudiesConfigParam.cxx | 4 + .../studies/src/ITSStudiesLinkDef.h | 2 + .../studies/src/PtResolution.cxx | 375 ++++++++++++ .../postprocessing/studies/src/TrackCheck.cxx | 567 +++++++++++++++++- .../standalone-postprocessing-workflow.cxx | 10 +- 8 files changed, 986 insertions(+), 20 deletions(-) create mode 100644 Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h create mode 100644 Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt b/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt index d1b8866c00b7a..bbe9185e255bb 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt @@ -14,6 +14,7 @@ o2_add_library(ITSPostprocessing src/AvgClusSize.cxx src/ITSStudiesConfigParam.cxx src/TrackCheck.cxx + src/PtResolution.cxx src/ITSStudiesConfigParam.cxx PUBLIC_LINK_LIBRARIES O2::GlobalTracking O2::GlobalTrackingWorkflowReaders diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h index 9a2a4838615cf..719764fc7a88c 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h @@ -31,6 +31,14 @@ struct ITSCheckTracksParamConfig : public o2::conf::ConfigurableParamHelper { + std::string outFileName = "TrackPtResStudy.root"; + unsigned short trackLengthMask = 0x7f; + + O2ParamDef(ITSPtTracksResParamConfig, "ITSPtTracksResParam"); +}; + struct ITSAvgClusSizeParamConfig : public o2::conf::ConfigurableParamHelper { // Data parameters double b = 5; // Solenoid field in kG (+/-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h new file mode 100644 index 0000000000000..d9b312dd1e264 --- /dev/null +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h @@ -0,0 +1,39 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file PtResolution.h +/// \author Roberta Ferioli roberta.ferioli@cern.ch + +#ifndef O2_PT_RESOLUTION_STUDY_H +#define O2_PT_RESOLUTION_STUDY_H + +#include +#include +#include + +namespace o2 +{ +namespace steer +{ +class MCKinematicsReader; +} +namespace its +{ +namespace study +{ +using mask_t = o2::dataformats::GlobalTrackID::mask_t; + +o2::framework::DataProcessorSpec getPtResolutionStudy(mask_t srcTracksMask, mask_t srcClustersMask, bool useMC , std::shared_ptr kineReader); +} // namespace study +} // namespace its +} // namespace o2 + +#endif // O2_PT_RESOLUTION_STUDY \ No newline at end of file diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx index fa7aeeb51797a..be5c1177fdac4 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx @@ -19,9 +19,13 @@ namespace study { static auto& sAvgClusSizeParamITS = o2::its::study::ITSAvgClusSizeParamConfig::Instance(); static auto& sCheckTracksParamsITS = o2::its::study::ITSCheckTracksParamConfig::Instance(); +static auto& sPtResParamsITS= o2::its::study::ITSPtTracksResParamConfig::Instance(); + O2ParamImpl(o2::its::study::ITSAvgClusSizeParamConfig); O2ParamImpl(o2::its::study::ITSCheckTracksParamConfig); +O2ParamImpl(o2::its::study::ITSPtTracksResParamConfig); + } // namespace study } // namespace its } // namespace o2 diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h index a0c483fb774a5..54ad18bd51a5c 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h @@ -18,5 +18,7 @@ #pragma link C++ class o2::its::study::ITSAvgClusSizeParamConfig + ; #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::study::ITSAvgClusSizeParamConfig> + ; #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::study::ITSCheckTracksParamConfig> + ; +#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::study::ITSPtTracksResParamConfig> + ; + #endif \ No newline at end of file diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx new file mode 100644 index 0000000000000..17106da79a3f9 --- /dev/null +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx @@ -0,0 +1,375 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file PtResolution.cxx.cxx +/// \brief Study on Pt resolution per track in the ITS +/// \author Roberta Ferioli roberta.ferioli@cern.ch +#include +#include "ITSStudies/ITSStudiesConfigParam.h" + +#include "DataFormatsITS/TrackITS.h" +#include "SimulationDataFormat/MCTrack.h" +#include "DataFormatsITSMFT/CompCluster.h" +#include "DataFormatsGlobalTracking/RecoContainer.h" +#include "CommonUtils/TreeStreamRedirector.h" + +#include "Framework/Task.h" +#include "Steer/MCKinematicsReader.h" +#include "ITSBase/GeometryTGeo.h" +#include "DetectorsBase/GRPGeomHelper.h" + +#include +#include +#include +#include +#include +#include +#include +#include +namespace o2 +{ +namespace its +{ +namespace study +{ +using namespace o2::framework; +using namespace o2::globaltracking; + +using GTrackID = o2::dataformats::GlobalTrackID; +using o2::steer::MCKinematicsReader; +class PtResolutionStudy : public Task +{ + struct ParticleInfo { + int event; + int pdg; + float pt; + float eta; + float phi; + int mother; + int first; + float vx; + float vy; + float vz; + unsigned short clusters = 0u; + unsigned char isReco = 0u; + unsigned char isFake = 0u; + bool isPrimary = 0u; + unsigned char storedStatus = 2; /// not stored = 2, fake = 1, good = 0 + o2::its::TrackITS track; + }; + + public: + PtResolutionStudy(std::shared_ptr dr, + mask_t src, + bool useMC, + std::shared_ptr kineReader, + std::shared_ptr gr) : mDataRequest(dr), mTracksSrc(src), mKineReader(kineReader), mGGCCDBRequest(gr) + { + if (useMC) { + LOGP(info, "Read MCKine reader with {} sources", mKineReader->getNSources()); + } + } + ~PtResolutionStudy() final = default; + void init(InitContext&) final; + void run(ProcessingContext&) final; + void endOfStream(EndOfStreamContext&) final; + void finaliseCCDB(ConcreteDataMatcher&, void*) final; + void initialiseRun(o2::globaltracking::RecoContainer&); + void process(); + + private: + void updateTimeDependentParams(ProcessingContext& pc); + std::string mOutFileName = "TrackPtResolutionStudy.root"; + std::shared_ptr mKineReader; + GeometryTGeo* mGeometry; + + // Spans + gsl::span mTracksROFRecords; + gsl::span mTracks; + gsl::span mTracksMCLabels; + gsl::span mClusters; + const o2::dataformats::MCLabelContainer* mClustersMCLCont; + + // Data + GTrackID::mask_t mTracksSrc{}; + std::shared_ptr mDataRequest; + std::vector>> mParticleInfo; // src/event/track + unsigned short mMask = 0x7f; + + // Utils + std::shared_ptr mGGCCDBRequest; + + // Histos + std::unique_ptr mPtResolution; + std::unique_ptr mPtResolution2D; + std::unique_ptr mPtResolutionSec; + std::unique_ptr mPtResolutionPrim; + std::unique_ptr mPtResolutionSec2D; + std::unique_ptr g1; + + //Canvas & decorations + std::unique_ptr mLegendPt; + std::unique_ptr mLegendPt4; + std::unique_ptr mCanvasPt; + std::unique_ptr mCanvasPt2; + std::unique_ptr mCanvasPt3; + std::unique_ptr mCanvasPt4; + // Debug output tree + std::unique_ptr mDBGOut; + double sigma[100]; + double sigmaerr[100]; + double meanPt[100]; + double aa[100]; + int bb=0; +}; + + + void PtResolutionStudy::init(InitContext& ic) +{ + o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest); + + auto& pars = o2::its::study::ITSPtTracksResParamConfig::Instance(); + mOutFileName = pars.outFileName; + mMask = pars.trackLengthMask; + + + mPtResolution = std::make_unique("PtResolution", ";#it{p}_{T} ;Den", 100, -1,1); + mPtResolutionSec = std::make_unique("PtResolutionSec", ";#it{p}_{T} ;Den", 100, -1,1); + mPtResolutionPrim = std::make_unique("PtResolutionPrim", ";#it{p}_{T} ;Den", 100, -1,1); + mPtResolution2D = std::make_unique("#it{p}_{T} Resolution vs #it{p}_{T}", ";#it{p}_{T} (GeV/#it{c});#Delta p_{T}/p_{T_{MC}", 100, 0,10,100,-1,1); + mPtResolutionSec2D=std::make_unique("#it{p}_{T} Resolution vs #it{p}_{T} sec ", ";#it{p}_{T} (GeV/#it{c});#Delta p_{T}/p_{T_{MC}", 100, 0,10,100,-1,1); + mPtResolution->Sumw2(); + mPtResolutionSec->Sumw2(); + mPtResolutionPrim->Sumw2(); + +} + +void PtResolutionStudy::run(ProcessingContext& pc) +{ + o2::globaltracking::RecoContainer recoData; + recoData.collectData(pc, *mDataRequest.get()); + LOGP(info,"*****RUN*****"); + updateTimeDependentParams(pc); // Make sure this is called after recoData.collectData, which may load some conditions + initialiseRun(recoData); + process(); +} + +void PtResolutionStudy::initialiseRun(o2::globaltracking::RecoContainer& recoData) +{ + mTracksROFRecords = recoData.getITSTracksROFRecords(); + mTracks = recoData.getITSTracks(); + mTracksMCLabels = recoData.getITSTracksMCLabels(); + LOGP(info,"***** INITI RUN*****"); + LOGP(info, "** Found in {} rofs:\n\t- {} tracks with {} labels", + mTracksROFRecords.size(), mTracks.size(), mTracksMCLabels.size()); + LOGP(info, "** Found {} sources from kinematic files", mKineReader->getNSources()); +} + +void PtResolutionStudy::process() +{ + LOGP(info, "** Filling particle table ... "); + mParticleInfo.resize(mKineReader->getNSources()); // sources + for (int iSource{0}; iSource < mKineReader->getNSources(); ++iSource) { + mParticleInfo[iSource].resize(mKineReader->getNEvents(iSource)); // events + for (int iEvent{0}; iEvent < mKineReader->getNEvents(iSource); ++iEvent) { + mParticleInfo[iSource][iEvent].resize(mKineReader->getTracks(iSource, iEvent).size()); // tracks + for (auto iPart{0}; iPart < mKineReader->getTracks(iEvent).size(); ++iPart) { + auto& part = mKineReader->getTracks(iSource, iEvent)[iPart]; + mParticleInfo[iSource][iEvent][iPart].event = iEvent; + mParticleInfo[iSource][iEvent][iPart].pdg = part.GetPdgCode(); + mParticleInfo[iSource][iEvent][iPart].pt = part.GetPt(); + mParticleInfo[iSource][iEvent][iPart].phi = part.GetPhi(); + mParticleInfo[iSource][iEvent][iPart].eta = part.GetEta(); + mParticleInfo[iSource][iEvent][iPart].isPrimary = part.isPrimary(); + mParticleInfo[iSource][iEvent][iPart].vx = part.Vx(); + mParticleInfo[iSource][iEvent][iPart].vy = part.Vy(); + mParticleInfo[iSource][iEvent][iPart].vz = part.Vz(); + mParticleInfo[iSource][iEvent][iPart].first = part.getFirstDaughterTrackId(); + } + } + } + LOGP(info, "** Analysing tracks ... "); + int good{0}, fakes{0}, total{0}; + for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { + auto& lab = mTracksMCLabels[iTrack]; + if (!lab.isSet() || lab.isNoise()) { + continue; + } + int trackID, evID, srcID; + bool fake; + const_cast(lab).get(trackID, evID, srcID, fake); + bool pass{true}; + + if (srcID == 99) { // skip QED + continue; + } + + mParticleInfo[srcID][evID][trackID].isReco += !fake; + mParticleInfo[srcID][evID][trackID].isFake += fake; + if (mTracks[iTrack].isBetter(mParticleInfo[srcID][evID][trackID].track, 1.e9)) { + mParticleInfo[srcID][evID][trackID].storedStatus = fake; + mParticleInfo[srcID][evID][trackID].track = mTracks[iTrack]; + } + fakes += fake; + good += !fake; + } + LOGP(info, "** Analysing pT resolution..."); + for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { + auto& lab = mTracksMCLabels[iTrack]; + if (!lab.isSet() || lab.isNoise()) continue; + int trackID, evID, srcID; + bool fake; + const_cast(lab).get(trackID, evID, srcID, fake); + bool pass{true}; + if (srcID == 99) continue;// skip QED + //PtResVec[iTrack]=(mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt; + mPtResolution->Fill((mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt); + mPtResolution2D->Fill(mParticleInfo[srcID][evID][trackID].pt,(mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt); + if(!mParticleInfo[srcID][evID][trackID].isPrimary) mPtResolutionSec->Fill((mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt); + if(mParticleInfo[srcID][evID][trackID].isPrimary) mPtResolutionPrim->Fill((mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt); + } + for(int yy=0;yy<100;yy++) + { + aa[yy]=0.; + sigma[yy]=0.; + sigmaerr[yy]=0.; + meanPt[yy]=0.; + } + + for(int yy=0;yy<100;yy++) + { + TH1D * projh2X = mPtResolution2D->ProjectionY("projh2X",yy,yy+1,""); + TF1 *f1 = new TF1("f1","gaus",-0.2,0.2); + projh2X->Fit("f1"); + if(f1->GetParameter(2)>0. && f1->GetParameter(2)<1. && f1->GetParameter(1)<1.) + { + sigma[yy]=f1->GetParameter(2); + sigmaerr[yy]=f1->GetParError(2); + meanPt[yy]=((8./100.)*yy+(8./100.)*(yy+1))/2; + aa[yy]=0.0125; + } + } + + + + +} + +void PtResolutionStudy::updateTimeDependentParams(ProcessingContext& pc) +{ + static bool initOnceDone = false; + o2::base::GRPGeomHelper::instance().checkUpdates(pc); + if (!initOnceDone) { // this params need to be queried only once + initOnceDone = true; + mGeometry = GeometryTGeo::Instance(); + mGeometry->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G)); + } +} +void PtResolutionStudy::endOfStream(EndOfStreamContext& ec) +{ + TFile fout(mOutFileName.c_str(), "recreate"); + mPtResolution->SetName("#it{p}_{T} resolution"); + mPtResolution->SetTitle(";#Delta p_{T}/p_{T_{MC}} ;Entries"); + mPtResolution->SetFillColor(kAzure + 4); + mPtResolutionPrim->SetFillColor(kRed); + mPtResolutionSec->SetFillColor(kOrange); + mPtResolutionPrim->SetTitle(";#Delta p_{T}/p_{T_{MC}} ;Entries"); + mPtResolutionSec->SetTitle(";#Delta #it{p}_{T}/#it{p}_{T_{MC}} ;Entries"); + mPtResolution2D->SetTitle(";#it{p}_{T_{MC}} [GeV];#Delta #it{p}_{T}/#it{p}_{T_{MC}}"); + + + fout.WriteTObject(mPtResolution.get()); + fout.WriteTObject(mPtResolutionPrim.get()); + fout.WriteTObject(mPtResolutionSec.get()); + fout.WriteTObject(mPtResolution2D.get()); + + mCanvasPt = std::make_unique("cPt", "cPt", 1600, 1200); + mCanvasPt->cd(); + mPtResolution->Draw("HIST"); + mLegendPt = std::make_unique(0.19, 0.8, 0.40, 0.96); + mLegendPt->SetHeader(Form("%zu events PP min bias", mKineReader->getNEvents(0)), "C"); + mLegendPt->AddEntry("mPtResolution", "All events", "lep"); + mLegendPt->Draw(); + mCanvasPt->SaveAs("ptRes.png"); + fout.cd(); + mCanvasPt->Write(); + mCanvasPt2 = std::make_unique("cPt2", "cPt2", 1600, 1200); + mCanvasPt2->cd(); + mPtResolution2D->Draw(); + mCanvasPt2->SaveAs("ptRes2.png"); + fout.cd(); + mCanvasPt2->Write(); + mCanvasPt3 = std::make_unique("cPt3", "cPt3", 1600, 1200); + mCanvasPt3->cd(); + + TGraphErrors *g1 = new TGraphErrors(100,meanPt,sigma,aa,sigmaerr); + g1->SetMarkerStyle(8); + g1->SetMarkerColor(kGreen); + g1->GetXaxis()->SetTitle("Pt [GeV]"); + g1->GetYaxis()->SetTitle("#sigma #Delta #it{p}_{T}/#it{p}_{T_{MC}}"); + g1->GetYaxis()->SetLimits(0,1); + g1->GetXaxis()->SetLimits(0,10.); + g1->Draw("AP"); + g1->GetYaxis()->SetRangeUser(0, 1); + g1->GetXaxis()->SetRangeUser(0, 10.); + mCanvasPt3->SaveAs("ptRes3.png"); + fout.cd(); + mCanvasPt3->Write(); + + mCanvasPt4 = std::make_unique("cPt4", "cPt4", 1600, 1200); + mCanvasPt4->cd(); + mPtResolutionPrim->SetName("mPtResolutionPrim"); + mPtResolutionSec->SetName("mPtResolutionSec"); + mPtResolutionPrim->Draw("same hist"); + mPtResolutionSec->Draw("same hist"); + mLegendPt4 = std::make_unique(0.19, 0.8, 0.40, 0.96); + + mLegendPt4->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); + mLegendPt4->AddEntry("mPtResolutionPrim", "Primary events","f"); + mLegendPt4->AddEntry("mPtResolutionSec", "Secondary events","f"); + mLegendPt4->Draw("same"); + mCanvasPt4->SaveAs("ptRes4.png"); + fout.cd(); + mCanvasPt4->Write(); + + fout.Close(); +} + +void PtResolutionStudy::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) +{ +} + +DataProcessorSpec getPtResolutionStudy(mask_t srcTracksMask, mask_t srcClustersMask, bool useMC, std::shared_ptr kineReader) +{ + std::vector outputs; + auto dataRequest = std::make_shared(); + dataRequest->requestTracks(srcTracksMask, useMC); + + auto ggRequest = std::make_shared(false, // orbitResetTime + true, // GRPECS=true + false, // GRPLHCIF + true, // GRPMagField + true, // askMatLUT + o2::base::GRPGeomRequest::Aligned, // geometry + dataRequest->inputs, + true); + + return DataProcessorSpec{ + "its-study-tracks-pt-resolution", + dataRequest->inputs, + outputs, + AlgorithmSpec{adaptFromTask(dataRequest, srcTracksMask, useMC, kineReader, ggRequest)}, + Options{}}; +} + +} // namespace study +} // namespace its +} // namespace o2 \ No newline at end of file diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index c0476681e8c86..dc49831e43f0e 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -50,6 +50,9 @@ class TrackCheckStudy : public Task float phi; int mother; int first; + float vx; + float vy; + float vz; unsigned short clusters = 0u; unsigned char isReco = 0u; unsigned char isFake = 0u; @@ -94,6 +97,8 @@ class TrackCheckStudy : public Task GTrackID::mask_t mTracksSrc{}; std::shared_ptr mDataRequest; std::vector>> mParticleInfo; // src/event/track + std::vector mParticleInfoPrim; + std::vector mParticleInfoSec; unsigned short mMask = 0x7f; // Utils @@ -114,6 +119,7 @@ class TrackCheckStudy : public Task std::unique_ptr mDenominatorPt; std::unique_ptr mDenominatorEta; + std::unique_ptr mEffPt; std::unique_ptr mEffFakePt; std::unique_ptr mEffClonesPt; @@ -122,11 +128,81 @@ class TrackCheckStudy : public Task std::unique_ptr mEffFakeEta; std::unique_ptr mEffClonesEta; + std::unique_ptr mEff0Pt; + std::unique_ptr mEff1Pt; + std::unique_ptr mEff2Pt; + std::unique_ptr mEff3Pt; + + std::unique_ptr mEff0FakePt; + std::unique_ptr mEff1FakePt; + std::unique_ptr mEff2FakePt; + std::unique_ptr mEff3FakePt; + + std::unique_ptr mEff0Eta; + std::unique_ptr mEff1Eta; + std::unique_ptr mEff2Eta; + std::unique_ptr mEff3Eta; + + std::unique_ptr mEff0FakeEta; + std::unique_ptr mEff1FakeEta; + std::unique_ptr mEff2FakeEta; + std::unique_ptr mEff3FakeEta; + + + + std::unique_ptr mGoodPt0; + std::unique_ptr mGoodPt1; + std::unique_ptr mGoodPt2; + std::unique_ptr mGoodPt3; + + std::unique_ptr mFakePt0; + std::unique_ptr mFakePt1; + std::unique_ptr mFakePt2; + std::unique_ptr mFakePt3; + + std::unique_ptr mGoodEta0; + std::unique_ptr mGoodEta1; + std::unique_ptr mGoodEta2; + std::unique_ptr mGoodEta3; + + std::unique_ptr mFakeEta0; + std::unique_ptr mFakeEta1; + std::unique_ptr mFakeEta2; + std::unique_ptr mFakeEta3; + + + + std::unique_ptr mPtSec0Pt; + std::unique_ptr mPtSec1Pt; + std::unique_ptr mPtSec2Pt; + std::unique_ptr mPtSec3Pt; + + std::unique_ptr mPtSec0Eta; + std::unique_ptr mPtSec1Eta; + std::unique_ptr mPtSec2Eta; + std::unique_ptr mPtSec3Eta; + + // Canvas & decorations std::unique_ptr mCanvasPt; + std::unique_ptr mCanvasPt2; + std::unique_ptr mCanvasPt2fake; + std::unique_ptr mCanvasPtRes; std::unique_ptr mCanvasEta; + std::unique_ptr mCanvasEta2; + std::unique_ptr mCanvasEta2fake; std::unique_ptr mLegendPt; + std::unique_ptr mLegendPt2; + std::unique_ptr mLegendPt2Fake; std::unique_ptr mLegendEta; + std::unique_ptr mLegendEta2; + std::unique_ptr mLegendEta2Fake; + + float rLayer0=2.34; + float rLayer1=3.15; + float rLayer2=3.93; + float rLayer3=19.605; + // Debug output tree std::unique_ptr mDBGOut; @@ -163,12 +239,74 @@ void TrackCheckStudy::init(InitContext& ic) mDenominatorPt = std::make_unique("denominatorPt", ";#it{p}_{T} (GeV/#it{c});Den", pars.effHistBins, xbins.data()); mDenominatorEta = std::make_unique("denominatorEta", ";#eta;Number of tracks", 60, -3, 3); + + mGoodPt0 = std::make_unique("goodPt0", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mGoodPt1 = std::make_unique("goodPt1", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mGoodPt2 = std::make_unique("goodPt2", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mGoodPt3 = std::make_unique("goodPt3", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + + mFakePt0 = std::make_unique("FakePt0", ";#it{p}_{T} (GeV/#it{c});Efficiency (Fake-track rate)", pars.effHistBins, xbins.data()); + mFakePt1 = std::make_unique("FakePt1", ";#it{p}_{T} (GeV/#it{c});Efficiency (Fake-track rate)", pars.effHistBins, xbins.data()); + mFakePt2 = std::make_unique("FakePt2", ";#it{p}_{T} (GeV/#it{c});Efficiency (Fake-track rate)", pars.effHistBins, xbins.data()); + mFakePt3 = std::make_unique("FakePt3", ";#it{p}_{T} (GeV/#it{c});Efficiency (Fake-track rate)", pars.effHistBins, xbins.data()); + + mGoodEta0 = std::make_unique("goodEta0", ";#eta;Number of tracks", 60, -3, 3); + mGoodEta1 = std::make_unique("goodEta1", ";#eta;Number of tracks", 60, -3, 3); + mGoodEta2 = std::make_unique("goodEta2", ";#eta;Number of tracks", 60, -3, 3); + mGoodEta3 = std::make_unique("goodEta3", ";#eta;Number of tracks", 60, -3, 3); + + mFakeEta0 = std::make_unique("FakeEta0", ";#eta;Number of tracks", 60, -3, 3); + mFakeEta1 = std::make_unique("FakeEta1", ";#eta;Number of tracks", 60, -3, 3); + mFakeEta2 = std::make_unique("FakeEta2", ";#eta;Number of tracks", 60, -3, 3); + mFakeEta3 = std::make_unique("FakeEta3", ";#eta;Number of tracks", 60, -3, 3); + + mPtSec0Pt= std::make_unique("mPtSec0Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})",pars.effHistBins, xbins.data()); + mPtSec1Pt= std::make_unique("mPtSec1Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})",pars.effHistBins, xbins.data()); + mPtSec2Pt= std::make_unique("mPtSec2Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})",pars.effHistBins, xbins.data()); + mPtSec3Pt= std::make_unique("mPtSec3Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})",pars.effHistBins, xbins.data()); + + mPtSec0Eta= std::make_unique("mPtSec0Eta", ";#eta;Number of tracks", 60, -3, 3); + mPtSec1Eta= std::make_unique("mPtSec1Eta", ";#eta;Number of tracks", 60, -3, 3); + mPtSec2Eta= std::make_unique("mPtSec2Eta", ";#eta;Number of tracks", 60, -3, 3); + mPtSec3Eta= std::make_unique("mPtSec3Eta", ";#eta;Number of tracks", 60, -3, 3); + + mGoodPt0->Sumw2(); + mGoodPt1->Sumw2(); + mGoodPt2->Sumw2(); + mGoodPt3->Sumw2(); + + mFakePt0->Sumw2(); + mFakePt1->Sumw2(); + mFakePt2->Sumw2(); + mFakePt3->Sumw2(); + + mGoodEta0->Sumw2(); + mGoodEta1->Sumw2(); + mGoodEta2->Sumw2(); + mGoodEta3->Sumw2(); + + mFakeEta0->Sumw2(); + mFakeEta1->Sumw2(); + mFakeEta2->Sumw2(); + mFakeEta3->Sumw2(); + + mPtSec0Pt->Sumw2(); + mPtSec1Pt->Sumw2(); + mPtSec2Pt->Sumw2(); + mPtSec3Pt->Sumw2(); + + mPtSec0Eta->Sumw2(); + mPtSec1Eta->Sumw2(); + mPtSec2Eta->Sumw2(); + mPtSec3Eta->Sumw2(); + mGoodPt->Sumw2(); mGoodEta->Sumw2(); mFakePt->Sumw2(); mMultiFake->Sumw2(); mClonePt->Sumw2(); mDenominatorPt->Sumw2(); + } void TrackCheckStudy::run(ProcessingContext& pc) @@ -209,7 +347,11 @@ void TrackCheckStudy::process() mParticleInfo[iSource][iEvent][iPart].pt = part.GetPt(); mParticleInfo[iSource][iEvent][iPart].phi = part.GetPhi(); mParticleInfo[iSource][iEvent][iPart].eta = part.GetEta(); + mParticleInfo[iSource][iEvent][iPart].vx = part.Vx(); + mParticleInfo[iSource][iEvent][iPart].vy = part.Vy(); + mParticleInfo[iSource][iEvent][iPart].vz = part.Vz(); mParticleInfo[iSource][iEvent][iPart].isPrimary = part.isPrimary(); + //mParticleInfo[iSource][iEvent][iPart].first = part.getFirstDaughterTrackId(); } } } @@ -232,6 +374,9 @@ void TrackCheckStudy::process() } LOGP(info, "** Analysing tracks ... "); int unaccounted{0}, good{0}, fakes{0}, total{0}; + int good0=0,good1=0,good2=0,good3=0, totalsec=0;//secondary + int fake0=0,fake1=0,fake2=0,fake3=0; + int totsec0=0,totsec1=0,totsec2=0,totsec3=0; for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { auto& lab = mTracksMCLabels[iTrack]; if (!lab.isSet() || lab.isNoise()) { @@ -256,12 +401,18 @@ void TrackCheckStudy::process() } fakes += fake; good += !fake; + + } LOGP(info, "** Some statistics:"); LOGP(info, "\t- Total number of tracks: {}", mTracks.size()); LOGP(info, "\t- Total number of tracks not corresponding to particles: {} ({:.2f} %)", unaccounted, unaccounted * 100. / mTracks.size()); LOGP(info, "\t- Total number of fakes: {} ({:.2f} %)", fakes, fakes * 100. / mTracks.size()); LOGP(info, "\t- Total number of good: {} ({:.2f} %)", good, good * 100. / mTracks.size()); + + + + LOGP(info, "** Filling histograms ... "); // Currently process only sourceID = 0, to be extended later if needed @@ -273,32 +424,123 @@ void TrackCheckStudy::process() // part.clusters != 0x0f && part.clusters != 0x0f << 1 && part.clusters != 0x0f << 2 && part.clusters != 0x0f << 3) { continue; } - if (!part.isPrimary) { - continue; - } - mDenominatorPt->Fill(part.pt); - mDenominatorEta->Fill(part.eta); - if (part.isReco) { - mGoodPt->Fill(part.pt); - mGoodEta->Fill(part.eta); - if (part.isReco > 1) { - for (int _i{0}; _i < part.isReco - 1; ++_i) { - mClonePt->Fill(part.pt); - mCloneEta->Fill(part.eta); + if (part.isPrimary) + { + mDenominatorPt->Fill(part.pt); + mDenominatorEta->Fill(part.eta); + if (part.isReco) { + mGoodPt->Fill(part.pt); + mGoodEta->Fill(part.eta); + if (part.isReco > 1) { + for (int _i{0}; _i < part.isReco - 1; ++_i) { + mClonePt->Fill(part.pt); + mCloneEta->Fill(part.eta); + } + } + } + if (part.isFake) { + mFakePt->Fill(part.pt); + mFakeEta->Fill(part.eta); + if (part.isFake > 1) { + for (int _i{0}; _i < part.isFake - 1; ++_i) { + mMultiFake->Fill(part.pt); + } } } } - if (part.isFake) { - mFakePt->Fill(part.pt); - mFakeEta->Fill(part.eta); - if (part.isFake > 1) { - for (int _i{0}; _i < part.isFake - 1; ++_i) { - mMultiFake->Fill(part.pt); + + if(!part.isPrimary){ + totalsec++; + float rad=sqrt(pow(part.vx,2)+pow(part.vy,2)); + if (rad< rLayer0)// layer 0 + { + totsec0++; + mPtSec0Pt->Fill(part.pt); + mPtSec0Eta->Fill(part.eta); + + if (part.isReco) + { + mGoodPt0->Fill(part.pt); + mGoodEta0->Fill(part.eta); + good0++; + } + if (part.isFake) + { + mFakePt0->Fill(part.pt); + mFakeEta0->Fill(part.eta); + fake0++; } } + + if (rad< rLayer1 && rad> rLayer0 )// layer 1 + { + totsec1++; + mPtSec1Pt->Fill(part.pt); + mPtSec1Eta->Fill(part.eta); + if (part.isReco) + { + mGoodPt1->Fill(part.pt); + mGoodEta1->Fill(part.eta); + good1++; + } + if (part.isFake) + { + mFakePt1->Fill(part.pt); + mFakeEta1->Fill(part.eta); + fake1++; + } + } + + if (rad< rLayer2 && rad> rLayer1 )// layer 2 + { + totsec2++; + mPtSec2Pt->Fill(part.pt); + mPtSec2Eta->Fill(part.eta); + if (part.isReco) + { + mGoodPt2->Fill(part.pt); + mGoodEta2->Fill(part.eta); + good2++; + } + if (part.isFake) + { + mFakePt2->Fill(part.pt); + mFakeEta2->Fill(part.eta); + fake2++; + } + } + + if (rad< rLayer3 && rad> rLayer2 )// layer 3 + { + totsec3++; + mPtSec3Pt->Fill(part.pt); + mPtSec3Eta->Fill(part.eta); + if (part.isReco) + { + mGoodPt3->Fill(part.pt); + mGoodEta3->Fill(part.eta); + good3++; + } + if (part.isFake) + { + mFakePt3->Fill(part.pt); + mFakeEta3->Fill(part.eta); + fake3++; + } + } } } } + LOGP(info, "** Some statistics on secondary tracks:"); + + LOGP(info, "\t- Total number of secondary tracks: {}", totalsec); + LOGP(info, "\t- Total number of secondary tracks on layer O: {}, good: {}, fake: {}", totsec0,good0,fake0); + LOGP(info, "\t- Total number of secondary tracks on layer 1: {}, good: {}, fake: {}", totsec1,good1,fake1); + LOGP(info, "\t- Total number of secondary tracks on layer 2: {}, good: {}, fake: {}", totsec2,good2,fake2); + LOGP(info, "\t- Total number of secondary tracks on layer 3: {}, good: {}, fake: {}", totsec3,good3,fake3); + + + LOGP(info, "** Computing efficiencies ..."); mEffPt = std::make_unique(*mGoodPt, *mDenominatorPt); @@ -308,6 +550,26 @@ void TrackCheckStudy::process() mEffEta = std::make_unique(*mGoodEta, *mDenominatorEta); mEffFakeEta = std::make_unique(*mFakeEta, *mDenominatorEta); mEffClonesEta = std::make_unique(*mCloneEta, *mDenominatorEta); + + mEff0Pt = std::make_unique(*mGoodPt0, *mPtSec0Pt); + mEff1Pt = std::make_unique(*mGoodPt1, *mPtSec1Pt); + mEff2Pt = std::make_unique(*mGoodPt2, *mPtSec2Pt); + mEff3Pt = std::make_unique(*mGoodPt3, *mPtSec3Pt); + + mEff0FakePt = std::make_unique(*mFakePt0, *mPtSec0Pt); + mEff1FakePt = std::make_unique(*mFakePt1, *mPtSec1Pt); + mEff2FakePt = std::make_unique(*mFakePt2, *mPtSec2Pt); + mEff3FakePt = std::make_unique(*mFakePt3, *mPtSec3Pt); + + mEff0Eta = std::make_unique(*mGoodEta0, *mPtSec0Eta); + mEff1Eta = std::make_unique(*mGoodEta1, *mPtSec1Eta); + mEff2Eta = std::make_unique(*mGoodEta2, *mPtSec2Eta); + mEff3Eta = std::make_unique(*mGoodEta3, *mPtSec3Eta); + + mEff0FakeEta = std::make_unique(*mFakeEta0, *mPtSec0Eta); + mEff1FakeEta = std::make_unique(*mFakeEta1, *mPtSec1Eta); + mEff2FakeEta = std::make_unique(*mFakeEta2, *mPtSec2Eta); + mEff3FakeEta = std::make_unique(*mFakeEta3, *mPtSec3Eta); } void TrackCheckStudy::updateTimeDependentParams(ProcessingContext& pc) @@ -391,6 +653,185 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEffClonesEta->SetDirectory(gDirectory); fout.WriteTObject(mEffClonesEta.get()); + mEff0Pt->SetName("Good_pt0");//******LAYER 0****** + mEff0Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); + mEff0Pt->SetLineColor(kAzure + 4); + mEff0Pt->SetLineColorAlpha(kAzure + 4, 1); + mEff0Pt->SetLineWidth(2); + mEff0Pt->SetMarkerColorAlpha(kAzure + 4, 1); + mEff0Pt->SetMarkerStyle(kFullCircle); + mEff0Pt->SetMarkerSize(1.7); + mEff0Pt->SetDirectory(gDirectory); + fout.WriteTObject(mEff0Pt.get()); + + mEff0FakePt->SetName("Fake_pt0"); + mEff0FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); + mEff0FakePt->SetLineColor(kAzure + 4); + mEff0FakePt->SetLineColorAlpha(kAzure + 4, 1); + mEff0FakePt->SetLineWidth(2); + mEff0FakePt->SetMarkerColorAlpha(kAzure + 4, 1); + mEff0FakePt->SetMarkerStyle(kFullCircle); + mEff0FakePt->SetMarkerSize(1.7); + mEff0FakePt->SetDirectory(gDirectory); + fout.WriteTObject(mEff0FakePt.get()); + + mEff0Eta->SetName("Good_eta0"); + mEff0Eta->SetTitle(";#eta;efficiency secondary particle" ); + mEff0Eta->SetLineColor(kAzure + 4); + mEff0Eta->SetLineColorAlpha(kAzure + 4, 1); + mEff0Eta->SetLineWidth(2); + mEff0Eta->SetMarkerColorAlpha(kAzure + 4, 1); + mEff0Eta->SetMarkerStyle(kFullCircle); + mEff0Eta->SetMarkerSize(1.7); + mEff0Eta->SetDirectory(gDirectory); + fout.WriteTObject(mEff0Eta.get()); + + mEff0FakeEta->SetName("Fake_eta0"); + mEff0FakeEta->SetTitle(";#eta;efficiency secondary particle" ); + mEff0FakeEta->SetLineColor(kAzure + 4); + mEff0FakeEta->SetLineColorAlpha(kAzure + 4, 1); + mEff0FakeEta->SetLineWidth(2); + mEff0FakeEta->SetMarkerColorAlpha(kAzure + 4, 1); + mEff0FakeEta->SetMarkerStyle(kFullCircle); + mEff0FakeEta->SetMarkerSize(1.7); + mEff0FakeEta->SetDirectory(gDirectory); + fout.WriteTObject(mEff0FakeEta.get()); + + mEff1Pt->SetName("Good_pt1");//*****LAYER 1 ******** + mEff1Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); + mEff1Pt->SetLineColor(kRed); + mEff1Pt->SetLineColorAlpha(kRed ,1 ); + mEff1Pt->SetLineWidth(2); + mEff1Pt->SetMarkerColorAlpha(kRed , 1); + mEff1Pt->SetMarkerStyle(kFullCircle); + mEff1Pt->SetMarkerSize(1.7); + mEff1Pt->SetDirectory(gDirectory); + fout.WriteTObject(mEff1Pt.get()); + + mEff1FakePt->SetName("Fake_pt1"); + mEff1FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); + mEff1FakePt->SetLineColor(kRed); + mEff1FakePt->SetLineColorAlpha(kRed,1); + mEff1FakePt->SetLineWidth(2); + mEff1FakePt->SetMarkerColorAlpha(kRed,1); + mEff1FakePt->SetMarkerStyle(kFullCircle); + mEff1FakePt->SetMarkerSize(1.7); + mEff1FakePt->SetDirectory(gDirectory); + fout.WriteTObject(mEff1FakePt.get()); + + mEff1Eta->SetName("Good_eta1"); + mEff1Eta->SetTitle(";#eta;efficiency secondary particle"); + mEff1Eta->SetLineColor(kRed); + mEff1Eta->SetLineColorAlpha(kRed ,1 ); + mEff1Eta->SetLineWidth(2); + mEff1Eta->SetMarkerColorAlpha(kRed , 1); + mEff1Eta->SetMarkerStyle(kFullCircle); + mEff1Eta->SetMarkerSize(1.7); + mEff1Eta->SetDirectory(gDirectory); + fout.WriteTObject(mEff1Eta.get()); + + mEff1FakeEta->SetName("Fake_eta1"); + mEff1FakeEta->SetTitle(";#eta;efficiency secondary particle"); + mEff1FakeEta->SetLineColor(kRed); + mEff1FakeEta->SetLineColorAlpha(kRed,1); + mEff1FakeEta->SetLineWidth(2); + mEff1FakeEta->SetMarkerColorAlpha(kRed,1); + mEff1FakeEta->SetMarkerStyle(kFullCircle); + mEff1FakeEta->SetMarkerSize(1.7); + mEff1FakeEta->SetDirectory(gDirectory); + fout.WriteTObject(mEff1FakeEta.get()); + + mEff2Pt->SetName("Good_pt2");//*****LAYER 2 ******** + mEff2Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); + mEff2Pt->SetLineColor(kGreen+1); + mEff2Pt->SetLineColorAlpha(kGreen +1 , 1); + mEff2Pt->SetLineWidth(2); + mEff2Pt->SetMarkerColorAlpha(kGreen+1 , 1); + mEff2Pt->SetMarkerStyle(kFullCircle); + mEff2Pt->SetMarkerSize(1.7); + mEff2Pt->SetDirectory(gDirectory); + fout.WriteTObject(mEff2Pt.get()); + + mEff2FakePt->SetName("Fake_pt2"); + mEff2FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); + mEff2FakePt->SetLineColor(kGreen+1); + mEff2FakePt->SetLineColorAlpha(kGreen+1 , 1); + mEff2FakePt->SetLineWidth(2); + mEff2FakePt->SetMarkerColorAlpha(kGreen+1 , 1); + mEff2FakePt->SetMarkerStyle(kFullCircle); + mEff2FakePt->SetMarkerSize(1.7); + mEff2FakePt->SetDirectory(gDirectory); + fout.WriteTObject(mEff2FakePt.get()); + + mEff2Eta->SetName("Good_eta2"); + mEff2Eta->SetTitle(";#eta;efficiency secondary particle"); + mEff2Eta->SetLineColor(kGreen +1); + mEff2Eta->SetLineColorAlpha(kGreen +1 ,1 ); + mEff2Eta->SetLineWidth(2); + mEff2Eta->SetMarkerColorAlpha(kGreen +1 , 1); + mEff2Eta->SetMarkerStyle(kFullCircle); + mEff2Eta->SetMarkerSize(1.7); + mEff2Eta->SetDirectory(gDirectory); + fout.WriteTObject(mEff2Eta.get()); + + mEff2FakeEta->SetName("Fake_eta2"); + mEff2FakeEta->SetTitle(";#eta;efficiency secondary particle"); + mEff2FakeEta->SetLineColor(kGreen +1); + mEff2FakeEta->SetLineColorAlpha(kGreen +1,1); + mEff2FakeEta->SetLineWidth(2); + mEff2FakeEta->SetMarkerColorAlpha(kGreen +1,1); + mEff2FakeEta->SetMarkerStyle(kFullCircle); + mEff2FakeEta->SetMarkerSize(1.7); + mEff2FakeEta->SetDirectory(gDirectory); + fout.WriteTObject(mEff2FakeEta.get()); + + mEff3Pt->SetName("Good_pt3");//*****LAYER 3 ******** + mEff3Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); + mEff3Pt->SetLineColor(kOrange-3); + mEff3Pt->SetLineColorAlpha(kOrange -3 , 1); + mEff3Pt->SetLineWidth(2); + mEff3Pt->SetMarkerColorAlpha(kOrange-3 , 1); + mEff3Pt->SetMarkerStyle(kFullCircle); + mEff3Pt->SetMarkerSize(1.7); + mEff3Pt->SetDirectory(gDirectory); + fout.WriteTObject(mEff3Pt.get()); + + mEff3FakePt->SetName("Fake_pt3"); + mEff3FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); + mEff3FakePt->SetLineColor(kOrange-3); + mEff3FakePt->SetLineColorAlpha(kOrange-3,1); + mEff3FakePt->SetLineWidth(2); + mEff3FakePt->SetMarkerColorAlpha(kOrange-3,1); + mEff3FakePt->SetMarkerStyle(kFullCircle); + mEff3FakePt->SetMarkerSize(1.7); + mEff3FakePt->SetDirectory(gDirectory); + fout.WriteTObject(mEff3FakePt.get()); + + mEff3Eta->SetName("Good_eta3"); + mEff3Eta->SetTitle(";#eta;efficiency secondary particle"); + mEff3Eta->SetLineColor(kOrange -3); + mEff3Eta->SetLineColorAlpha(kOrange -3 ,1 ); + mEff3Eta->SetLineWidth(2); + mEff3Eta->SetMarkerColorAlpha(kOrange -3 , 1); + mEff3Eta->SetMarkerStyle(kFullCircle); + mEff3Eta->SetMarkerSize(1.7); + mEff3Eta->SetDirectory(gDirectory); + fout.WriteTObject(mEff3Eta.get()); + + mEff3FakeEta->SetName("Fake_eta3"); + mEff3FakeEta->SetTitle(";#eta;efficiency secondary particle"); + mEff3FakeEta->SetLineColor(kOrange -3); + mEff3FakeEta->SetLineColorAlpha(kOrange -3,1); + mEff3FakeEta->SetLineWidth(2); + mEff3FakeEta->SetMarkerColorAlpha(kOrange -3,1); + mEff3FakeEta->SetMarkerStyle(kFullCircle); + mEff3FakeEta->SetMarkerSize(1.7); + mEff3FakeEta->SetDirectory(gDirectory); + fout.WriteTObject(mEff3FakeEta.get()); + + + + // Paint the histograms // todo: delegate to a dedicated helper gStyle->SetTitleSize(0.035, "xy"); @@ -435,9 +876,99 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mLegendEta->Draw(); mCanvasEta->SaveAs("eff_eta.png"); + mCanvasPt2 = std::make_unique("cPt2", "cPt2", 1600, 1200); + mCanvasPt2->cd(); + mCanvasPt2->SetLogx(); + mCanvasPt2->SetGrid(); + mEff0Pt->Draw("pz"); + mEff1Pt->Draw("pz same"); + mEff2Pt->Draw("pz same"); + mEff3Pt->Draw("pz same"); + + + mLegendPt2 = std::make_unique(0.19, 0.8, 0.40, 0.96); + mLegendPt2->SetHeader(Form("%zu events PP, good tracks", mKineReader->getNEvents(0)), "C"); + mLegendPt2->AddEntry("Good_pt0", "Layer 0", "lep"); + mLegendPt2->AddEntry("Good_pt1", "Layer 1", "lep"); + mLegendPt2->AddEntry("Good_pt2", "Layer 2", "lep"); + mLegendPt2->AddEntry("Good_pt3", "Layer 3", "lep"); + + mLegendPt2->Draw(); + mCanvasPt2->SaveAs("eff_sec_pt.png"); + + mCanvasEta2 = std::make_unique("cEta2", "cEta2", 1600, 1200); + mCanvasEta2->cd(); + + mCanvasEta2->SetGrid(); + mEff0Eta->Draw("pz"); + mEff1Eta->Draw("pz same"); + mEff2Eta->Draw("pz same"); + mEff3Eta->Draw("pz same"); + + + mLegendEta2 = std::make_unique(0.19, 0.8, 0.40, 0.96); + mLegendEta2->SetHeader(Form("%zu events PP, good tracks", mKineReader->getNEvents(0)), "C"); + mLegendEta2->AddEntry("Good_eta0", "Layer 0", "lep"); + mLegendEta2->AddEntry("Good_eta1", "Layer 1", "lep"); + mLegendEta2->AddEntry("Good_eta2", "Layer 2", "lep"); + mLegendEta2->AddEntry("Good_eta3", "Layer 3", "lep"); + + mLegendEta2->Draw(); + mCanvasEta2->SaveAs("eff_sec_eta.png"); + + + + mCanvasPt2fake = std::make_unique("cPt2fake", "cPt2fake", 1600, 1200); + mCanvasPt2fake->cd(); + mCanvasPt2fake->SetLogx(); + mCanvasPt2fake->SetGrid(); + mEff0FakePt->Draw("pz"); + mEff1FakePt->Draw("pz same"); + mEff2FakePt->Draw("pz same"); + mEff3FakePt->Draw("pz same"); + + + mLegendPt2Fake = std::make_unique(0.19, 0.8, 0.40, 0.96); + mLegendPt2Fake->SetHeader(Form("%zu events PP, fake tracks ", mKineReader->getNEvents(0)), "C"); + mLegendPt2Fake->AddEntry("Fake_pt0", "Layer 0", "lep"); + mLegendPt2Fake->AddEntry("Fake_pt1", "Layer 1", "lep"); + mLegendPt2Fake->AddEntry("Fake_pt2", "Layer 2", "lep"); + mLegendPt2Fake->AddEntry("Fake_pt3", "Layer 3", "lep"); + + + mLegendPt2Fake->Draw(); + mCanvasPt2fake->SaveAs("eff_sec_pt_fake.png"); + + mCanvasEta2fake = std::make_unique("cEta2fake", "cEta2fake", 1600, 1200); + mCanvasEta2fake->cd(); + + mCanvasEta2fake->SetGrid(); + mEff0FakeEta->Draw("pz"); + mEff1FakeEta->Draw("pz same"); + mEff2FakeEta->Draw("pz same"); + mEff3FakeEta->Draw("pz same"); + + + mLegendEta2Fake = std::make_unique(0.19, 0.8, 0.40, 0.96); + mLegendEta2Fake->SetHeader(Form("%zu events PP, fake tracks ", mKineReader->getNEvents(0)), "C"); + mLegendEta2Fake->AddEntry("Fake_eta0", "Layer 0", "lep"); + mLegendEta2Fake->AddEntry("Fake_eta1", "Layer 1", "lep"); + mLegendEta2Fake->AddEntry("Fake_eta2", "Layer 2", "lep"); + mLegendEta2Fake->AddEntry("Fake_eta3", "Layer 3", "lep"); + + + mLegendEta2Fake->Draw(); + mCanvasEta2fake->SaveAs("eff_sec_Eta_fake.png"); + + fout.cd(); mCanvasPt->Write(); mCanvasEta->Write(); + mCanvasPt2->Write(); + mCanvasPt2fake->Write(); + mCanvasEta2->Write(); + mCanvasEta2fake->Write(); + fout.Close(); } diff --git a/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx b/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx index 572b5a5968ad4..57a73e785218b 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx @@ -17,6 +17,7 @@ #include "ITSStudies/ImpactParameter.h" #include "ITSStudies/AvgClusSize.h" #include "ITSStudies/TrackCheck.h" +#include "ITSStudies/PtResolution.h" #include "Steer/MCKinematicsReader.h" using namespace o2::framework; @@ -39,6 +40,7 @@ void customize(std::vector& workflowOptions) {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}}, {"cluster-size-study", VariantType::Bool, false, {"Perform the average cluster size study"}}, {"track-study", VariantType::Bool, false, {"Perform the track study"}}, + {"pt-res-study", VariantType::Bool, false, {"Perform the Pt resolution study"}}, {"impact-parameter-study", VariantType::Bool, false, {"Perform the impact parameter study"}}, {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}}; o2::raw::HBFUtilsInitializer::addConfigOption(options, "o2_tfidinfo.root"); @@ -61,8 +63,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext) GID::mask_t srcCls = allowedSourcesClus & GID::getSourcesMask(configcontext.options().get("cluster-sources")); o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, useMC, srcCls, srcTrc); - o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC); - o2::globaltracking::InputHelper::addInputSpecsSVertex(configcontext, specs); + //o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC); + //o2::globaltracking::InputHelper::addInputSpecsSVertex(configcontext, specs); std::shared_ptr mcKinematicsReader; if (useMC) { @@ -83,6 +85,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext) anyStudy = true; specs.emplace_back(o2::its::study::getTrackCheckStudy(GID::getSourcesMask("ITS"), GID::getSourcesMask("ITS"), useMC, mcKinematicsReader)); } + if (configcontext.options().get("pt-res-study")) { + anyStudy = true; + specs.emplace_back(o2::its::study::getPtResolutionStudy(GID::getSourcesMask("ITS"), GID::getSourcesMask("ITS"), useMC, mcKinematicsReader)); + } if (!anyStudy) { LOGP(info, "No study selected, dryrunning"); } From f04953ae794d7e7ba844b4c76dca97744a925423 Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Mon, 14 Aug 2023 15:38:24 +0200 Subject: [PATCH 02/19] Fix format --- .../ITSStudies/ITSStudiesConfigParam.h | 1 - .../studies/include/ITSStudies/PtResolution.h | 2 +- .../studies/src/ITSStudiesConfigParam.cxx | 3 +- .../studies/src/ITSStudiesLinkDef.h | 1 - .../studies/src/PtResolution.cxx | 151 ++++++------ .../postprocessing/studies/src/TrackCheck.cxx | 215 ++++++++---------- .../standalone-postprocessing-workflow.cxx | 4 +- 7 files changed, 165 insertions(+), 212 deletions(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h index 719764fc7a88c..4838667ac7cc3 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h @@ -31,7 +31,6 @@ struct ITSCheckTracksParamConfig : public o2::conf::ConfigurableParamHelper { std::string outFileName = "TrackPtResStudy.root"; unsigned short trackLengthMask = 0x7f; diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h index d9b312dd1e264..9980814edac75 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h @@ -31,7 +31,7 @@ namespace study { using mask_t = o2::dataformats::GlobalTrackID::mask_t; -o2::framework::DataProcessorSpec getPtResolutionStudy(mask_t srcTracksMask, mask_t srcClustersMask, bool useMC , std::shared_ptr kineReader); +o2::framework::DataProcessorSpec getPtResolutionStudy(mask_t srcTracksMask, mask_t srcClustersMask, bool useMC, std::shared_ptr kineReader); } // namespace study } // namespace its } // namespace o2 diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx index be5c1177fdac4..cc725c8f6f10a 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx @@ -19,8 +19,7 @@ namespace study { static auto& sAvgClusSizeParamITS = o2::its::study::ITSAvgClusSizeParamConfig::Instance(); static auto& sCheckTracksParamsITS = o2::its::study::ITSCheckTracksParamConfig::Instance(); -static auto& sPtResParamsITS= o2::its::study::ITSPtTracksResParamConfig::Instance(); - +static auto& sPtResParamsITS = o2::its::study::ITSPtTracksResParamConfig::Instance(); O2ParamImpl(o2::its::study::ITSAvgClusSizeParamConfig); O2ParamImpl(o2::its::study::ITSCheckTracksParamConfig); diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h index 54ad18bd51a5c..2f4d413a55586 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h @@ -20,5 +20,4 @@ #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::study::ITSCheckTracksParamConfig> + ; #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::study::ITSPtTracksResParamConfig> + ; - #endif \ No newline at end of file diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx index 17106da79a3f9..c6ac399f744eb 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx @@ -68,10 +68,10 @@ class PtResolutionStudy : public Task public: PtResolutionStudy(std::shared_ptr dr, - mask_t src, - bool useMC, - std::shared_ptr kineReader, - std::shared_ptr gr) : mDataRequest(dr), mTracksSrc(src), mKineReader(kineReader), mGGCCDBRequest(gr) + mask_t src, + bool useMC, + std::shared_ptr kineReader, + std::shared_ptr gr) : mDataRequest(dr), mTracksSrc(src), mKineReader(kineReader), mGGCCDBRequest(gr) { if (useMC) { LOGP(info, "Read MCKine reader with {} sources", mKineReader->getNSources()); @@ -115,7 +115,7 @@ class PtResolutionStudy : public Task std::unique_ptr mPtResolutionSec2D; std::unique_ptr g1; - //Canvas & decorations + // Canvas & decorations std::unique_ptr mLegendPt; std::unique_ptr mLegendPt4; std::unique_ptr mCanvasPt; @@ -128,11 +128,10 @@ class PtResolutionStudy : public Task double sigmaerr[100]; double meanPt[100]; double aa[100]; - int bb=0; + int bb = 0; }; - - void PtResolutionStudy::init(InitContext& ic) +void PtResolutionStudy::init(InitContext& ic) { o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest); @@ -140,23 +139,21 @@ class PtResolutionStudy : public Task mOutFileName = pars.outFileName; mMask = pars.trackLengthMask; - - mPtResolution = std::make_unique("PtResolution", ";#it{p}_{T} ;Den", 100, -1,1); - mPtResolutionSec = std::make_unique("PtResolutionSec", ";#it{p}_{T} ;Den", 100, -1,1); - mPtResolutionPrim = std::make_unique("PtResolutionPrim", ";#it{p}_{T} ;Den", 100, -1,1); - mPtResolution2D = std::make_unique("#it{p}_{T} Resolution vs #it{p}_{T}", ";#it{p}_{T} (GeV/#it{c});#Delta p_{T}/p_{T_{MC}", 100, 0,10,100,-1,1); - mPtResolutionSec2D=std::make_unique("#it{p}_{T} Resolution vs #it{p}_{T} sec ", ";#it{p}_{T} (GeV/#it{c});#Delta p_{T}/p_{T_{MC}", 100, 0,10,100,-1,1); + mPtResolution = std::make_unique("PtResolution", ";#it{p}_{T} ;Den", 100, -1, 1); + mPtResolutionSec = std::make_unique("PtResolutionSec", ";#it{p}_{T} ;Den", 100, -1, 1); + mPtResolutionPrim = std::make_unique("PtResolutionPrim", ";#it{p}_{T} ;Den", 100, -1, 1); + mPtResolution2D = std::make_unique("#it{p}_{T} Resolution vs #it{p}_{T}", ";#it{p}_{T} (GeV/#it{c});#Delta p_{T}/p_{T_{MC}", 100, 0, 10, 100, -1, 1); + mPtResolutionSec2D = std::make_unique("#it{p}_{T} Resolution vs #it{p}_{T} sec ", ";#it{p}_{T} (GeV/#it{c});#Delta p_{T}/p_{T_{MC}", 100, 0, 10, 100, -1, 1); mPtResolution->Sumw2(); mPtResolutionSec->Sumw2(); mPtResolutionPrim->Sumw2(); - } void PtResolutionStudy::run(ProcessingContext& pc) { o2::globaltracking::RecoContainer recoData; recoData.collectData(pc, *mDataRequest.get()); - LOGP(info,"*****RUN*****"); + LOGP(info, "*****RUN*****"); updateTimeDependentParams(pc); // Make sure this is called after recoData.collectData, which may load some conditions initialiseRun(recoData); process(); @@ -167,7 +164,7 @@ void PtResolutionStudy::initialiseRun(o2::globaltracking::RecoContainer& recoDat mTracksROFRecords = recoData.getITSTracksROFRecords(); mTracks = recoData.getITSTracks(); mTracksMCLabels = recoData.getITSTracksMCLabels(); - LOGP(info,"***** INITI RUN*****"); + LOGP(info, "***** INITI RUN*****"); LOGP(info, "** Found in {} rofs:\n\t- {} tracks with {} labels", mTracksROFRecords.size(), mTracks.size(), mTracksMCLabels.size()); LOGP(info, "** Found {} sources from kinematic files", mKineReader->getNSources()); @@ -176,9 +173,9 @@ void PtResolutionStudy::initialiseRun(o2::globaltracking::RecoContainer& recoDat void PtResolutionStudy::process() { LOGP(info, "** Filling particle table ... "); - mParticleInfo.resize(mKineReader->getNSources()); // sources + mParticleInfo.resize(mKineReader->getNSources()); // sources for (int iSource{0}; iSource < mKineReader->getNSources(); ++iSource) { - mParticleInfo[iSource].resize(mKineReader->getNEvents(iSource)); // events + mParticleInfo[iSource].resize(mKineReader->getNEvents(iSource)); // events for (int iEvent{0}; iEvent < mKineReader->getNEvents(iSource); ++iEvent) { mParticleInfo[iSource][iEvent].resize(mKineReader->getTracks(iSource, iEvent).size()); // tracks for (auto iPart{0}; iPart < mKineReader->getTracks(iEvent).size(); ++iPart) { @@ -197,7 +194,7 @@ void PtResolutionStudy::process() } } LOGP(info, "** Analysing tracks ... "); - int good{0}, fakes{0}, total{0}; + int good{0}, fakes{0}, total{0}; for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { auto& lab = mTracksMCLabels[iTrack]; if (!lab.isSet() || lab.isNoise()) { @@ -223,44 +220,41 @@ void PtResolutionStudy::process() } LOGP(info, "** Analysing pT resolution..."); for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { - auto& lab = mTracksMCLabels[iTrack]; - if (!lab.isSet() || lab.isNoise()) continue; - int trackID, evID, srcID; - bool fake; - const_cast(lab).get(trackID, evID, srcID, fake); - bool pass{true}; - if (srcID == 99) continue;// skip QED - //PtResVec[iTrack]=(mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt; - mPtResolution->Fill((mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt); - mPtResolution2D->Fill(mParticleInfo[srcID][evID][trackID].pt,(mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt); - if(!mParticleInfo[srcID][evID][trackID].isPrimary) mPtResolutionSec->Fill((mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt); - if(mParticleInfo[srcID][evID][trackID].isPrimary) mPtResolutionPrim->Fill((mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt); - } - for(int yy=0;yy<100;yy++) - { - aa[yy]=0.; - sigma[yy]=0.; - sigmaerr[yy]=0.; - meanPt[yy]=0.; - } - - for(int yy=0;yy<100;yy++) - { - TH1D * projh2X = mPtResolution2D->ProjectionY("projh2X",yy,yy+1,""); - TF1 *f1 = new TF1("f1","gaus",-0.2,0.2); - projh2X->Fit("f1"); - if(f1->GetParameter(2)>0. && f1->GetParameter(2)<1. && f1->GetParameter(1)<1.) - { - sigma[yy]=f1->GetParameter(2); - sigmaerr[yy]=f1->GetParError(2); - meanPt[yy]=((8./100.)*yy+(8./100.)*(yy+1))/2; - aa[yy]=0.0125; - } - } - - - + auto& lab = mTracksMCLabels[iTrack]; + if (!lab.isSet() || lab.isNoise()) + continue; + int trackID, evID, srcID; + bool fake; + const_cast(lab).get(trackID, evID, srcID, fake); + bool pass{true}; + if (srcID == 99) + continue; // skip QED + // PtResVec[iTrack]=(mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt; + mPtResolution->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); + mPtResolution2D->Fill(mParticleInfo[srcID][evID][trackID].pt, (mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); + if (!mParticleInfo[srcID][evID][trackID].isPrimary) + mPtResolutionSec->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); + if (mParticleInfo[srcID][evID][trackID].isPrimary) + mPtResolutionPrim->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); + } + for (int yy = 0; yy < 100; yy++) { + aa[yy] = 0.; + sigma[yy] = 0.; + sigmaerr[yy] = 0.; + meanPt[yy] = 0.; + } + for (int yy = 0; yy < 100; yy++) { + TH1D* projh2X = mPtResolution2D->ProjectionY("projh2X", yy, yy + 1, ""); + TF1* f1 = new TF1("f1", "gaus", -0.2, 0.2); + projh2X->Fit("f1"); + if (f1->GetParameter(2) > 0. && f1->GetParameter(2) < 1. && f1->GetParameter(1) < 1.) { + sigma[yy] = f1->GetParameter(2); + sigmaerr[yy] = f1->GetParError(2); + meanPt[yy] = ((8. / 100.) * yy + (8. / 100.) * (yy + 1)) / 2; + aa[yy] = 0.0125; + } + } } void PtResolutionStudy::updateTimeDependentParams(ProcessingContext& pc) @@ -284,13 +278,12 @@ void PtResolutionStudy::endOfStream(EndOfStreamContext& ec) mPtResolutionPrim->SetTitle(";#Delta p_{T}/p_{T_{MC}} ;Entries"); mPtResolutionSec->SetTitle(";#Delta #it{p}_{T}/#it{p}_{T_{MC}} ;Entries"); mPtResolution2D->SetTitle(";#it{p}_{T_{MC}} [GeV];#Delta #it{p}_{T}/#it{p}_{T_{MC}}"); - - + fout.WriteTObject(mPtResolution.get()); fout.WriteTObject(mPtResolutionPrim.get()); fout.WriteTObject(mPtResolutionSec.get()); fout.WriteTObject(mPtResolution2D.get()); - + mCanvasPt = std::make_unique("cPt", "cPt", 1600, 1200); mCanvasPt->cd(); mPtResolution->Draw("HIST"); @@ -309,14 +302,14 @@ void PtResolutionStudy::endOfStream(EndOfStreamContext& ec) mCanvasPt2->Write(); mCanvasPt3 = std::make_unique("cPt3", "cPt3", 1600, 1200); mCanvasPt3->cd(); - - TGraphErrors *g1 = new TGraphErrors(100,meanPt,sigma,aa,sigmaerr); + + TGraphErrors* g1 = new TGraphErrors(100, meanPt, sigma, aa, sigmaerr); g1->SetMarkerStyle(8); g1->SetMarkerColor(kGreen); g1->GetXaxis()->SetTitle("Pt [GeV]"); g1->GetYaxis()->SetTitle("#sigma #Delta #it{p}_{T}/#it{p}_{T_{MC}}"); - g1->GetYaxis()->SetLimits(0,1); - g1->GetXaxis()->SetLimits(0,10.); + g1->GetYaxis()->SetLimits(0, 1); + g1->GetXaxis()->SetLimits(0, 10.); g1->Draw("AP"); g1->GetYaxis()->SetRangeUser(0, 1); g1->GetXaxis()->SetRangeUser(0, 10.); @@ -324,21 +317,21 @@ void PtResolutionStudy::endOfStream(EndOfStreamContext& ec) fout.cd(); mCanvasPt3->Write(); - mCanvasPt4 = std::make_unique("cPt4", "cPt4", 1600, 1200); - mCanvasPt4->cd(); - mPtResolutionPrim->SetName("mPtResolutionPrim"); - mPtResolutionSec->SetName("mPtResolutionSec"); - mPtResolutionPrim->Draw("same hist"); - mPtResolutionSec->Draw("same hist"); - mLegendPt4 = std::make_unique(0.19, 0.8, 0.40, 0.96); - - mLegendPt4->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); - mLegendPt4->AddEntry("mPtResolutionPrim", "Primary events","f"); - mLegendPt4->AddEntry("mPtResolutionSec", "Secondary events","f"); - mLegendPt4->Draw("same"); - mCanvasPt4->SaveAs("ptRes4.png"); - fout.cd(); - mCanvasPt4->Write(); + mCanvasPt4 = std::make_unique("cPt4", "cPt4", 1600, 1200); + mCanvasPt4->cd(); + mPtResolutionPrim->SetName("mPtResolutionPrim"); + mPtResolutionSec->SetName("mPtResolutionSec"); + mPtResolutionPrim->Draw("same hist"); + mPtResolutionSec->Draw("same hist"); + mLegendPt4 = std::make_unique(0.19, 0.8, 0.40, 0.96); + + mLegendPt4->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); + mLegendPt4->AddEntry("mPtResolutionPrim", "Primary events", "f"); + mLegendPt4->AddEntry("mPtResolutionSec", "Secondary events", "f"); + mLegendPt4->Draw("same"); + mCanvasPt4->SaveAs("ptRes4.png"); + fout.cd(); + mCanvasPt4->Write(); fout.Close(); } diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index dc49831e43f0e..5e28203f57ca8 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -119,7 +119,6 @@ class TrackCheckStudy : public Task std::unique_ptr mDenominatorPt; std::unique_ptr mDenominatorEta; - std::unique_ptr mEffPt; std::unique_ptr mEffFakePt; std::unique_ptr mEffClonesPt; @@ -147,8 +146,6 @@ class TrackCheckStudy : public Task std::unique_ptr mEff1FakeEta; std::unique_ptr mEff2FakeEta; std::unique_ptr mEff3FakeEta; - - std::unique_ptr mGoodPt0; std::unique_ptr mGoodPt1; @@ -169,8 +166,6 @@ class TrackCheckStudy : public Task std::unique_ptr mFakeEta1; std::unique_ptr mFakeEta2; std::unique_ptr mFakeEta3; - - std::unique_ptr mPtSec0Pt; std::unique_ptr mPtSec1Pt; @@ -182,7 +177,6 @@ class TrackCheckStudy : public Task std::unique_ptr mPtSec2Eta; std::unique_ptr mPtSec3Eta; - // Canvas & decorations std::unique_ptr mCanvasPt; std::unique_ptr mCanvasPt2; @@ -198,11 +192,10 @@ class TrackCheckStudy : public Task std::unique_ptr mLegendEta2; std::unique_ptr mLegendEta2Fake; - float rLayer0=2.34; - float rLayer1=3.15; - float rLayer2=3.93; - float rLayer3=19.605; - + float rLayer0 = 2.34; + float rLayer1 = 3.15; + float rLayer2 = 3.93; + float rLayer3 = 19.605; // Debug output tree std::unique_ptr mDBGOut; @@ -239,7 +232,6 @@ void TrackCheckStudy::init(InitContext& ic) mDenominatorPt = std::make_unique("denominatorPt", ";#it{p}_{T} (GeV/#it{c});Den", pars.effHistBins, xbins.data()); mDenominatorEta = std::make_unique("denominatorEta", ";#eta;Number of tracks", 60, -3, 3); - mGoodPt0 = std::make_unique("goodPt0", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); mGoodPt1 = std::make_unique("goodPt1", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); mGoodPt2 = std::make_unique("goodPt2", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); @@ -250,7 +242,7 @@ void TrackCheckStudy::init(InitContext& ic) mFakePt2 = std::make_unique("FakePt2", ";#it{p}_{T} (GeV/#it{c});Efficiency (Fake-track rate)", pars.effHistBins, xbins.data()); mFakePt3 = std::make_unique("FakePt3", ";#it{p}_{T} (GeV/#it{c});Efficiency (Fake-track rate)", pars.effHistBins, xbins.data()); - mGoodEta0 = std::make_unique("goodEta0", ";#eta;Number of tracks", 60, -3, 3); + mGoodEta0 = std::make_unique("goodEta0", ";#eta;Number of tracks", 60, -3, 3); mGoodEta1 = std::make_unique("goodEta1", ";#eta;Number of tracks", 60, -3, 3); mGoodEta2 = std::make_unique("goodEta2", ";#eta;Number of tracks", 60, -3, 3); mGoodEta3 = std::make_unique("goodEta3", ";#eta;Number of tracks", 60, -3, 3); @@ -260,15 +252,15 @@ void TrackCheckStudy::init(InitContext& ic) mFakeEta2 = std::make_unique("FakeEta2", ";#eta;Number of tracks", 60, -3, 3); mFakeEta3 = std::make_unique("FakeEta3", ";#eta;Number of tracks", 60, -3, 3); - mPtSec0Pt= std::make_unique("mPtSec0Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})",pars.effHistBins, xbins.data()); - mPtSec1Pt= std::make_unique("mPtSec1Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})",pars.effHistBins, xbins.data()); - mPtSec2Pt= std::make_unique("mPtSec2Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})",pars.effHistBins, xbins.data()); - mPtSec3Pt= std::make_unique("mPtSec3Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})",pars.effHistBins, xbins.data()); + mPtSec0Pt = std::make_unique("mPtSec0Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})", pars.effHistBins, xbins.data()); + mPtSec1Pt = std::make_unique("mPtSec1Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})", pars.effHistBins, xbins.data()); + mPtSec2Pt = std::make_unique("mPtSec2Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})", pars.effHistBins, xbins.data()); + mPtSec3Pt = std::make_unique("mPtSec3Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})", pars.effHistBins, xbins.data()); - mPtSec0Eta= std::make_unique("mPtSec0Eta", ";#eta;Number of tracks", 60, -3, 3); - mPtSec1Eta= std::make_unique("mPtSec1Eta", ";#eta;Number of tracks", 60, -3, 3); - mPtSec2Eta= std::make_unique("mPtSec2Eta", ";#eta;Number of tracks", 60, -3, 3); - mPtSec3Eta= std::make_unique("mPtSec3Eta", ";#eta;Number of tracks", 60, -3, 3); + mPtSec0Eta = std::make_unique("mPtSec0Eta", ";#eta;Number of tracks", 60, -3, 3); + mPtSec1Eta = std::make_unique("mPtSec1Eta", ";#eta;Number of tracks", 60, -3, 3); + mPtSec2Eta = std::make_unique("mPtSec2Eta", ";#eta;Number of tracks", 60, -3, 3); + mPtSec3Eta = std::make_unique("mPtSec3Eta", ";#eta;Number of tracks", 60, -3, 3); mGoodPt0->Sumw2(); mGoodPt1->Sumw2(); @@ -306,7 +298,6 @@ void TrackCheckStudy::init(InitContext& ic) mMultiFake->Sumw2(); mClonePt->Sumw2(); mDenominatorPt->Sumw2(); - } void TrackCheckStudy::run(ProcessingContext& pc) @@ -335,9 +326,9 @@ void TrackCheckStudy::initialiseRun(o2::globaltracking::RecoContainer& recoData) void TrackCheckStudy::process() { LOGP(info, "** Filling particle table ... "); - mParticleInfo.resize(mKineReader->getNSources()); // sources + mParticleInfo.resize(mKineReader->getNSources()); // sources for (int iSource{0}; iSource < mKineReader->getNSources(); ++iSource) { - mParticleInfo[iSource].resize(mKineReader->getNEvents(iSource)); // events + mParticleInfo[iSource].resize(mKineReader->getNEvents(iSource)); // events for (int iEvent{0}; iEvent < mKineReader->getNEvents(iSource); ++iEvent) { mParticleInfo[iSource][iEvent].resize(mKineReader->getTracks(iSource, iEvent).size()); // tracks for (auto iPart{0}; iPart < mKineReader->getTracks(iEvent).size(); ++iPart) { @@ -351,7 +342,7 @@ void TrackCheckStudy::process() mParticleInfo[iSource][iEvent][iPart].vy = part.Vy(); mParticleInfo[iSource][iEvent][iPart].vz = part.Vz(); mParticleInfo[iSource][iEvent][iPart].isPrimary = part.isPrimary(); - //mParticleInfo[iSource][iEvent][iPart].first = part.getFirstDaughterTrackId(); + // mParticleInfo[iSource][iEvent][iPart].first = part.getFirstDaughterTrackId(); } } } @@ -374,9 +365,9 @@ void TrackCheckStudy::process() } LOGP(info, "** Analysing tracks ... "); int unaccounted{0}, good{0}, fakes{0}, total{0}; - int good0=0,good1=0,good2=0,good3=0, totalsec=0;//secondary - int fake0=0,fake1=0,fake2=0,fake3=0; - int totsec0=0,totsec1=0,totsec2=0,totsec3=0; + int good0 = 0, good1 = 0, good2 = 0, good3 = 0, totalsec = 0; // secondary + int fake0 = 0, fake1 = 0, fake2 = 0, fake3 = 0; + int totsec0 = 0, totsec1 = 0, totsec2 = 0, totsec3 = 0; for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { auto& lab = mTracksMCLabels[iTrack]; if (!lab.isSet() || lab.isNoise()) { @@ -401,8 +392,6 @@ void TrackCheckStudy::process() } fakes += fake; good += !fake; - - } LOGP(info, "** Some statistics:"); LOGP(info, "\t- Total number of tracks: {}", mTracks.size()); @@ -410,9 +399,6 @@ void TrackCheckStudy::process() LOGP(info, "\t- Total number of fakes: {} ({:.2f} %)", fakes, fakes * 100. / mTracks.size()); LOGP(info, "\t- Total number of good: {} ({:.2f} %)", good, good * 100. / mTracks.size()); - - - LOGP(info, "** Filling histograms ... "); // Currently process only sourceID = 0, to be extended later if needed @@ -424,8 +410,7 @@ void TrackCheckStudy::process() // part.clusters != 0x0f && part.clusters != 0x0f << 1 && part.clusters != 0x0f << 2 && part.clusters != 0x0f << 3) { continue; } - if (part.isPrimary) - { + if (part.isPrimary) { mDenominatorPt->Fill(part.pt); mDenominatorEta->Fill(part.eta); if (part.isReco) { @@ -449,97 +434,87 @@ void TrackCheckStudy::process() } } - if(!part.isPrimary){ + if (!part.isPrimary) { totalsec++; - float rad=sqrt(pow(part.vx,2)+pow(part.vy,2)); - if (rad< rLayer0)// layer 0 + float rad = sqrt(pow(part.vx, 2) + pow(part.vy, 2)); + if (rad < rLayer0) // layer 0 { totsec0++; mPtSec0Pt->Fill(part.pt); mPtSec0Eta->Fill(part.eta); - - if (part.isReco) - { + + if (part.isReco) { mGoodPt0->Fill(part.pt); mGoodEta0->Fill(part.eta); good0++; - } - if (part.isFake) - { + } + if (part.isFake) { mFakePt0->Fill(part.pt); mFakeEta0->Fill(part.eta); fake0++; } } - if (rad< rLayer1 && rad> rLayer0 )// layer 1 + if (rad < rLayer1 && rad > rLayer0) // layer 1 { totsec1++; mPtSec1Pt->Fill(part.pt); mPtSec1Eta->Fill(part.eta); - if (part.isReco) - { + if (part.isReco) { mGoodPt1->Fill(part.pt); mGoodEta1->Fill(part.eta); good1++; - } - if (part.isFake) - { + } + if (part.isFake) { mFakePt1->Fill(part.pt); mFakeEta1->Fill(part.eta); fake1++; } } - if (rad< rLayer2 && rad> rLayer1 )// layer 2 + if (rad < rLayer2 && rad > rLayer1) // layer 2 { totsec2++; mPtSec2Pt->Fill(part.pt); mPtSec2Eta->Fill(part.eta); - if (part.isReco) - { + if (part.isReco) { mGoodPt2->Fill(part.pt); mGoodEta2->Fill(part.eta); good2++; - } - if (part.isFake) - { + } + if (part.isFake) { mFakePt2->Fill(part.pt); mFakeEta2->Fill(part.eta); fake2++; } } - if (rad< rLayer3 && rad> rLayer2 )// layer 3 + if (rad < rLayer3 && rad > rLayer2) // layer 3 { totsec3++; mPtSec3Pt->Fill(part.pt); mPtSec3Eta->Fill(part.eta); - if (part.isReco) - { + if (part.isReco) { mGoodPt3->Fill(part.pt); mGoodEta3->Fill(part.eta); good3++; - } - if (part.isFake) - { + } + if (part.isFake) { mFakePt3->Fill(part.pt); mFakeEta3->Fill(part.eta); fake3++; } - } + } } } } LOGP(info, "** Some statistics on secondary tracks:"); LOGP(info, "\t- Total number of secondary tracks: {}", totalsec); - LOGP(info, "\t- Total number of secondary tracks on layer O: {}, good: {}, fake: {}", totsec0,good0,fake0); - LOGP(info, "\t- Total number of secondary tracks on layer 1: {}, good: {}, fake: {}", totsec1,good1,fake1); - LOGP(info, "\t- Total number of secondary tracks on layer 2: {}, good: {}, fake: {}", totsec2,good2,fake2); - LOGP(info, "\t- Total number of secondary tracks on layer 3: {}, good: {}, fake: {}", totsec3,good3,fake3); - - + LOGP(info, "\t- Total number of secondary tracks on layer O: {}, good: {}, fake: {}", totsec0, good0, fake0); + LOGP(info, "\t- Total number of secondary tracks on layer 1: {}, good: {}, fake: {}", totsec1, good1, fake1); + LOGP(info, "\t- Total number of secondary tracks on layer 2: {}, good: {}, fake: {}", totsec2, good2, fake2); + LOGP(info, "\t- Total number of secondary tracks on layer 3: {}, good: {}, fake: {}", totsec3, good3, fake3); LOGP(info, "** Computing efficiencies ..."); @@ -653,7 +628,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEffClonesEta->SetDirectory(gDirectory); fout.WriteTObject(mEffClonesEta.get()); - mEff0Pt->SetName("Good_pt0");//******LAYER 0****** + mEff0Pt->SetName("Good_pt0"); //******LAYER 0****** mEff0Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); mEff0Pt->SetLineColor(kAzure + 4); mEff0Pt->SetLineColorAlpha(kAzure + 4, 1); @@ -676,7 +651,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) fout.WriteTObject(mEff0FakePt.get()); mEff0Eta->SetName("Good_eta0"); - mEff0Eta->SetTitle(";#eta;efficiency secondary particle" ); + mEff0Eta->SetTitle(";#eta;efficiency secondary particle"); mEff0Eta->SetLineColor(kAzure + 4); mEff0Eta->SetLineColorAlpha(kAzure + 4, 1); mEff0Eta->SetLineWidth(2); @@ -687,7 +662,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) fout.WriteTObject(mEff0Eta.get()); mEff0FakeEta->SetName("Fake_eta0"); - mEff0FakeEta->SetTitle(";#eta;efficiency secondary particle" ); + mEff0FakeEta->SetTitle(";#eta;efficiency secondary particle"); mEff0FakeEta->SetLineColor(kAzure + 4); mEff0FakeEta->SetLineColorAlpha(kAzure + 4, 1); mEff0FakeEta->SetLineWidth(2); @@ -697,12 +672,12 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff0FakeEta->SetDirectory(gDirectory); fout.WriteTObject(mEff0FakeEta.get()); - mEff1Pt->SetName("Good_pt1");//*****LAYER 1 ******** + mEff1Pt->SetName("Good_pt1"); //*****LAYER 1 ******** mEff1Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); mEff1Pt->SetLineColor(kRed); - mEff1Pt->SetLineColorAlpha(kRed ,1 ); + mEff1Pt->SetLineColorAlpha(kRed, 1); mEff1Pt->SetLineWidth(2); - mEff1Pt->SetMarkerColorAlpha(kRed , 1); + mEff1Pt->SetMarkerColorAlpha(kRed, 1); mEff1Pt->SetMarkerStyle(kFullCircle); mEff1Pt->SetMarkerSize(1.7); mEff1Pt->SetDirectory(gDirectory); @@ -711,9 +686,9 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff1FakePt->SetName("Fake_pt1"); mEff1FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); mEff1FakePt->SetLineColor(kRed); - mEff1FakePt->SetLineColorAlpha(kRed,1); + mEff1FakePt->SetLineColorAlpha(kRed, 1); mEff1FakePt->SetLineWidth(2); - mEff1FakePt->SetMarkerColorAlpha(kRed,1); + mEff1FakePt->SetMarkerColorAlpha(kRed, 1); mEff1FakePt->SetMarkerStyle(kFullCircle); mEff1FakePt->SetMarkerSize(1.7); mEff1FakePt->SetDirectory(gDirectory); @@ -722,9 +697,9 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff1Eta->SetName("Good_eta1"); mEff1Eta->SetTitle(";#eta;efficiency secondary particle"); mEff1Eta->SetLineColor(kRed); - mEff1Eta->SetLineColorAlpha(kRed ,1 ); + mEff1Eta->SetLineColorAlpha(kRed, 1); mEff1Eta->SetLineWidth(2); - mEff1Eta->SetMarkerColorAlpha(kRed , 1); + mEff1Eta->SetMarkerColorAlpha(kRed, 1); mEff1Eta->SetMarkerStyle(kFullCircle); mEff1Eta->SetMarkerSize(1.7); mEff1Eta->SetDirectory(gDirectory); @@ -733,20 +708,20 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff1FakeEta->SetName("Fake_eta1"); mEff1FakeEta->SetTitle(";#eta;efficiency secondary particle"); mEff1FakeEta->SetLineColor(kRed); - mEff1FakeEta->SetLineColorAlpha(kRed,1); + mEff1FakeEta->SetLineColorAlpha(kRed, 1); mEff1FakeEta->SetLineWidth(2); - mEff1FakeEta->SetMarkerColorAlpha(kRed,1); + mEff1FakeEta->SetMarkerColorAlpha(kRed, 1); mEff1FakeEta->SetMarkerStyle(kFullCircle); mEff1FakeEta->SetMarkerSize(1.7); mEff1FakeEta->SetDirectory(gDirectory); fout.WriteTObject(mEff1FakeEta.get()); - mEff2Pt->SetName("Good_pt2");//*****LAYER 2 ******** + mEff2Pt->SetName("Good_pt2"); //*****LAYER 2 ******** mEff2Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff2Pt->SetLineColor(kGreen+1); - mEff2Pt->SetLineColorAlpha(kGreen +1 , 1); + mEff2Pt->SetLineColor(kGreen + 1); + mEff2Pt->SetLineColorAlpha(kGreen + 1, 1); mEff2Pt->SetLineWidth(2); - mEff2Pt->SetMarkerColorAlpha(kGreen+1 , 1); + mEff2Pt->SetMarkerColorAlpha(kGreen + 1, 1); mEff2Pt->SetMarkerStyle(kFullCircle); mEff2Pt->SetMarkerSize(1.7); mEff2Pt->SetDirectory(gDirectory); @@ -754,10 +729,10 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff2FakePt->SetName("Fake_pt2"); mEff2FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff2FakePt->SetLineColor(kGreen+1); - mEff2FakePt->SetLineColorAlpha(kGreen+1 , 1); + mEff2FakePt->SetLineColor(kGreen + 1); + mEff2FakePt->SetLineColorAlpha(kGreen + 1, 1); mEff2FakePt->SetLineWidth(2); - mEff2FakePt->SetMarkerColorAlpha(kGreen+1 , 1); + mEff2FakePt->SetMarkerColorAlpha(kGreen + 1, 1); mEff2FakePt->SetMarkerStyle(kFullCircle); mEff2FakePt->SetMarkerSize(1.7); mEff2FakePt->SetDirectory(gDirectory); @@ -765,10 +740,10 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff2Eta->SetName("Good_eta2"); mEff2Eta->SetTitle(";#eta;efficiency secondary particle"); - mEff2Eta->SetLineColor(kGreen +1); - mEff2Eta->SetLineColorAlpha(kGreen +1 ,1 ); + mEff2Eta->SetLineColor(kGreen + 1); + mEff2Eta->SetLineColorAlpha(kGreen + 1, 1); mEff2Eta->SetLineWidth(2); - mEff2Eta->SetMarkerColorAlpha(kGreen +1 , 1); + mEff2Eta->SetMarkerColorAlpha(kGreen + 1, 1); mEff2Eta->SetMarkerStyle(kFullCircle); mEff2Eta->SetMarkerSize(1.7); mEff2Eta->SetDirectory(gDirectory); @@ -776,21 +751,21 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff2FakeEta->SetName("Fake_eta2"); mEff2FakeEta->SetTitle(";#eta;efficiency secondary particle"); - mEff2FakeEta->SetLineColor(kGreen +1); - mEff2FakeEta->SetLineColorAlpha(kGreen +1,1); + mEff2FakeEta->SetLineColor(kGreen + 1); + mEff2FakeEta->SetLineColorAlpha(kGreen + 1, 1); mEff2FakeEta->SetLineWidth(2); - mEff2FakeEta->SetMarkerColorAlpha(kGreen +1,1); + mEff2FakeEta->SetMarkerColorAlpha(kGreen + 1, 1); mEff2FakeEta->SetMarkerStyle(kFullCircle); mEff2FakeEta->SetMarkerSize(1.7); mEff2FakeEta->SetDirectory(gDirectory); fout.WriteTObject(mEff2FakeEta.get()); - mEff3Pt->SetName("Good_pt3");//*****LAYER 3 ******** + mEff3Pt->SetName("Good_pt3"); //*****LAYER 3 ******** mEff3Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff3Pt->SetLineColor(kOrange-3); - mEff3Pt->SetLineColorAlpha(kOrange -3 , 1); + mEff3Pt->SetLineColor(kOrange - 3); + mEff3Pt->SetLineColorAlpha(kOrange - 3, 1); mEff3Pt->SetLineWidth(2); - mEff3Pt->SetMarkerColorAlpha(kOrange-3 , 1); + mEff3Pt->SetMarkerColorAlpha(kOrange - 3, 1); mEff3Pt->SetMarkerStyle(kFullCircle); mEff3Pt->SetMarkerSize(1.7); mEff3Pt->SetDirectory(gDirectory); @@ -798,10 +773,10 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff3FakePt->SetName("Fake_pt3"); mEff3FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff3FakePt->SetLineColor(kOrange-3); - mEff3FakePt->SetLineColorAlpha(kOrange-3,1); + mEff3FakePt->SetLineColor(kOrange - 3); + mEff3FakePt->SetLineColorAlpha(kOrange - 3, 1); mEff3FakePt->SetLineWidth(2); - mEff3FakePt->SetMarkerColorAlpha(kOrange-3,1); + mEff3FakePt->SetMarkerColorAlpha(kOrange - 3, 1); mEff3FakePt->SetMarkerStyle(kFullCircle); mEff3FakePt->SetMarkerSize(1.7); mEff3FakePt->SetDirectory(gDirectory); @@ -809,10 +784,10 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff3Eta->SetName("Good_eta3"); mEff3Eta->SetTitle(";#eta;efficiency secondary particle"); - mEff3Eta->SetLineColor(kOrange -3); - mEff3Eta->SetLineColorAlpha(kOrange -3 ,1 ); + mEff3Eta->SetLineColor(kOrange - 3); + mEff3Eta->SetLineColorAlpha(kOrange - 3, 1); mEff3Eta->SetLineWidth(2); - mEff3Eta->SetMarkerColorAlpha(kOrange -3 , 1); + mEff3Eta->SetMarkerColorAlpha(kOrange - 3, 1); mEff3Eta->SetMarkerStyle(kFullCircle); mEff3Eta->SetMarkerSize(1.7); mEff3Eta->SetDirectory(gDirectory); @@ -820,17 +795,14 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff3FakeEta->SetName("Fake_eta3"); mEff3FakeEta->SetTitle(";#eta;efficiency secondary particle"); - mEff3FakeEta->SetLineColor(kOrange -3); - mEff3FakeEta->SetLineColorAlpha(kOrange -3,1); + mEff3FakeEta->SetLineColor(kOrange - 3); + mEff3FakeEta->SetLineColorAlpha(kOrange - 3, 1); mEff3FakeEta->SetLineWidth(2); - mEff3FakeEta->SetMarkerColorAlpha(kOrange -3,1); + mEff3FakeEta->SetMarkerColorAlpha(kOrange - 3, 1); mEff3FakeEta->SetMarkerStyle(kFullCircle); mEff3FakeEta->SetMarkerSize(1.7); mEff3FakeEta->SetDirectory(gDirectory); fout.WriteTObject(mEff3FakeEta.get()); - - - // Paint the histograms // todo: delegate to a dedicated helper @@ -884,8 +856,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff1Pt->Draw("pz same"); mEff2Pt->Draw("pz same"); mEff3Pt->Draw("pz same"); - - + mLegendPt2 = std::make_unique(0.19, 0.8, 0.40, 0.96); mLegendPt2->SetHeader(Form("%zu events PP, good tracks", mKineReader->getNEvents(0)), "C"); mLegendPt2->AddEntry("Good_pt0", "Layer 0", "lep"); @@ -898,14 +869,13 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasEta2 = std::make_unique("cEta2", "cEta2", 1600, 1200); mCanvasEta2->cd(); - + mCanvasEta2->SetGrid(); mEff0Eta->Draw("pz"); mEff1Eta->Draw("pz same"); mEff2Eta->Draw("pz same"); mEff3Eta->Draw("pz same"); - - + mLegendEta2 = std::make_unique(0.19, 0.8, 0.40, 0.96); mLegendEta2->SetHeader(Form("%zu events PP, good tracks", mKineReader->getNEvents(0)), "C"); mLegendEta2->AddEntry("Good_eta0", "Layer 0", "lep"); @@ -916,8 +886,6 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mLegendEta2->Draw(); mCanvasEta2->SaveAs("eff_sec_eta.png"); - - mCanvasPt2fake = std::make_unique("cPt2fake", "cPt2fake", 1600, 1200); mCanvasPt2fake->cd(); mCanvasPt2fake->SetLogx(); @@ -926,7 +894,6 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEff1FakePt->Draw("pz same"); mEff2FakePt->Draw("pz same"); mEff3FakePt->Draw("pz same"); - mLegendPt2Fake = std::make_unique(0.19, 0.8, 0.40, 0.96); mLegendPt2Fake->SetHeader(Form("%zu events PP, fake tracks ", mKineReader->getNEvents(0)), "C"); @@ -934,20 +901,18 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mLegendPt2Fake->AddEntry("Fake_pt1", "Layer 1", "lep"); mLegendPt2Fake->AddEntry("Fake_pt2", "Layer 2", "lep"); mLegendPt2Fake->AddEntry("Fake_pt3", "Layer 3", "lep"); - - + mLegendPt2Fake->Draw(); mCanvasPt2fake->SaveAs("eff_sec_pt_fake.png"); mCanvasEta2fake = std::make_unique("cEta2fake", "cEta2fake", 1600, 1200); mCanvasEta2fake->cd(); - + mCanvasEta2fake->SetGrid(); mEff0FakeEta->Draw("pz"); mEff1FakeEta->Draw("pz same"); mEff2FakeEta->Draw("pz same"); mEff3FakeEta->Draw("pz same"); - mLegendEta2Fake = std::make_unique(0.19, 0.8, 0.40, 0.96); mLegendEta2Fake->SetHeader(Form("%zu events PP, fake tracks ", mKineReader->getNEvents(0)), "C"); @@ -955,12 +920,10 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mLegendEta2Fake->AddEntry("Fake_eta1", "Layer 1", "lep"); mLegendEta2Fake->AddEntry("Fake_eta2", "Layer 2", "lep"); mLegendEta2Fake->AddEntry("Fake_eta3", "Layer 3", "lep"); - - + mLegendEta2Fake->Draw(); mCanvasEta2fake->SaveAs("eff_sec_Eta_fake.png"); - fout.cd(); mCanvasPt->Write(); mCanvasEta->Write(); @@ -968,7 +931,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasPt2fake->Write(); mCanvasEta2->Write(); mCanvasEta2fake->Write(); - + fout.Close(); } diff --git a/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx b/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx index 57a73e785218b..44051e00cb06b 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx @@ -63,8 +63,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext) GID::mask_t srcCls = allowedSourcesClus & GID::getSourcesMask(configcontext.options().get("cluster-sources")); o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, useMC, srcCls, srcTrc); - //o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC); - //o2::globaltracking::InputHelper::addInputSpecsSVertex(configcontext, specs); + // o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC); + // o2::globaltracking::InputHelper::addInputSpecsSVertex(configcontext, specs); std::shared_ptr mcKinematicsReader; if (useMC) { From b2de5e810101fca94da246280c3755e61a466a6a Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Mon, 14 Aug 2023 17:31:09 +0200 Subject: [PATCH 03/19] Add Pt res study at TrackChech --- .../ITS/postprocessing/studies/CMakeLists.txt | 1 - .../studies/include/ITSStudies/PtResolution.h | 39 -- .../studies/src/ITSStudiesConfigParam.cxx | 1 - .../studies/src/ITSStudiesLinkDef.h | 1 - .../studies/src/PtResolution.cxx | 368 ------------------ .../postprocessing/studies/src/TrackCheck.cxx | 134 ++++++- .../standalone-postprocessing-workflow.cxx | 6 - 7 files changed, 133 insertions(+), 417 deletions(-) delete mode 100644 Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h delete mode 100644 Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt b/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt index bbe9185e255bb..d1b8866c00b7a 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt @@ -14,7 +14,6 @@ o2_add_library(ITSPostprocessing src/AvgClusSize.cxx src/ITSStudiesConfigParam.cxx src/TrackCheck.cxx - src/PtResolution.cxx src/ITSStudiesConfigParam.cxx PUBLIC_LINK_LIBRARIES O2::GlobalTracking O2::GlobalTrackingWorkflowReaders diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h deleted file mode 100644 index 9980814edac75..0000000000000 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/PtResolution.h +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -/// \file PtResolution.h -/// \author Roberta Ferioli roberta.ferioli@cern.ch - -#ifndef O2_PT_RESOLUTION_STUDY_H -#define O2_PT_RESOLUTION_STUDY_H - -#include -#include -#include - -namespace o2 -{ -namespace steer -{ -class MCKinematicsReader; -} -namespace its -{ -namespace study -{ -using mask_t = o2::dataformats::GlobalTrackID::mask_t; - -o2::framework::DataProcessorSpec getPtResolutionStudy(mask_t srcTracksMask, mask_t srcClustersMask, bool useMC, std::shared_ptr kineReader); -} // namespace study -} // namespace its -} // namespace o2 - -#endif // O2_PT_RESOLUTION_STUDY \ No newline at end of file diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx index cc725c8f6f10a..851bb996426c4 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx @@ -23,7 +23,6 @@ static auto& sPtResParamsITS = o2::its::study::ITSPtTracksResParamConfig::Instan O2ParamImpl(o2::its::study::ITSAvgClusSizeParamConfig); O2ParamImpl(o2::its::study::ITSCheckTracksParamConfig); -O2ParamImpl(o2::its::study::ITSPtTracksResParamConfig); } // namespace study } // namespace its diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h index 2f4d413a55586..a0c483fb774a5 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesLinkDef.h @@ -18,6 +18,5 @@ #pragma link C++ class o2::its::study::ITSAvgClusSizeParamConfig + ; #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::study::ITSAvgClusSizeParamConfig> + ; #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::study::ITSCheckTracksParamConfig> + ; -#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::study::ITSPtTracksResParamConfig> + ; #endif \ No newline at end of file diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx deleted file mode 100644 index c6ac399f744eb..0000000000000 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/PtResolution.cxx +++ /dev/null @@ -1,368 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -/// \file PtResolution.cxx.cxx -/// \brief Study on Pt resolution per track in the ITS -/// \author Roberta Ferioli roberta.ferioli@cern.ch -#include -#include "ITSStudies/ITSStudiesConfigParam.h" - -#include "DataFormatsITS/TrackITS.h" -#include "SimulationDataFormat/MCTrack.h" -#include "DataFormatsITSMFT/CompCluster.h" -#include "DataFormatsGlobalTracking/RecoContainer.h" -#include "CommonUtils/TreeStreamRedirector.h" - -#include "Framework/Task.h" -#include "Steer/MCKinematicsReader.h" -#include "ITSBase/GeometryTGeo.h" -#include "DetectorsBase/GRPGeomHelper.h" - -#include -#include -#include -#include -#include -#include -#include -#include -namespace o2 -{ -namespace its -{ -namespace study -{ -using namespace o2::framework; -using namespace o2::globaltracking; - -using GTrackID = o2::dataformats::GlobalTrackID; -using o2::steer::MCKinematicsReader; -class PtResolutionStudy : public Task -{ - struct ParticleInfo { - int event; - int pdg; - float pt; - float eta; - float phi; - int mother; - int first; - float vx; - float vy; - float vz; - unsigned short clusters = 0u; - unsigned char isReco = 0u; - unsigned char isFake = 0u; - bool isPrimary = 0u; - unsigned char storedStatus = 2; /// not stored = 2, fake = 1, good = 0 - o2::its::TrackITS track; - }; - - public: - PtResolutionStudy(std::shared_ptr dr, - mask_t src, - bool useMC, - std::shared_ptr kineReader, - std::shared_ptr gr) : mDataRequest(dr), mTracksSrc(src), mKineReader(kineReader), mGGCCDBRequest(gr) - { - if (useMC) { - LOGP(info, "Read MCKine reader with {} sources", mKineReader->getNSources()); - } - } - ~PtResolutionStudy() final = default; - void init(InitContext&) final; - void run(ProcessingContext&) final; - void endOfStream(EndOfStreamContext&) final; - void finaliseCCDB(ConcreteDataMatcher&, void*) final; - void initialiseRun(o2::globaltracking::RecoContainer&); - void process(); - - private: - void updateTimeDependentParams(ProcessingContext& pc); - std::string mOutFileName = "TrackPtResolutionStudy.root"; - std::shared_ptr mKineReader; - GeometryTGeo* mGeometry; - - // Spans - gsl::span mTracksROFRecords; - gsl::span mTracks; - gsl::span mTracksMCLabels; - gsl::span mClusters; - const o2::dataformats::MCLabelContainer* mClustersMCLCont; - - // Data - GTrackID::mask_t mTracksSrc{}; - std::shared_ptr mDataRequest; - std::vector>> mParticleInfo; // src/event/track - unsigned short mMask = 0x7f; - - // Utils - std::shared_ptr mGGCCDBRequest; - - // Histos - std::unique_ptr mPtResolution; - std::unique_ptr mPtResolution2D; - std::unique_ptr mPtResolutionSec; - std::unique_ptr mPtResolutionPrim; - std::unique_ptr mPtResolutionSec2D; - std::unique_ptr g1; - - // Canvas & decorations - std::unique_ptr mLegendPt; - std::unique_ptr mLegendPt4; - std::unique_ptr mCanvasPt; - std::unique_ptr mCanvasPt2; - std::unique_ptr mCanvasPt3; - std::unique_ptr mCanvasPt4; - // Debug output tree - std::unique_ptr mDBGOut; - double sigma[100]; - double sigmaerr[100]; - double meanPt[100]; - double aa[100]; - int bb = 0; -}; - -void PtResolutionStudy::init(InitContext& ic) -{ - o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest); - - auto& pars = o2::its::study::ITSPtTracksResParamConfig::Instance(); - mOutFileName = pars.outFileName; - mMask = pars.trackLengthMask; - - mPtResolution = std::make_unique("PtResolution", ";#it{p}_{T} ;Den", 100, -1, 1); - mPtResolutionSec = std::make_unique("PtResolutionSec", ";#it{p}_{T} ;Den", 100, -1, 1); - mPtResolutionPrim = std::make_unique("PtResolutionPrim", ";#it{p}_{T} ;Den", 100, -1, 1); - mPtResolution2D = std::make_unique("#it{p}_{T} Resolution vs #it{p}_{T}", ";#it{p}_{T} (GeV/#it{c});#Delta p_{T}/p_{T_{MC}", 100, 0, 10, 100, -1, 1); - mPtResolutionSec2D = std::make_unique("#it{p}_{T} Resolution vs #it{p}_{T} sec ", ";#it{p}_{T} (GeV/#it{c});#Delta p_{T}/p_{T_{MC}", 100, 0, 10, 100, -1, 1); - mPtResolution->Sumw2(); - mPtResolutionSec->Sumw2(); - mPtResolutionPrim->Sumw2(); -} - -void PtResolutionStudy::run(ProcessingContext& pc) -{ - o2::globaltracking::RecoContainer recoData; - recoData.collectData(pc, *mDataRequest.get()); - LOGP(info, "*****RUN*****"); - updateTimeDependentParams(pc); // Make sure this is called after recoData.collectData, which may load some conditions - initialiseRun(recoData); - process(); -} - -void PtResolutionStudy::initialiseRun(o2::globaltracking::RecoContainer& recoData) -{ - mTracksROFRecords = recoData.getITSTracksROFRecords(); - mTracks = recoData.getITSTracks(); - mTracksMCLabels = recoData.getITSTracksMCLabels(); - LOGP(info, "***** INITI RUN*****"); - LOGP(info, "** Found in {} rofs:\n\t- {} tracks with {} labels", - mTracksROFRecords.size(), mTracks.size(), mTracksMCLabels.size()); - LOGP(info, "** Found {} sources from kinematic files", mKineReader->getNSources()); -} - -void PtResolutionStudy::process() -{ - LOGP(info, "** Filling particle table ... "); - mParticleInfo.resize(mKineReader->getNSources()); // sources - for (int iSource{0}; iSource < mKineReader->getNSources(); ++iSource) { - mParticleInfo[iSource].resize(mKineReader->getNEvents(iSource)); // events - for (int iEvent{0}; iEvent < mKineReader->getNEvents(iSource); ++iEvent) { - mParticleInfo[iSource][iEvent].resize(mKineReader->getTracks(iSource, iEvent).size()); // tracks - for (auto iPart{0}; iPart < mKineReader->getTracks(iEvent).size(); ++iPart) { - auto& part = mKineReader->getTracks(iSource, iEvent)[iPart]; - mParticleInfo[iSource][iEvent][iPart].event = iEvent; - mParticleInfo[iSource][iEvent][iPart].pdg = part.GetPdgCode(); - mParticleInfo[iSource][iEvent][iPart].pt = part.GetPt(); - mParticleInfo[iSource][iEvent][iPart].phi = part.GetPhi(); - mParticleInfo[iSource][iEvent][iPart].eta = part.GetEta(); - mParticleInfo[iSource][iEvent][iPart].isPrimary = part.isPrimary(); - mParticleInfo[iSource][iEvent][iPart].vx = part.Vx(); - mParticleInfo[iSource][iEvent][iPart].vy = part.Vy(); - mParticleInfo[iSource][iEvent][iPart].vz = part.Vz(); - mParticleInfo[iSource][iEvent][iPart].first = part.getFirstDaughterTrackId(); - } - } - } - LOGP(info, "** Analysing tracks ... "); - int good{0}, fakes{0}, total{0}; - for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { - auto& lab = mTracksMCLabels[iTrack]; - if (!lab.isSet() || lab.isNoise()) { - continue; - } - int trackID, evID, srcID; - bool fake; - const_cast(lab).get(trackID, evID, srcID, fake); - bool pass{true}; - - if (srcID == 99) { // skip QED - continue; - } - - mParticleInfo[srcID][evID][trackID].isReco += !fake; - mParticleInfo[srcID][evID][trackID].isFake += fake; - if (mTracks[iTrack].isBetter(mParticleInfo[srcID][evID][trackID].track, 1.e9)) { - mParticleInfo[srcID][evID][trackID].storedStatus = fake; - mParticleInfo[srcID][evID][trackID].track = mTracks[iTrack]; - } - fakes += fake; - good += !fake; - } - LOGP(info, "** Analysing pT resolution..."); - for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { - auto& lab = mTracksMCLabels[iTrack]; - if (!lab.isSet() || lab.isNoise()) - continue; - int trackID, evID, srcID; - bool fake; - const_cast(lab).get(trackID, evID, srcID, fake); - bool pass{true}; - if (srcID == 99) - continue; // skip QED - // PtResVec[iTrack]=(mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt; - mPtResolution->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); - mPtResolution2D->Fill(mParticleInfo[srcID][evID][trackID].pt, (mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); - if (!mParticleInfo[srcID][evID][trackID].isPrimary) - mPtResolutionSec->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); - if (mParticleInfo[srcID][evID][trackID].isPrimary) - mPtResolutionPrim->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); - } - for (int yy = 0; yy < 100; yy++) { - aa[yy] = 0.; - sigma[yy] = 0.; - sigmaerr[yy] = 0.; - meanPt[yy] = 0.; - } - - for (int yy = 0; yy < 100; yy++) { - TH1D* projh2X = mPtResolution2D->ProjectionY("projh2X", yy, yy + 1, ""); - TF1* f1 = new TF1("f1", "gaus", -0.2, 0.2); - projh2X->Fit("f1"); - if (f1->GetParameter(2) > 0. && f1->GetParameter(2) < 1. && f1->GetParameter(1) < 1.) { - sigma[yy] = f1->GetParameter(2); - sigmaerr[yy] = f1->GetParError(2); - meanPt[yy] = ((8. / 100.) * yy + (8. / 100.) * (yy + 1)) / 2; - aa[yy] = 0.0125; - } - } -} - -void PtResolutionStudy::updateTimeDependentParams(ProcessingContext& pc) -{ - static bool initOnceDone = false; - o2::base::GRPGeomHelper::instance().checkUpdates(pc); - if (!initOnceDone) { // this params need to be queried only once - initOnceDone = true; - mGeometry = GeometryTGeo::Instance(); - mGeometry->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G)); - } -} -void PtResolutionStudy::endOfStream(EndOfStreamContext& ec) -{ - TFile fout(mOutFileName.c_str(), "recreate"); - mPtResolution->SetName("#it{p}_{T} resolution"); - mPtResolution->SetTitle(";#Delta p_{T}/p_{T_{MC}} ;Entries"); - mPtResolution->SetFillColor(kAzure + 4); - mPtResolutionPrim->SetFillColor(kRed); - mPtResolutionSec->SetFillColor(kOrange); - mPtResolutionPrim->SetTitle(";#Delta p_{T}/p_{T_{MC}} ;Entries"); - mPtResolutionSec->SetTitle(";#Delta #it{p}_{T}/#it{p}_{T_{MC}} ;Entries"); - mPtResolution2D->SetTitle(";#it{p}_{T_{MC}} [GeV];#Delta #it{p}_{T}/#it{p}_{T_{MC}}"); - - fout.WriteTObject(mPtResolution.get()); - fout.WriteTObject(mPtResolutionPrim.get()); - fout.WriteTObject(mPtResolutionSec.get()); - fout.WriteTObject(mPtResolution2D.get()); - - mCanvasPt = std::make_unique("cPt", "cPt", 1600, 1200); - mCanvasPt->cd(); - mPtResolution->Draw("HIST"); - mLegendPt = std::make_unique(0.19, 0.8, 0.40, 0.96); - mLegendPt->SetHeader(Form("%zu events PP min bias", mKineReader->getNEvents(0)), "C"); - mLegendPt->AddEntry("mPtResolution", "All events", "lep"); - mLegendPt->Draw(); - mCanvasPt->SaveAs("ptRes.png"); - fout.cd(); - mCanvasPt->Write(); - mCanvasPt2 = std::make_unique("cPt2", "cPt2", 1600, 1200); - mCanvasPt2->cd(); - mPtResolution2D->Draw(); - mCanvasPt2->SaveAs("ptRes2.png"); - fout.cd(); - mCanvasPt2->Write(); - mCanvasPt3 = std::make_unique("cPt3", "cPt3", 1600, 1200); - mCanvasPt3->cd(); - - TGraphErrors* g1 = new TGraphErrors(100, meanPt, sigma, aa, sigmaerr); - g1->SetMarkerStyle(8); - g1->SetMarkerColor(kGreen); - g1->GetXaxis()->SetTitle("Pt [GeV]"); - g1->GetYaxis()->SetTitle("#sigma #Delta #it{p}_{T}/#it{p}_{T_{MC}}"); - g1->GetYaxis()->SetLimits(0, 1); - g1->GetXaxis()->SetLimits(0, 10.); - g1->Draw("AP"); - g1->GetYaxis()->SetRangeUser(0, 1); - g1->GetXaxis()->SetRangeUser(0, 10.); - mCanvasPt3->SaveAs("ptRes3.png"); - fout.cd(); - mCanvasPt3->Write(); - - mCanvasPt4 = std::make_unique("cPt4", "cPt4", 1600, 1200); - mCanvasPt4->cd(); - mPtResolutionPrim->SetName("mPtResolutionPrim"); - mPtResolutionSec->SetName("mPtResolutionSec"); - mPtResolutionPrim->Draw("same hist"); - mPtResolutionSec->Draw("same hist"); - mLegendPt4 = std::make_unique(0.19, 0.8, 0.40, 0.96); - - mLegendPt4->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); - mLegendPt4->AddEntry("mPtResolutionPrim", "Primary events", "f"); - mLegendPt4->AddEntry("mPtResolutionSec", "Secondary events", "f"); - mLegendPt4->Draw("same"); - mCanvasPt4->SaveAs("ptRes4.png"); - fout.cd(); - mCanvasPt4->Write(); - - fout.Close(); -} - -void PtResolutionStudy::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) -{ -} - -DataProcessorSpec getPtResolutionStudy(mask_t srcTracksMask, mask_t srcClustersMask, bool useMC, std::shared_ptr kineReader) -{ - std::vector outputs; - auto dataRequest = std::make_shared(); - dataRequest->requestTracks(srcTracksMask, useMC); - - auto ggRequest = std::make_shared(false, // orbitResetTime - true, // GRPECS=true - false, // GRPLHCIF - true, // GRPMagField - true, // askMatLUT - o2::base::GRPGeomRequest::Aligned, // geometry - dataRequest->inputs, - true); - - return DataProcessorSpec{ - "its-study-tracks-pt-resolution", - dataRequest->inputs, - outputs, - AlgorithmSpec{adaptFromTask(dataRequest, srcTracksMask, useMC, kineReader, ggRequest)}, - Options{}}; -} - -} // namespace study -} // namespace its -} // namespace o2 \ No newline at end of file diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 5e28203f57ca8..643e1f0d286ca 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -24,10 +24,13 @@ #include "DetectorsBase/GRPGeomHelper.h" #include +#include #include #include #include #include +#include +#include namespace o2 { @@ -177,26 +180,42 @@ class TrackCheckStudy : public Task std::unique_ptr mPtSec2Eta; std::unique_ptr mPtSec3Eta; + std::unique_ptr mPtResolution; + std::unique_ptr mPtResolution2D; + std::unique_ptr mPtResolutionSec; + std::unique_ptr mPtResolutionPrim; + std::unique_ptr g1; + // Canvas & decorations std::unique_ptr mCanvasPt; std::unique_ptr mCanvasPt2; std::unique_ptr mCanvasPt2fake; - std::unique_ptr mCanvasPtRes; std::unique_ptr mCanvasEta; std::unique_ptr mCanvasEta2; std::unique_ptr mCanvasEta2fake; + std::unique_ptr mCanvasPtRes; + std::unique_ptr mCanvasPtRes2; + std::unique_ptr mCanvasPtRes3; + std::unique_ptr mCanvasPtRes4; std::unique_ptr mLegendPt; std::unique_ptr mLegendPt2; std::unique_ptr mLegendPt2Fake; std::unique_ptr mLegendEta; std::unique_ptr mLegendEta2; std::unique_ptr mLegendEta2Fake; + std::unique_ptr mLegendPtRes; + std::unique_ptr mLegendPtRes2; float rLayer0 = 2.34; float rLayer1 = 3.15; float rLayer2 = 3.93; float rLayer3 = 19.605; + double sigma[100]; + double sigmaerr[100]; + double meanPt[100]; + double aa[100]; + // Debug output tree std::unique_ptr mDBGOut; }; @@ -262,6 +281,15 @@ void TrackCheckStudy::init(InitContext& ic) mPtSec2Eta = std::make_unique("mPtSec2Eta", ";#eta;Number of tracks", 60, -3, 3); mPtSec3Eta = std::make_unique("mPtSec3Eta", ";#eta;Number of tracks", 60, -3, 3); + mPtResolution = std::make_unique("PtResolution", ";#it{p}_{T} ;Den", 100, -1, 1); + mPtResolutionSec = std::make_unique("PtResolutionSec", ";#it{p}_{T} ;Den", 100, -1, 1); + mPtResolutionPrim = std::make_unique("PtResolutionPrim", ";#it{p}_{T} ;Den", 100, -1, 1); + mPtResolution2D = std::make_unique("#it{p}_{T} Resolution vs #it{p}_{T}", ";#it{p}_{T} (GeV/#it{c});#Delta p_{T}/p_{T_{MC}", 100, 0, 10, 100, -1, 1); + + mPtResolution->Sumw2(); + mPtResolutionSec->Sumw2(); + mPtResolutionPrim->Sumw2(); + mGoodPt0->Sumw2(); mGoodPt1->Sumw2(); mGoodPt2->Sumw2(); @@ -545,6 +573,45 @@ void TrackCheckStudy::process() mEff1FakeEta = std::make_unique(*mFakeEta1, *mPtSec1Eta); mEff2FakeEta = std::make_unique(*mFakeEta2, *mPtSec2Eta); mEff3FakeEta = std::make_unique(*mFakeEta3, *mPtSec3Eta); + + LOGP(info, "** Analysing pT resolution..."); + for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { + auto& lab = mTracksMCLabels[iTrack]; + if (!lab.isSet() || lab.isNoise()) + continue; + int trackID, evID, srcID; + bool fake; + const_cast(lab).get(trackID, evID, srcID, fake); + bool pass{true}; + if (srcID == 99) + continue; // skip QED + // PtResVec[iTrack]=(mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt; + mPtResolution->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); + mPtResolution2D->Fill(mParticleInfo[srcID][evID][trackID].pt, (mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); + if (!mParticleInfo[srcID][evID][trackID].isPrimary) + mPtResolutionSec->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); + if (mParticleInfo[srcID][evID][trackID].isPrimary) + mPtResolutionPrim->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); + } + + for (int yy = 0; yy < 100; yy++) { + aa[yy] = 0.; + sigma[yy] = 0.; + sigmaerr[yy] = 0.; + meanPt[yy] = 0.; + } + + for (int yy = 0; yy < 100; yy++) { + TH1D* projh2X = mPtResolution2D->ProjectionY("projh2X", yy, yy + 1, ""); + TF1* f1 = new TF1("f1", "gaus", -0.2, 0.2); + projh2X->Fit("f1"); + if (f1->GetParameter(2) > 0. && f1->GetParameter(2) < 1. && f1->GetParameter(1) < 1.) { + sigma[yy] = f1->GetParameter(2); + sigmaerr[yy] = f1->GetParError(2); + meanPt[yy] = ((8. / 100.) * yy + (8. / 100.) * (yy + 1)) / 2; + aa[yy] = 0.0125; + } + } } void TrackCheckStudy::updateTimeDependentParams(ProcessingContext& pc) @@ -924,6 +991,67 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mLegendEta2Fake->Draw(); mCanvasEta2fake->SaveAs("eff_sec_Eta_fake.png"); + mPtResolution->SetName("#it{p}_{T} resolution"); + mPtResolution->SetTitle(";#Delta p_{T}/p_{T_{MC}} ;Entries"); + mPtResolution->SetFillColor(kAzure + 4); + mPtResolutionPrim->SetFillColor(kRed); + mPtResolutionSec->SetFillColor(kOrange); + mPtResolutionPrim->SetTitle(";#Delta p_{T}/p_{T_{MC}} ;Entries"); + mPtResolutionSec->SetTitle(";#Delta #it{p}_{T}/#it{p}_{T_{MC}} ;Entries"); + mPtResolution2D->SetTitle(";#it{p}_{T_{MC}} [GeV];#Delta #it{p}_{T}/#it{p}_{T_{MC}}"); + + fout.WriteTObject(mPtResolution.get()); + fout.WriteTObject(mPtResolutionPrim.get()); + fout.WriteTObject(mPtResolutionSec.get()); + fout.WriteTObject(mPtResolution2D.get()); + + mCanvasPtRes = std::make_unique("cPtr", "cPtr", 1600, 1200); + mCanvasPtRes->cd(); + mPtResolution->Draw("HIST"); + mLegendPtRes = std::make_unique(0.19, 0.8, 0.40, 0.96); + mLegendPtRes->SetHeader(Form("%zu events PP min bias", mKineReader->getNEvents(0)), "C"); + mLegendPtRes->AddEntry("mPtResolution", "All events", "lep"); + mLegendPtRes->Draw(); + mCanvasPtRes->SaveAs("ptRes.png"); + fout.cd(); + mCanvasPtRes2->Write(); + mCanvasPtRes2 = std::make_unique("cPtr2", "cPtr2", 1600, 1200); + mCanvasPtRes2->cd(); + mPtResolution2D->Draw(); + mCanvasPtRes2->SaveAs("ptRes2.png"); + fout.cd(); + mCanvasPtRes2->Write(); + mCanvasPtRes3 = std::make_unique("cPtr3", "cPtr3", 1600, 1200); + mCanvasPtRes3->cd(); + + TGraphErrors* g1 = new TGraphErrors(100, meanPt, sigma, aa, sigmaerr); + g1->SetMarkerStyle(8); + g1->SetMarkerColor(kGreen); + g1->GetXaxis()->SetTitle(" #it{p}_{T} [GeV]"); + g1->GetYaxis()->SetTitle("#sigma #Delta #it{p}_{T}/#it{p}_{T_{MC}}"); + g1->GetYaxis()->SetLimits(0, 1); + g1->GetXaxis()->SetLimits(0, 10.); + g1->Draw("AP"); + g1->GetYaxis()->SetRangeUser(0, 1); + g1->GetXaxis()->SetRangeUser(0, 10.); + mCanvasPtRes3->SaveAs("ptRes3.png"); + fout.cd(); + mCanvasPtRes3->Write(); + + mCanvasPtRes4 = std::make_unique("cPt4", "cPt4", 1600, 1200); + mCanvasPtRes4->cd(); + mPtResolutionPrim->SetName("mPtResolutionPrim"); + mPtResolutionSec->SetName("mPtResolutionSec"); + mPtResolutionPrim->Draw("same hist"); + mPtResolutionSec->Draw("same hist"); + mLegendPtRes2 = std::make_unique(0.19, 0.8, 0.40, 0.96); + + mLegendPtRes2->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); + mLegendPtRes2->AddEntry("mPtResolutionPrim", "Primary events", "f"); + mLegendPtRes2->AddEntry("mPtResolutionSec", "Secondary events", "f"); + mLegendPtRes2->Draw("same"); + mLegendPtRes2->SaveAs("ptRes4.png"); + fout.cd(); mCanvasPt->Write(); mCanvasEta->Write(); @@ -931,6 +1059,10 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasPt2fake->Write(); mCanvasEta2->Write(); mCanvasEta2fake->Write(); + mCanvasPtRes->Write(); + mCanvasPtRes2->Write(); + mCanvasPtRes3->Write(); + mCanvasPtRes4->Write(); fout.Close(); } diff --git a/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx b/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx index 44051e00cb06b..8ab49d768e08f 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx @@ -17,7 +17,6 @@ #include "ITSStudies/ImpactParameter.h" #include "ITSStudies/AvgClusSize.h" #include "ITSStudies/TrackCheck.h" -#include "ITSStudies/PtResolution.h" #include "Steer/MCKinematicsReader.h" using namespace o2::framework; @@ -40,7 +39,6 @@ void customize(std::vector& workflowOptions) {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}}, {"cluster-size-study", VariantType::Bool, false, {"Perform the average cluster size study"}}, {"track-study", VariantType::Bool, false, {"Perform the track study"}}, - {"pt-res-study", VariantType::Bool, false, {"Perform the Pt resolution study"}}, {"impact-parameter-study", VariantType::Bool, false, {"Perform the impact parameter study"}}, {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}}; o2::raw::HBFUtilsInitializer::addConfigOption(options, "o2_tfidinfo.root"); @@ -85,10 +83,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext) anyStudy = true; specs.emplace_back(o2::its::study::getTrackCheckStudy(GID::getSourcesMask("ITS"), GID::getSourcesMask("ITS"), useMC, mcKinematicsReader)); } - if (configcontext.options().get("pt-res-study")) { - anyStudy = true; - specs.emplace_back(o2::its::study::getPtResolutionStudy(GID::getSourcesMask("ITS"), GID::getSourcesMask("ITS"), useMC, mcKinematicsReader)); - } if (!anyStudy) { LOGP(info, "No study selected, dryrunning"); } From e6867c21dedbc70abe6f6597a4a94f603f7e4383 Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Mon, 14 Aug 2023 18:22:31 +0200 Subject: [PATCH 04/19] Add Pt resolution at check study --- .../ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 643e1f0d286ca..de978fd9cc2c3 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -354,9 +354,9 @@ void TrackCheckStudy::initialiseRun(o2::globaltracking::RecoContainer& recoData) void TrackCheckStudy::process() { LOGP(info, "** Filling particle table ... "); - mParticleInfo.resize(mKineReader->getNSources()); // sources + mParticleInfo.resize(mKineReader->getNSources()); // sources for (int iSource{0}; iSource < mKineReader->getNSources(); ++iSource) { - mParticleInfo[iSource].resize(mKineReader->getNEvents(iSource)); // events + mParticleInfo[iSource].resize(mKineReader->getNEvents(iSource)); // events for (int iEvent{0}; iEvent < mKineReader->getNEvents(iSource); ++iEvent) { mParticleInfo[iSource][iEvent].resize(mKineReader->getTracks(iSource, iEvent).size()); // tracks for (auto iPart{0}; iPart < mKineReader->getTracks(iEvent).size(); ++iPart) { From 2cd439e16ef242a16d0e06f3e8559c657a96d1cc Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Tue, 22 Aug 2023 11:01:07 +0200 Subject: [PATCH 05/19] ITS-Study: add some study on efficiency of secondary tracks, add fake clusters of secondary analysis --- .../ITSStudies/ITSStudiesConfigParam.h | 7 - .../studies/src/ITSStudiesConfigParam.cxx | 1 - .../postprocessing/studies/src/TrackCheck.cxx | 873 +++++++++++++----- 3 files changed, 628 insertions(+), 253 deletions(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h index 4838667ac7cc3..9a2a4838615cf 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSStudiesConfigParam.h @@ -31,13 +31,6 @@ struct ITSCheckTracksParamConfig : public o2::conf::ConfigurableParamHelper { - std::string outFileName = "TrackPtResStudy.root"; - unsigned short trackLengthMask = 0x7f; - - O2ParamDef(ITSPtTracksResParamConfig, "ITSPtTracksResParam"); -}; - struct ITSAvgClusSizeParamConfig : public o2::conf::ConfigurableParamHelper { // Data parameters double b = 5; // Solenoid field in kG (+/-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx index 851bb996426c4..28e046c72e697 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSStudiesConfigParam.cxx @@ -19,7 +19,6 @@ namespace study { static auto& sAvgClusSizeParamITS = o2::its::study::ITSAvgClusSizeParamConfig::Instance(); static auto& sCheckTracksParamsITS = o2::its::study::ITSCheckTracksParamConfig::Instance(); -static auto& sPtResParamsITS = o2::its::study::ITSPtTracksResParamConfig::Instance(); O2ParamImpl(o2::its::study::ITSAvgClusSizeParamConfig); O2ParamImpl(o2::its::study::ITSCheckTracksParamConfig); diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index de978fd9cc2c3..3373de9083f72 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -31,6 +31,8 @@ #include #include #include +#include +#include namespace o2 { @@ -56,7 +58,7 @@ class TrackCheckStudy : public Task float vx; float vy; float vz; - unsigned short clusters = 0u; + int unsigned short clusters = 0u; unsigned char isReco = 0u; unsigned char isFake = 0u; bool isPrimary = 0u; @@ -82,6 +84,9 @@ class TrackCheckStudy : public Task void finaliseCCDB(ConcreteDataMatcher&, void*) final; void initialiseRun(o2::globaltracking::RecoContainer&); void process(); + void setEfficiencyGraph(std::unique_ptr&, const char*, const char*, const int, const double, const double, const int, const double); + void setHistoMCGraph(TH1D&, std::unique_ptr&, const char*, const char*, const int, const double); + void NormalizeHistos(std::vector&); private: void updateTimeDependentParams(ProcessingContext& pc); @@ -115,22 +120,61 @@ class TrackCheckStudy : public Task std::unique_ptr mFakeEta; std::unique_ptr mMultiFake; std::unique_ptr mFakeChi2; - std::unique_ptr mClonePt; std::unique_ptr mCloneEta; std::unique_ptr mDenominatorPt; std::unique_ptr mDenominatorEta; - - std::unique_ptr mEffPt; + std::unique_ptr mDenominatorSecRad; + std::unique_ptr mDenominatorSecZ; + + std::unique_ptr mGoodRad; // decay radius and z of sv for secondary particle + std::unique_ptr mFakeRad; + std::unique_ptr mGoodZ; + std::unique_ptr mFakeZ; + + std::unique_ptr mRadk; // decay radius and z of sv for particle with mother k e lambda + std::unique_ptr mZk; + std::unique_ptr mRadLam; + std::unique_ptr mZLam; + + std::unique_ptr mGoodRadk; + std::unique_ptr mFakeRadk; + std::unique_ptr mGoodZk; + std::unique_ptr mFakeZk; + + std::unique_ptr mGoodRadLam; + std::unique_ptr mFakeRadLam; + std::unique_ptr mGoodZLam; + std::unique_ptr mFakeZLam; + + std::unique_ptr mEffPt; // Eff vs Pt primary std::unique_ptr mEffFakePt; std::unique_ptr mEffClonesPt; - std::unique_ptr mEffEta; + std::unique_ptr mEffEta; // Eff vs Eta primary std::unique_ptr mEffFakeEta; std::unique_ptr mEffClonesEta; - std::unique_ptr mEff0Pt; + std::unique_ptr mEffRad; // Eff vs Radius secondary + std::unique_ptr mEffFakeRad; + + std::unique_ptr mEffZ; // Eff vs Z of sv secondary + std::unique_ptr mEffFakeZ; + + std::unique_ptr mEffRadk; // Eff vs Z of sv and decay radius secondary for particle with mother k e lambda + std::unique_ptr mEffFakeRadk; + + std::unique_ptr mEffZk; + std::unique_ptr mEffFakeZk; + + std::unique_ptr mEffRadLam; + std::unique_ptr mEffFakeRadLam; + + std::unique_ptr mEffZLam; + std::unique_ptr mEffFakeZLam; + + std::unique_ptr mEff0Pt; // Eff vs Pt secondary for different layer std::unique_ptr mEff1Pt; std::unique_ptr mEff2Pt; std::unique_ptr mEff3Pt; @@ -140,7 +184,7 @@ class TrackCheckStudy : public Task std::unique_ptr mEff2FakePt; std::unique_ptr mEff3FakePt; - std::unique_ptr mEff0Eta; + std::unique_ptr mEff0Eta; // Eff vs eta secondary for different layer std::unique_ptr mEff1Eta; std::unique_ptr mEff2Eta; std::unique_ptr mEff3Eta; @@ -150,7 +194,7 @@ class TrackCheckStudy : public Task std::unique_ptr mEff2FakeEta; std::unique_ptr mEff3FakeEta; - std::unique_ptr mGoodPt0; + std::unique_ptr mGoodPt0; // Pt secondary for different layer std::unique_ptr mGoodPt1; std::unique_ptr mGoodPt2; std::unique_ptr mGoodPt3; @@ -160,7 +204,7 @@ class TrackCheckStudy : public Task std::unique_ptr mFakePt2; std::unique_ptr mFakePt3; - std::unique_ptr mGoodEta0; + std::unique_ptr mGoodEta0; // eta secondary for different layer std::unique_ptr mGoodEta1; std::unique_ptr mGoodEta2; std::unique_ptr mGoodEta3; @@ -180,17 +224,25 @@ class TrackCheckStudy : public Task std::unique_ptr mPtSec2Eta; std::unique_ptr mPtSec3Eta; - std::unique_ptr mPtResolution; + std::unique_ptr mPtResolution; // Pt resolution for both primary and secondary std::unique_ptr mPtResolution2D; std::unique_ptr mPtResolutionSec; std::unique_ptr mPtResolutionPrim; std::unique_ptr g1; + std::vector histLength, histLength1Fake, histLength2Fake, histLength3Fake, histLengthNoCl, histLength1FakeNoCl, histLength2FakeNoCl, histLength3FakeNoCl; // FakeCluster Study + std::vector stackLength, stackLength1Fake, stackLength2Fake, stackLength3Fake; + std::vector legends, legends1Fake, legends2Fake, legends3Fake; + ParticleInfo pInfo; // Canvas & decorations std::unique_ptr mCanvasPt; std::unique_ptr mCanvasPt2; std::unique_ptr mCanvasPt2fake; std::unique_ptr mCanvasEta; + std::unique_ptr mCanvasRad; + std::unique_ptr mCanvasZ; + std::unique_ptr mCanvasRadD; + std::unique_ptr mCanvasZD; std::unique_ptr mCanvasEta2; std::unique_ptr mCanvasEta2fake; std::unique_ptr mCanvasPtRes; @@ -205,6 +257,12 @@ class TrackCheckStudy : public Task std::unique_ptr mLegendEta2Fake; std::unique_ptr mLegendPtRes; std::unique_ptr mLegendPtRes2; + std::unique_ptr mLegendZ; + std::unique_ptr mLegendRad; + std::unique_ptr mLegendZD; + std::unique_ptr mLegendRadD; + std::vector HistoMC; + std::vector> EffVec; float rLayer0 = 2.34; float rLayer1 = 3.15; @@ -234,15 +292,30 @@ void TrackCheckStudy::init(InitContext& ic) for (int i{0}; i <= pars.effHistBins; i++) { xbins[i] = pars.effPtCutLow * std::exp(i * a); } - + // to do: cut a lot of lines (reminder: use form like bt, for canvas a vector + function and from bt) mGoodPt = std::make_unique("goodPt", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + //EffVec.push_back(mGoodPt); mGoodEta = std::make_unique("goodEta", ";#eta;Number of tracks", 60, -3, 3); mGoodChi2 = std::make_unique("goodChi2", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", 200, 0, 100); + mGoodRad = std::make_unique("goodRad", ";#Radius [cm];Number of tracks", 100, 0, 25); + mGoodZ = std::make_unique("goodZ", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); + mGoodRadk = std::make_unique("goodRadk", ";#Radius [cm];Number of tracks", 100, 0, 25); + mGoodZk = std::make_unique("goodZk", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); + mGoodRadLam = std::make_unique("goodRadLam", ";#Radius [cm];Number of tracks", 100, 0, 25); + mGoodZLam = std::make_unique("goodZLam", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); + mFakePt = std::make_unique("fakePt", ";#it{p}_{T} (GeV/#it{c});Fak", pars.effHistBins, xbins.data()); mFakeEta = std::make_unique("fakeEta", ";#eta;Number of tracks", 60, -3, 3); mFakeChi2 = std::make_unique("fakeChi2", ";#it{p}_{T} (GeV/#it{c});Fak", 200, 0, 100); + mFakeRad = std::make_unique("fakeRad", ";#Radius [cm];Number of tracks", 100, 0, 25); + mFakeZ = std::make_unique("fakeZ", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); + mFakeRadk = std::make_unique("fakeRadLam", ";#Radius [cm];Number of tracks", 100, 0, 25); + mFakeZk = std::make_unique("fakeZLam", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); + mFakeRadLam = std::make_unique("fakeRadLam", ";#Radius [cm];Number of tracks", 100, 0, 25); + mFakeZLam = std::make_unique("fakeZLam", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); + mMultiFake = std::make_unique("multiFake", ";#it{p}_{T} (GeV/#it{c});Fak", pars.effHistBins, xbins.data()); mClonePt = std::make_unique("clonePt", ";#it{p}_{T} (GeV/#it{c});Clone", pars.effHistBins, xbins.data()); @@ -250,6 +323,13 @@ void TrackCheckStudy::init(InitContext& ic) mDenominatorPt = std::make_unique("denominatorPt", ";#it{p}_{T} (GeV/#it{c});Den", pars.effHistBins, xbins.data()); mDenominatorEta = std::make_unique("denominatorEta", ";#eta;Number of tracks", 60, -3, 3); + mDenominatorSecRad = std::make_unique("denominatorSecRad", ";Radius [cm];Number of tracks", 100, 0, 25); + mDenominatorSecZ = std::make_unique("denominatorSecZ", ";z of secondary vertex [cm];Number of tracks", 100, -50, 50); + + mRadk = std::make_unique("mRadk", ";Radius [cm];Number of tracks", 100, 0, 25); + mRadLam = std::make_unique("mRadLam", ";Radius [cm];Number of tracks", 100, 0, 25); + mZk = std::make_unique("mZk", ";z of secondary vertex [cm]", 100, -50, 50); + mZLam = std::make_unique("mZLam", ";z of secondary vertex [cm]", 100, -50, 50); mGoodPt0 = std::make_unique("goodPt0", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); mGoodPt1 = std::make_unique("goodPt1", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); @@ -290,6 +370,11 @@ void TrackCheckStudy::init(InitContext& ic) mPtResolutionSec->Sumw2(); mPtResolutionPrim->Sumw2(); + mRadk->Sumw2(); + mRadLam->Sumw2(); + mZk->Sumw2(); + mZLam->Sumw2(); + mGoodPt0->Sumw2(); mGoodPt1->Sumw2(); mGoodPt2->Sumw2(); @@ -322,10 +407,24 @@ void TrackCheckStudy::init(InitContext& ic) mGoodPt->Sumw2(); mGoodEta->Sumw2(); + mGoodRad->Sumw2(); + mGoodZ->Sumw2(); + mGoodRadk->Sumw2(); + mGoodZk->Sumw2(); + mGoodRadLam->Sumw2(); + mGoodZLam->Sumw2(); + mFakeRadk->Sumw2(); + mFakeZk->Sumw2(); + mFakeRadLam->Sumw2(); + mFakeZLam->Sumw2(); mFakePt->Sumw2(); + mFakeRad->Sumw2(); + mFakeZ->Sumw2(); mMultiFake->Sumw2(); mClonePt->Sumw2(); mDenominatorPt->Sumw2(); + mDenominatorSecRad->Sumw2(); + mDenominatorSecZ->Sumw2(); } void TrackCheckStudy::run(ProcessingContext& pc) @@ -370,6 +469,7 @@ void TrackCheckStudy::process() mParticleInfo[iSource][iEvent][iPart].vy = part.Vy(); mParticleInfo[iSource][iEvent][iPart].vz = part.Vz(); mParticleInfo[iSource][iEvent][iPart].isPrimary = part.isPrimary(); + mParticleInfo[iSource][iEvent][iPart].mother = part.getMotherTrackId(); // mParticleInfo[iSource][iEvent][iPart].first = part.getFirstDaughterTrackId(); } } @@ -427,115 +527,360 @@ void TrackCheckStudy::process() LOGP(info, "\t- Total number of fakes: {} ({:.2f} %)", fakes, fakes * 100. / mTracks.size()); LOGP(info, "\t- Total number of good: {} ({:.2f} %)", good, good * 100. / mTracks.size()); + histLength.resize(4); + histLength1Fake.resize(4); + histLength2Fake.resize(4); + histLength3Fake.resize(2); + histLengthNoCl.resize(4); + histLength1FakeNoCl.resize(4); + histLength2FakeNoCl.resize(4); + histLength3FakeNoCl.resize(2); + stackLength.resize(4); + stackLength1Fake.resize(4); + stackLength2Fake.resize(4); + stackLength3Fake.resize(2); + legends.resize(4); + legends1Fake.resize(4); + legends2Fake.resize(4); + legends3Fake.resize(2); + + for (int iH{4}; iH < 8; ++iH) { + histLength[iH - 4] = new TH1I(Form("trk_len_%d", iH), "#exists cluster", 7, -.5, 6.5); + histLength[iH - 4]->SetFillColor(kGreen + 3); + histLength[iH - 4]->SetLineColor(kGreen + 3); + histLength[iH - 4]->SetFillStyle(3352); + histLengthNoCl[iH - 4] = new TH1I(Form("trk_len_%d_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); + histLengthNoCl[iH - 4]->SetFillColor(kOrange + 7); + histLengthNoCl[iH - 4]->SetLineColor(kOrange + 7); + histLengthNoCl[iH - 4]->SetFillStyle(3352); + stackLength[iH - 4] = new THStack(Form("stack_trk_len_%d", iH), Form("trk_len=%d", iH)); + stackLength[iH - 4]->Add(histLength[iH - 4]); + stackLength[iH - 4]->Add(histLengthNoCl[iH - 4]); + + histLength1Fake[iH - 4] = new TH1I(Form("trk_len_%d_1f", iH), "#exists cluster", 7, -.5, 6.5); + histLength1Fake[iH - 4]->SetFillColor(kGreen + 3); + histLength1Fake[iH - 4]->SetLineColor(kGreen + 3); + histLength1Fake[iH - 4]->SetFillStyle(3352); + histLength1FakeNoCl[iH - 4] = new TH1I(Form("trk_len_%d_1f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); + histLength1FakeNoCl[iH - 4]->SetFillColor(kOrange + 7); + histLength1FakeNoCl[iH - 4]->SetLineColor(kOrange + 7); + histLength1FakeNoCl[iH - 4]->SetFillStyle(3352); + stackLength1Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_1f", iH), Form("trk_len=%d, 1 Fake", iH)); + stackLength1Fake[iH - 4]->Add(histLength1Fake[iH - 4]); + stackLength1Fake[iH - 4]->Add(histLength1FakeNoCl[iH - 4]); + + histLength2Fake[iH - 4] = new TH1I(Form("trk_len_%d_2f", iH), "#exists cluster", 7, -.5, 6.5); + histLength2Fake[iH - 4]->SetFillColor(kGreen + 3); + histLength2Fake[iH - 4]->SetLineColor(kGreen + 3); + histLength2Fake[iH - 4]->SetFillStyle(3352); + histLength2FakeNoCl[iH - 4] = new TH1I(Form("trk_len_%d_2f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); + histLength2FakeNoCl[iH - 4]->SetFillColor(kOrange + 7); + histLength2FakeNoCl[iH - 4]->SetLineColor(kOrange + 7); + histLength2FakeNoCl[iH - 4]->SetFillStyle(3352); + stackLength2Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_2f", iH), Form("trk_len=%d, 2 Fake", iH)); + stackLength2Fake[iH - 4]->Add(histLength2Fake[iH - 4]); + stackLength2Fake[iH - 4]->Add(histLength2FakeNoCl[iH - 4]); + if (iH > 5) { + histLength3Fake[iH - 6] = new TH1I(Form("trk_len_%d_3f", iH), "#exists cluster", 7, -.5, 6.5); + histLength3Fake[iH - 6]->SetFillColor(kGreen + 3); + histLength3Fake[iH - 6]->SetLineColor(kGreen + 3); + histLength3Fake[iH - 6]->SetFillStyle(3352); + histLength3FakeNoCl[iH - 6] = new TH1I(Form("trk_len_%d_3f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); + histLength3FakeNoCl[iH - 6]->SetFillColor(kOrange + 7); + histLength3FakeNoCl[iH - 6]->SetLineColor(kOrange + 7); + histLength3FakeNoCl[iH - 6]->SetFillStyle(3352); + stackLength3Fake[iH - 6] = new THStack(Form("stack_trk_len_%d_3f", iH), Form("trk_len=%d, 3 Fake", iH)); + stackLength3Fake[iH - 6]->Add(histLength3Fake[iH - 6]); + stackLength3Fake[iH - 6]->Add(histLength3FakeNoCl[iH - 6]); + } + } LOGP(info, "** Filling histograms ... "); - + int evID = 0; + int trackID = 0; // Currently process only sourceID = 0, to be extended later if needed for (auto& evInfo : mParticleInfo[0]) { + trackID = 0; for (auto& part : evInfo) { - if ((part.clusters & 0x7f) != mMask) { + if ((part.clusters & 0x7f) == mMask) { // part.clusters != 0x3f && part.clusters != 0x3f << 1 && // part.clusters != 0x1f && part.clusters != 0x1f << 1 && part.clusters != 0x1f << 2 && // part.clusters != 0x0f && part.clusters != 0x0f << 1 && part.clusters != 0x0f << 2 && part.clusters != 0x0f << 3) { - continue; - } - if (part.isPrimary) { - mDenominatorPt->Fill(part.pt); - mDenominatorEta->Fill(part.eta); - if (part.isReco) { - mGoodPt->Fill(part.pt); - mGoodEta->Fill(part.eta); - if (part.isReco > 1) { - for (int _i{0}; _i < part.isReco - 1; ++_i) { - mClonePt->Fill(part.pt); - mCloneEta->Fill(part.eta); + // continue; + + if (part.isPrimary) { + mDenominatorPt->Fill(part.pt); + mDenominatorEta->Fill(part.eta); + if (part.isReco) { + mGoodPt->Fill(part.pt); + mGoodEta->Fill(part.eta); + if (part.isReco > 1) { + for (int _i{0}; _i < part.isReco - 1; ++_i) { + mClonePt->Fill(part.pt); + mCloneEta->Fill(part.eta); + } } } - } - if (part.isFake) { - mFakePt->Fill(part.pt); - mFakeEta->Fill(part.eta); - if (part.isFake > 1) { - for (int _i{0}; _i < part.isFake - 1; ++_i) { - mMultiFake->Fill(part.pt); + if (part.isFake) { + mFakePt->Fill(part.pt); + mFakeEta->Fill(part.eta); + if (part.isFake > 1) { + for (int _i{0}; _i < part.isFake - 1; ++_i) { + mMultiFake->Fill(part.pt); + } } } } } if (!part.isPrimary) { + totalsec++; + int pdgcode = mParticleInfo[0][evID][part.mother].pdg; float rad = sqrt(pow(part.vx, 2) + pow(part.vy, 2)); - if (rad < rLayer0) // layer 0 + + if ((rad < rLayer0) && (part.clusters == 0x7f || part.clusters == 0x3f || part.clusters == 0x1f || part.clusters == 0x0f)) // layer 0 { + if (pdgcode == 310) // k0s + { + mRadk->Fill(rad); + mZk->Fill(part.vz); + } + if (pdgcode == 3122) { // Lambda + mRadLam->Fill(rad); + mZLam->Fill(part.vz); + } totsec0++; mPtSec0Pt->Fill(part.pt); mPtSec0Eta->Fill(part.eta); - + mDenominatorSecRad->Fill(rad); + mDenominatorSecZ->Fill(part.vz); if (part.isReco) { mGoodPt0->Fill(part.pt); mGoodEta0->Fill(part.eta); + mGoodRad->Fill(rad); + mGoodZ->Fill(part.vz); + if (pdgcode == 310) { + mGoodRadk->Fill(rad); + mGoodZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mGoodRadLam->Fill(rad); + mGoodZLam->Fill(part.vz); + } good0++; } if (part.isFake) { mFakePt0->Fill(part.pt); mFakeEta0->Fill(part.eta); + mFakeRad->Fill(rad); + mFakeZ->Fill(part.vz); + if (pdgcode == 310) { + mFakeRadk->Fill(rad); + mFakeZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mFakeRadLam->Fill(rad); + mFakeZLam->Fill(part.vz); + } fake0++; } } - if (rad < rLayer1 && rad > rLayer0) // layer 1 + if (rad < rLayer1 && rad > rLayer0 && (part.clusters == 0x1e || part.clusters == 0x3e || part.clusters == 0x7e)) // layer 1 { + if (pdgcode == 310) { + mRadk->Fill(rad); + mZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mRadLam->Fill(rad); + mZLam->Fill(part.vz); + } totsec1++; mPtSec1Pt->Fill(part.pt); mPtSec1Eta->Fill(part.eta); + mDenominatorSecRad->Fill(rad); + mDenominatorSecZ->Fill(part.vz); if (part.isReco) { mGoodPt1->Fill(part.pt); mGoodEta1->Fill(part.eta); + mGoodRad->Fill(rad); + mGoodZ->Fill(part.vz); + if (pdgcode == 310) { + mGoodRadk->Fill(rad); + mGoodZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mGoodRadLam->Fill(rad); + mGoodZLam->Fill(part.vz); + } good1++; } if (part.isFake) { mFakePt1->Fill(part.pt); mFakeEta1->Fill(part.eta); + mFakeRad->Fill(rad); + mFakeZ->Fill(part.vz); + if (pdgcode == 310) { + mFakeRadk->Fill(rad); + mFakeZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mFakeRadLam->Fill(rad); + mFakeZLam->Fill(part.vz); + } fake1++; } } - if (rad < rLayer2 && rad > rLayer1) // layer 2 + if (rad < rLayer2 && rad > rLayer1 && (part.clusters == 0x7c || part.clusters == 0x3c)) // layer 2 { + if (pdgcode == 310) { + mRadk->Fill(rad); + mZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mRadLam->Fill(rad); + mZLam->Fill(part.vz); + } totsec2++; mPtSec2Pt->Fill(part.pt); mPtSec2Eta->Fill(part.eta); + mDenominatorSecRad->Fill(rad); + mDenominatorSecZ->Fill(part.vz); if (part.isReco) { mGoodPt2->Fill(part.pt); mGoodEta2->Fill(part.eta); + mGoodRad->Fill(rad); + mGoodZ->Fill(part.vz); + if (pdgcode == 310) { + mGoodRadk->Fill(rad); + mGoodZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mGoodRadLam->Fill(rad); + mGoodZLam->Fill(part.vz); + } good2++; } if (part.isFake) { mFakePt2->Fill(part.pt); mFakeEta2->Fill(part.eta); + mFakeRad->Fill(rad); + mFakeZ->Fill(part.vz); + if (pdgcode == 310) { + mFakeRadk->Fill(rad); + mFakeZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mFakeRadLam->Fill(rad); + mFakeZLam->Fill(part.vz); + } fake2++; } } - if (rad < rLayer3 && rad > rLayer2) // layer 3 + if (rad < rLayer3 && rad > rLayer2 && part.clusters == 0x78) // layer 3 { + if (pdgcode == 310) { + mRadk->Fill(rad); + mZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mRadLam->Fill(rad); + mZLam->Fill(part.vz); + } totsec3++; mPtSec3Pt->Fill(part.pt); mPtSec3Eta->Fill(part.eta); + mDenominatorSecRad->Fill(rad); + mDenominatorSecZ->Fill(part.vz); if (part.isReco) { mGoodPt3->Fill(part.pt); mGoodEta3->Fill(part.eta); + mGoodRad->Fill(rad); + mGoodZ->Fill(part.vz); + if (pdgcode == 310) { + mGoodRadk->Fill(rad); + mGoodZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mGoodRadLam->Fill(rad); + mGoodZLam->Fill(part.vz); + } good3++; } if (part.isFake) { mFakePt3->Fill(part.pt); mFakeEta3->Fill(part.eta); + mFakeRad->Fill(rad); + mFakeZ->Fill(part.vz); + if (pdgcode == 310) { + mFakeRadk->Fill(rad); + mFakeZk->Fill(part.vz); + } + if (pdgcode == 3122) { + mFakeRadLam->Fill(rad); + mFakeZLam->Fill(part.vz); + } fake3++; } } + + // Analysing fake clusters + + int nCl{0}; + for (unsigned int bit{0}; bit < sizeof(part.clusters) * 8; ++bit) { + nCl += bool(part.clusters & (1 << bit)); + } + if (nCl < 3) { + continue; + } + auto& track = part.track; + auto len = track.getNClusters(); + for (int iLayer{0}; iLayer < 7; ++iLayer) { + if (track.hasHitOnLayer(iLayer)) { + if (track.isFakeOnLayer(iLayer)) { // Reco track has fake cluster + if (part.clusters & (0x1 << iLayer)) { // Correct cluster exists + histLength[len - 4]->Fill(iLayer); + if (track.getNFakeClusters() == 1) { + histLength1Fake[len - 4]->Fill(iLayer); + } + if (track.getNFakeClusters() == 2) { + histLength2Fake[len - 4]->Fill(iLayer); + } + if (track.getNFakeClusters() == 3) { + histLength3Fake[len - 6]->Fill(iLayer); + } + + } else { + histLengthNoCl[len - 4]->Fill(iLayer); + if (track.getNFakeClusters() == 1) { + histLength1FakeNoCl[len - 4]->Fill(iLayer); + } + if (track.getNFakeClusters() == 2) { + histLength2FakeNoCl[len - 4]->Fill(iLayer); + } + if (track.getNFakeClusters() == 3) { + histLength3FakeNoCl[len - 6]->Fill(iLayer); + } + } + } + } + } } + trackID++; } + evID++; } + + HistoMC.push_back(*mDenominatorSecRad); + HistoMC.push_back(*mRadk); + HistoMC.push_back(*mRadLam); + HistoMC.push_back(*mDenominatorSecZ); + HistoMC.push_back(*mZk); + HistoMC.push_back(*mZLam); + LOGP(info, "** Some statistics on secondary tracks:"); LOGP(info, "\t- Total number of secondary tracks: {}", totalsec); @@ -543,7 +888,7 @@ void TrackCheckStudy::process() LOGP(info, "\t- Total number of secondary tracks on layer 1: {}, good: {}, fake: {}", totsec1, good1, fake1); LOGP(info, "\t- Total number of secondary tracks on layer 2: {}, good: {}, fake: {}", totsec2, good2, fake2); LOGP(info, "\t- Total number of secondary tracks on layer 3: {}, good: {}, fake: {}", totsec3, good3, fake3); - + LOGP(info, "fraction of k = {}, fraction of lambda= {}", (*mRadk).GetEntries() / (*mDenominatorSecRad).GetEntries(), (*mRadLam).GetEntries() / (*mDenominatorSecRad).GetEntries()); LOGP(info, "** Computing efficiencies ..."); mEffPt = std::make_unique(*mGoodPt, *mDenominatorPt); @@ -554,6 +899,24 @@ void TrackCheckStudy::process() mEffFakeEta = std::make_unique(*mFakeEta, *mDenominatorEta); mEffClonesEta = std::make_unique(*mCloneEta, *mDenominatorEta); + mEffRad = std::make_unique(*mGoodRad, *mDenominatorSecRad); + mEffFakeRad = std::make_unique(*mFakeRad, *mDenominatorSecRad); + + mEffZ = std::make_unique(*mGoodZ, *mDenominatorSecZ); + mEffFakeZ = std::make_unique(*mFakeZ, *mDenominatorSecZ); + + mEffRadk = std::make_unique(*mGoodRadk, *mRadk); + mEffFakeRadk = std::make_unique(*mFakeRadk, *mRadk); + + mEffZk = std::make_unique(*mGoodZk, *mZk); + mEffFakeZk = std::make_unique(*mFakeZk, *mZk); + + mEffRadLam = std::make_unique(*mGoodRadLam, *mRadLam); + mEffFakeRadLam = std::make_unique(*mFakeRadLam, *mRadLam); + + mEffZLam = std::make_unique(*mGoodZLam, *mZLam); + mEffFakeZLam = std::make_unique(*mFakeZLam, *mZLam); + mEff0Pt = std::make_unique(*mGoodPt0, *mPtSec0Pt); mEff1Pt = std::make_unique(*mGoodPt1, *mPtSec1Pt); mEff2Pt = std::make_unique(*mGoodPt2, *mPtSec2Pt); @@ -590,8 +953,7 @@ void TrackCheckStudy::process() mPtResolution2D->Fill(mParticleInfo[srcID][evID][trackID].pt, (mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); if (!mParticleInfo[srcID][evID][trackID].isPrimary) mPtResolutionSec->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); - if (mParticleInfo[srcID][evID][trackID].isPrimary) - mPtResolutionPrim->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); + mPtResolutionPrim->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); } for (int yy = 0; yy < 100; yy++) { @@ -614,6 +976,40 @@ void TrackCheckStudy::process() } } +void TrackCheckStudy::NormalizeHistos(std::vector& HistoMC) +{ + int nHist = HistoMC.size(); + for (int jh = 0; jh < nHist; jh++) { + double tot = HistoMC[jh].Integral(); + if (tot > 0) + HistoMC[jh].Scale(1. / tot); + } +} + +void TrackCheckStudy::setEfficiencyGraph(std::unique_ptr& eff, const char* name, const char* title, const int color, const double alpha = 1, const double linew = 2, const int markerStyle = kFullCircle, const double markersize = 1.7) +{ + eff->SetName(name); + eff->SetTitle(title); + eff->SetLineColor(color); + eff->SetLineColorAlpha(color, alpha); + eff->SetMarkerColor(color); + eff->SetMarkerColorAlpha(color, alpha); + eff->SetLineWidth(linew); + eff->SetMarkerStyle(markerStyle); + eff->SetMarkerSize(markersize); + eff->SetDirectory(gDirectory); +} + +void TrackCheckStudy::setHistoMCGraph(TH1D& histo, std::unique_ptr& histo2, const char* name, const char* title, const int color, const double alpha = 0.5) +{ + histo.SetName(name); + histo2->SetName(name); + histo.SetTitle(title); + histo.SetFillColor(color); + histo.SetFillColorAlpha(color, alpha); + histo.SetDirectory(gDirectory); +} + void TrackCheckStudy::updateTimeDependentParams(ProcessingContext& pc) { static bool initOnceDone = false; @@ -628,249 +1024,128 @@ void TrackCheckStudy::updateTimeDependentParams(ProcessingContext& pc) void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) { TFile fout(mOutFileName.c_str(), "recreate"); - mEffPt->SetName("Good_pt"); - mEffPt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency primary particle"); - mEffPt->SetLineColor(kAzure + 4); - mEffPt->SetLineColorAlpha(kAzure + 4, 0.65); - mEffPt->SetLineWidth(2); - mEffPt->SetMarkerColorAlpha(kAzure + 4, 0.65); - mEffPt->SetMarkerStyle(kFullCircle); - mEffPt->SetMarkerSize(1.35); - mEffPt->SetDirectory(gDirectory); + NormalizeHistos(HistoMC); + + setEfficiencyGraph(mEffPt, "Good_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kAzure + 4, 0.65); fout.WriteTObject(mEffPt.get()); - mEffFakePt->SetName("Fake_pt"); - mEffFakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency primary particle"); - mEffFakePt->SetLineColor(kRed + 1); - mEffFakePt->SetLineColorAlpha(kRed + 1, 0.65); - mEffFakePt->SetLineWidth(2); - mEffFakePt->SetMarkerColorAlpha(kRed + 1, 0.65); - mEffFakePt->SetMarkerStyle(kFullCircle); - mEffFakePt->SetMarkerSize(1.35); - mEffFakePt->SetDirectory(gDirectory); + setEfficiencyGraph(mEffFakePt, "Fake_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kRed + 1, 0.65); fout.WriteTObject(mEffFakePt.get()); - mEffClonesPt->SetName("Clone_pt"); - mEffClonesPt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency primary particle"); - mEffClonesPt->SetLineColor(kGreen + 2); - mEffClonesPt->SetLineColorAlpha(kGreen + 2, 0.65); - mEffClonesPt->SetLineWidth(2); - mEffClonesPt->SetMarkerColorAlpha(kGreen + 2, 0.65); - - mEffClonesPt->SetMarkerStyle(kFullCircle); - mEffClonesPt->SetMarkerSize(1.35); - mEffClonesPt->SetDirectory(gDirectory); + setEfficiencyGraph(mEffClonesPt, "Clone_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kGreen + 2, 0.65); fout.WriteTObject(mEffClonesPt.get()); - mEffEta->SetName("Good_eta"); - mEffEta->SetTitle(";#eta;efficiency primary particle"); - mEffEta->SetLineColor(kAzure + 4); - mEffEta->SetLineColorAlpha(kAzure + 4, 0.65); - mEffEta->SetLineWidth(2); - mEffEta->SetMarkerColorAlpha(kAzure + 4, 0.65); - mEffEta->SetMarkerStyle(kFullCircle); - mEffEta->SetMarkerSize(1.35); - mEffEta->SetDirectory(gDirectory); + setEfficiencyGraph(mEffEta, "Good_eta", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kAzure + 4, 0.65); fout.WriteTObject(mEffEta.get()); - mEffFakeEta->SetName("Fake_eta"); - mEffFakeEta->SetTitle(";#eta;efficiency primary particle"); - mEffFakeEta->SetLineColor(kRed + 1); - mEffFakeEta->SetLineColorAlpha(kRed + 1, 0.65); - mEffFakeEta->SetLineWidth(2); - mEffFakeEta->SetMarkerColorAlpha(kRed + 1, 0.65); - mEffFakeEta->SetMarkerStyle(kFullCircle); - mEffFakeEta->SetMarkerSize(1.35); - mEffFakeEta->SetDirectory(gDirectory); + setEfficiencyGraph(mEffFakeEta, "Fake_eta", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kRed + 1, 0.65); fout.WriteTObject(mEffFakeEta.get()); - mEffClonesEta->SetName("Clone_eta"); - mEffClonesEta->SetTitle(";#eta;efficiency primary particle"); - mEffClonesEta->SetLineColor(kGreen + 2); - mEffClonesEta->SetLineColorAlpha(kGreen + 2, 0.65); - mEffClonesEta->SetLineWidth(2); - mEffClonesEta->SetMarkerColorAlpha(kGreen + 2, 0.65); - mEffClonesEta->SetMarkerStyle(kFullCircle); - mEffClonesEta->SetMarkerSize(1.35); - mEffClonesEta->SetDirectory(gDirectory); + setEfficiencyGraph(mEffClonesEta, "Clone_eta", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kGreen + 2, 0.65); fout.WriteTObject(mEffClonesEta.get()); - mEff0Pt->SetName("Good_pt0"); //******LAYER 0****** - mEff0Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff0Pt->SetLineColor(kAzure + 4); - mEff0Pt->SetLineColorAlpha(kAzure + 4, 1); - mEff0Pt->SetLineWidth(2); - mEff0Pt->SetMarkerColorAlpha(kAzure + 4, 1); - mEff0Pt->SetMarkerStyle(kFullCircle); - mEff0Pt->SetMarkerSize(1.7); - mEff0Pt->SetDirectory(gDirectory); + setEfficiencyGraph(mEffRad, "Good_Rad", ";Radius [cm];efficiency secondary particle", kBlue, 1); + fout.WriteTObject(mEffRad.get()); + + setEfficiencyGraph(mEffFakeRad, "Fake_Rad", ";Radius [cm];efficiency secondary particle", kOrange + 7, 1); + fout.WriteTObject(mEffFakeRad.get()); + + setEfficiencyGraph(mEffRadk, "Good_Radk", ";Radius [cm];efficiency secondary particle", kBlue, 1); + fout.WriteTObject(mEffRadk.get()); + + setEfficiencyGraph(mEffFakeRadk, "Fake_Radk", ";Radius [cm];efficiency secondary particle", kAzure + 10, 1); + fout.WriteTObject(mEffFakeRadk.get()); + + setEfficiencyGraph(mEffRadLam, "Good_RadLam", ";Radius [cm];efficiency secondary particle", kRed + 2, 1); + fout.WriteTObject(mEffRadLam.get()); + + setEfficiencyGraph(mEffFakeRadLam, "Fake_RadLam", ";Radius [cm];efficiency secondary particle", kMagenta - 9, 1); + fout.WriteTObject(mEffFakeRadLam.get()); + + setEfficiencyGraph(mEffZ, "Good_Z", ";z secondary vertex [cm];efficiency secondary particle", kTeal + 2, 1); + fout.WriteTObject(mEffZ.get()); + + setEfficiencyGraph(mEffFakeZ, "Fake_Z", ";z secondary vertex [cm];efficiency secondary particle", kMagenta - 4, 1); + fout.WriteTObject(mEffFakeZ.get()); + + setEfficiencyGraph(mEffZk, "Good_Zk", ";z of sv [cm];efficiency secondary particle", kBlue); + fout.WriteTObject(mEffZk.get()); + + setEfficiencyGraph(mEffFakeZk, "Fake_Zk", ";z of sv [cm];efficiency secondary particle", kAzure + 10); + fout.WriteTObject(mEffFakeZk.get()); + + setEfficiencyGraph(mEffZLam, "Good_ZLam", ";z of sv [cm];efficiency secondary particle", kRed + 2); + fout.WriteTObject(mEffZLam.get()); + + setEfficiencyGraph(mEffFakeZLam, "Fake_ZLam", ";z of sv [cm];efficiency secondary particle", kMagenta - 9); + fout.WriteTObject(mEffFakeZLam.get()); + + setEfficiencyGraph(mEff0Pt, "Good_pt0", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kAzure + 4); fout.WriteTObject(mEff0Pt.get()); - mEff0FakePt->SetName("Fake_pt0"); - mEff0FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff0FakePt->SetLineColor(kAzure + 4); - mEff0FakePt->SetLineColorAlpha(kAzure + 4, 1); - mEff0FakePt->SetLineWidth(2); - mEff0FakePt->SetMarkerColorAlpha(kAzure + 4, 1); - mEff0FakePt->SetMarkerStyle(kFullCircle); - mEff0FakePt->SetMarkerSize(1.7); - mEff0FakePt->SetDirectory(gDirectory); + setEfficiencyGraph(mEff0FakePt, "Fake_pt0", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kAzure + 4); fout.WriteTObject(mEff0FakePt.get()); - mEff0Eta->SetName("Good_eta0"); - mEff0Eta->SetTitle(";#eta;efficiency secondary particle"); - mEff0Eta->SetLineColor(kAzure + 4); - mEff0Eta->SetLineColorAlpha(kAzure + 4, 1); - mEff0Eta->SetLineWidth(2); - mEff0Eta->SetMarkerColorAlpha(kAzure + 4, 1); - mEff0Eta->SetMarkerStyle(kFullCircle); - mEff0Eta->SetMarkerSize(1.7); - mEff0Eta->SetDirectory(gDirectory); + setEfficiencyGraph(mEff0Eta, "Good_eta0", ";#eta;efficiency secondary particle ", kAzure + 4); fout.WriteTObject(mEff0Eta.get()); - mEff0FakeEta->SetName("Fake_eta0"); - mEff0FakeEta->SetTitle(";#eta;efficiency secondary particle"); - mEff0FakeEta->SetLineColor(kAzure + 4); - mEff0FakeEta->SetLineColorAlpha(kAzure + 4, 1); - mEff0FakeEta->SetLineWidth(2); - mEff0FakeEta->SetMarkerColorAlpha(kAzure + 4, 1); - mEff0FakeEta->SetMarkerStyle(kFullCircle); - mEff0FakeEta->SetMarkerSize(1.7); - mEff0FakeEta->SetDirectory(gDirectory); + setEfficiencyGraph(mEff0FakeEta, "Fake_eta0", ";#eta;efficiency secondary particle ", kAzure + 4); fout.WriteTObject(mEff0FakeEta.get()); - mEff1Pt->SetName("Good_pt1"); //*****LAYER 1 ******** - mEff1Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff1Pt->SetLineColor(kRed); - mEff1Pt->SetLineColorAlpha(kRed, 1); - mEff1Pt->SetLineWidth(2); - mEff1Pt->SetMarkerColorAlpha(kRed, 1); - mEff1Pt->SetMarkerStyle(kFullCircle); - mEff1Pt->SetMarkerSize(1.7); - mEff1Pt->SetDirectory(gDirectory); + setEfficiencyGraph(mEff1Pt, "Good_pt1", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kRed); fout.WriteTObject(mEff1Pt.get()); - mEff1FakePt->SetName("Fake_pt1"); - mEff1FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff1FakePt->SetLineColor(kRed); - mEff1FakePt->SetLineColorAlpha(kRed, 1); - mEff1FakePt->SetLineWidth(2); - mEff1FakePt->SetMarkerColorAlpha(kRed, 1); - mEff1FakePt->SetMarkerStyle(kFullCircle); - mEff1FakePt->SetMarkerSize(1.7); - mEff1FakePt->SetDirectory(gDirectory); + setEfficiencyGraph(mEff1FakePt, "Fake_pt1", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kRed); fout.WriteTObject(mEff1FakePt.get()); - mEff1Eta->SetName("Good_eta1"); - mEff1Eta->SetTitle(";#eta;efficiency secondary particle"); - mEff1Eta->SetLineColor(kRed); - mEff1Eta->SetLineColorAlpha(kRed, 1); - mEff1Eta->SetLineWidth(2); - mEff1Eta->SetMarkerColorAlpha(kRed, 1); - mEff1Eta->SetMarkerStyle(kFullCircle); - mEff1Eta->SetMarkerSize(1.7); - mEff1Eta->SetDirectory(gDirectory); + setEfficiencyGraph(mEff1Eta, "Good_eta1", ";#eta;efficiency secondary particle ", kRed); fout.WriteTObject(mEff1Eta.get()); - mEff1FakeEta->SetName("Fake_eta1"); - mEff1FakeEta->SetTitle(";#eta;efficiency secondary particle"); - mEff1FakeEta->SetLineColor(kRed); - mEff1FakeEta->SetLineColorAlpha(kRed, 1); - mEff1FakeEta->SetLineWidth(2); - mEff1FakeEta->SetMarkerColorAlpha(kRed, 1); - mEff1FakeEta->SetMarkerStyle(kFullCircle); - mEff1FakeEta->SetMarkerSize(1.7); - mEff1FakeEta->SetDirectory(gDirectory); + setEfficiencyGraph(mEff1FakeEta, "Fake_eta1", ";#eta;efficiency secondary particle ", kRed); fout.WriteTObject(mEff1FakeEta.get()); - mEff2Pt->SetName("Good_pt2"); //*****LAYER 2 ******** - mEff2Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff2Pt->SetLineColor(kGreen + 1); - mEff2Pt->SetLineColorAlpha(kGreen + 1, 1); - mEff2Pt->SetLineWidth(2); - mEff2Pt->SetMarkerColorAlpha(kGreen + 1, 1); - mEff2Pt->SetMarkerStyle(kFullCircle); - mEff2Pt->SetMarkerSize(1.7); - mEff2Pt->SetDirectory(gDirectory); + setEfficiencyGraph(mEff2Pt, "Good_pt2", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kGreen + 1); fout.WriteTObject(mEff2Pt.get()); - mEff2FakePt->SetName("Fake_pt2"); - mEff2FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff2FakePt->SetLineColor(kGreen + 1); - mEff2FakePt->SetLineColorAlpha(kGreen + 1, 1); - mEff2FakePt->SetLineWidth(2); - mEff2FakePt->SetMarkerColorAlpha(kGreen + 1, 1); - mEff2FakePt->SetMarkerStyle(kFullCircle); - mEff2FakePt->SetMarkerSize(1.7); - mEff2FakePt->SetDirectory(gDirectory); + setEfficiencyGraph(mEff2FakePt, "Fake_pt2", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kGreen + 1); fout.WriteTObject(mEff2FakePt.get()); - mEff2Eta->SetName("Good_eta2"); - mEff2Eta->SetTitle(";#eta;efficiency secondary particle"); - mEff2Eta->SetLineColor(kGreen + 1); - mEff2Eta->SetLineColorAlpha(kGreen + 1, 1); - mEff2Eta->SetLineWidth(2); - mEff2Eta->SetMarkerColorAlpha(kGreen + 1, 1); - mEff2Eta->SetMarkerStyle(kFullCircle); - mEff2Eta->SetMarkerSize(1.7); - mEff2Eta->SetDirectory(gDirectory); + setEfficiencyGraph(mEff2Eta, "Good_eta2", ";#eta;efficiency secondary particle ", kGreen + 1); fout.WriteTObject(mEff2Eta.get()); - mEff2FakeEta->SetName("Fake_eta2"); - mEff2FakeEta->SetTitle(";#eta;efficiency secondary particle"); - mEff2FakeEta->SetLineColor(kGreen + 1); - mEff2FakeEta->SetLineColorAlpha(kGreen + 1, 1); - mEff2FakeEta->SetLineWidth(2); - mEff2FakeEta->SetMarkerColorAlpha(kGreen + 1, 1); - mEff2FakeEta->SetMarkerStyle(kFullCircle); - mEff2FakeEta->SetMarkerSize(1.7); - mEff2FakeEta->SetDirectory(gDirectory); + setEfficiencyGraph(mEff2FakeEta, "Fake_eta2", ";#eta;efficiency secondary particle ", kGreen + 1); fout.WriteTObject(mEff2FakeEta.get()); - mEff3Pt->SetName("Good_pt3"); //*****LAYER 3 ******** - mEff3Pt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff3Pt->SetLineColor(kOrange - 3); - mEff3Pt->SetLineColorAlpha(kOrange - 3, 1); - mEff3Pt->SetLineWidth(2); - mEff3Pt->SetMarkerColorAlpha(kOrange - 3, 1); - mEff3Pt->SetMarkerStyle(kFullCircle); - mEff3Pt->SetMarkerSize(1.7); - mEff3Pt->SetDirectory(gDirectory); + setEfficiencyGraph(mEff3Pt, "Good_pt3", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kOrange - 3); fout.WriteTObject(mEff3Pt.get()); - mEff3FakePt->SetName("Fake_pt3"); - mEff3FakePt->SetTitle(";#it{p}_{T} (GeV/#it{c});efficiency secondary particle "); - mEff3FakePt->SetLineColor(kOrange - 3); - mEff3FakePt->SetLineColorAlpha(kOrange - 3, 1); - mEff3FakePt->SetLineWidth(2); - mEff3FakePt->SetMarkerColorAlpha(kOrange - 3, 1); - mEff3FakePt->SetMarkerStyle(kFullCircle); - mEff3FakePt->SetMarkerSize(1.7); - mEff3FakePt->SetDirectory(gDirectory); + setEfficiencyGraph(mEff3FakePt, "Fake_pt3", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kOrange - 3); fout.WriteTObject(mEff3FakePt.get()); - mEff3Eta->SetName("Good_eta3"); - mEff3Eta->SetTitle(";#eta;efficiency secondary particle"); - mEff3Eta->SetLineColor(kOrange - 3); - mEff3Eta->SetLineColorAlpha(kOrange - 3, 1); - mEff3Eta->SetLineWidth(2); - mEff3Eta->SetMarkerColorAlpha(kOrange - 3, 1); - mEff3Eta->SetMarkerStyle(kFullCircle); - mEff3Eta->SetMarkerSize(1.7); - mEff3Eta->SetDirectory(gDirectory); + setEfficiencyGraph(mEff3Eta, "Good_eta3", ";#eta;efficiency secondary particle", kOrange - 3); fout.WriteTObject(mEff3Eta.get()); - mEff3FakeEta->SetName("Fake_eta3"); - mEff3FakeEta->SetTitle(";#eta;efficiency secondary particle"); - mEff3FakeEta->SetLineColor(kOrange - 3); - mEff3FakeEta->SetLineColorAlpha(kOrange - 3, 1); - mEff3FakeEta->SetLineWidth(2); - mEff3FakeEta->SetMarkerColorAlpha(kOrange - 3, 1); - mEff3FakeEta->SetMarkerStyle(kFullCircle); - mEff3FakeEta->SetMarkerSize(1.7); - mEff3FakeEta->SetDirectory(gDirectory); + setEfficiencyGraph(mEff3FakeEta, "Fake_eta3", ";#eta;efficiency secondary particle", kOrange - 3); fout.WriteTObject(mEff3FakeEta.get()); + setHistoMCGraph(HistoMC[0], mDenominatorSecRad, "Decay_Radius_MC", ";Decay Radius ;Entries", kGray, 0.4); + fout.WriteTObject(mDenominatorSecRad.get()); + + setHistoMCGraph(HistoMC[3], mDenominatorSecZ, "Zsv_MC", ";z of secondary vertex ;Entries", kGray, 0.4); + fout.WriteTObject(mDenominatorSecZ.get()); + + setHistoMCGraph(HistoMC[1], mRadk, "Decay_Radius_MC_k", ";Decay Radius ;Entries", kBlue, 0.2); + fout.WriteTObject(mRadk.get()); + + setHistoMCGraph(HistoMC[4], mZk, "Zsv_MC_k", ";Zsv ;Entries", kBlue, 0.2); + fout.WriteTObject(mZk.get()); + + setHistoMCGraph(HistoMC[2], mRadLam, "Decay_Radius_MC_Lam", ";Decay Radius ;Entries", kRed, 0.2); + fout.WriteTObject(mRadLam.get()); + + setHistoMCGraph(HistoMC[5], mZLam, "Zsv_MC_Lam", ";Zsv ;Entries", kRed, 0.2); + fout.WriteTObject(mZLam.get()); + // Paint the histograms // todo: delegate to a dedicated helper gStyle->SetTitleSize(0.035, "xy"); @@ -915,6 +1190,81 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mLegendEta->Draw(); mCanvasEta->SaveAs("eff_eta.png"); + mCanvasRad = std::make_unique("cRad", "cRad", 1600, 1200); + mCanvasRad->cd(); + mCanvasRad->SetGrid(); + mEffRad->Draw("pz"); + mEffFakeRad->Draw("pz same"); + HistoMC[0].Draw("hist same"); // HistoMC[0] + mCanvasRad->SetLogy(); + mLegendRad = std::make_unique(0.8, 0.4, 0.95, 0.6); + mLegendRad->SetHeader(Form("%zu events PP ", mKineReader->getNEvents(0)), "C"); + mLegendRad->AddEntry("Good_Rad", "good", "lep"); + mLegendRad->AddEntry("Fake_Rad", "fake", "lep"); + mLegendRad->AddEntry("Decay_Radius_MC", "MC", "f"); + mLegendRad->Draw(); + mCanvasRad->SaveAs("eff_rad_sec_MC.png"); + + mCanvasZ = std::make_unique("cZ", "cZ", 1600, 1200); + mCanvasZ->cd(); + mCanvasZ->SetGrid(); + mCanvasZ->SetLogy(); + mEffZ->Draw("pz"); + mEffFakeZ->Draw("pz same"); + HistoMC[3].Draw(" histsame"); // HistoMC[1] + mLegendZ = std::make_unique(0.19, 0.8, 0.40, 0.96); + mLegendZ->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); + mLegendZ->AddEntry("Good_Z", "good", "lep"); + mLegendZ->AddEntry("Fake_Z", "fake", "lep"); + mLegendZ->AddEntry("Zsv_MC", "MC", "f"); + + mLegendZ->Draw(); + mCanvasZ->SaveAs("eff_Z_sec_MC.png"); + + mCanvasRadD = std::make_unique("cRadD", "cRadD", 1600, 1200); + mCanvasRadD->cd(); + mCanvasRadD->SetGrid(); + mEffRadk->Draw("pz"); + mEffFakeRadk->Draw("pz same"); + HistoMC[1].Draw(" hist same"); + mEffRadLam->Draw("pz same"); + mEffFakeRadLam->Draw("pz same"); + HistoMC[2].Draw(" hist same"); + mCanvasRadD->SetLogy(); + mLegendRadD = std::make_unique(0.8, 0.64, 0.95, 0.8); + mLegendRadD->SetHeader(Form("%zu events PP ", mKineReader->getNEvents(0)), "C"); + mLegendRadD->AddEntry("Good_Radk", " k^{0}_{s} good", "lep"); + mLegendRadD->AddEntry("Fake_Radk", "k^{0}_{s} fake", "lep"); + mLegendRadD->AddEntry("Decay_Radius_MC_k", "k^{0}_{s} MC", "f"); + mLegendRadD->AddEntry("Good_RadLam", " #Lambda good", "lep"); + mLegendRadD->AddEntry("Fake_RadLam", "#Lambda fake", "lep"); + mLegendRadD->AddEntry("Decay_Radius_MC_Lam", "#Lambda MC", "f"); + + mLegendRadD->Draw(); + mCanvasRadD->SaveAs("eff_RadD_sec_MC.png"); + + mCanvasZD = std::make_unique("cZ", "cZ", 1600, 1200); + mCanvasZD->cd(); + mCanvasZD->SetGrid(); + mEffZk->Draw("pz"); + mEffFakeZk->Draw("pz same"); + HistoMC[4].Draw("same hist"); // HistoMC[4] + mEffZLam->Draw("pz same"); + mEffFakeZLam->Draw("pz same"); + HistoMC[5].Draw("same hist"); // HistoMC[5] + mCanvasZD->SetLogy(); + mLegendZD = std::make_unique(0.19, 0.5, 0.30, 0.7); + mLegendZD->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); + mLegendZD->AddEntry("Good_Zk", " k^{0}_{s} good", "lep"); + mLegendZD->AddEntry("Fake_Zk", "k^{0}_{s} fake", "lep"); + mLegendZD->AddEntry("Zsv_MC_k", "k^{0}_{s} MC", "f"); + mLegendZD->AddEntry("Good_ZLam", "#Lambda good", "lep"); + mLegendZD->AddEntry("Fake_ZLam", "#Lambda fake", "lep"); + mLegendZD->AddEntry("Zsv_MC_Lam", "#Lambda MC", "f"); + + mLegendZD->Draw(); + mCanvasZD->SaveAs("eff_ZD_sec_MC.png"); + mCanvasPt2 = std::make_unique("cPt2", "cPt2", 1600, 1200); mCanvasPt2->cd(); mCanvasPt2->SetLogx(); @@ -1013,14 +1363,12 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mLegendPtRes->AddEntry("mPtResolution", "All events", "lep"); mLegendPtRes->Draw(); mCanvasPtRes->SaveAs("ptRes.png"); - fout.cd(); - mCanvasPtRes2->Write(); + mCanvasPtRes2 = std::make_unique("cPtr2", "cPtr2", 1600, 1200); mCanvasPtRes2->cd(); mPtResolution2D->Draw(); mCanvasPtRes2->SaveAs("ptRes2.png"); - fout.cd(); - mCanvasPtRes2->Write(); + mCanvasPtRes3 = std::make_unique("cPtr3", "cPtr3", 1600, 1200); mCanvasPtRes3->cd(); @@ -1035,8 +1383,6 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) g1->GetYaxis()->SetRangeUser(0, 1); g1->GetXaxis()->SetRangeUser(0, 10.); mCanvasPtRes3->SaveAs("ptRes3.png"); - fout.cd(); - mCanvasPtRes3->Write(); mCanvasPtRes4 = std::make_unique("cPt4", "cPt4", 1600, 1200); mCanvasPtRes4->cd(); @@ -1052,6 +1398,36 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mLegendPtRes2->Draw("same"); mLegendPtRes2->SaveAs("ptRes4.png"); + auto canvas = new TCanvas("fc_canvas", "Fake clusters", 1600, 1000); + canvas->Divide(4, 2); + + for (int iH{0}; iH < 4; ++iH) { + canvas->cd(iH + 1); + stackLength[iH]->Draw(); + gPad->BuildLegend(); + } + for (int iH{0}; iH < 4; ++iH) { + canvas->cd(iH + 5); + stackLength1Fake[iH]->Draw(); + gPad->BuildLegend(); + } + + canvas->SaveAs("fakeClusters2.png", "recreate"); + +auto canvas2 = new TCanvas("fc_canvas2", "Fake clusters", 1600, 1000); + canvas2->Divide(4, 2); + + for (int iH{0}; iH < 4; ++iH) { + canvas2->cd(iH + 1); + stackLength2Fake[iH]->Draw(); + gPad->BuildLegend(); + } + for (int iH{0}; iH < 2; ++iH) { + canvas2->cd(iH + 5); + stackLength3Fake[iH]->Draw(); + gPad->BuildLegend(); + } +canvas2->SaveAs("fakeClusters3.png", "recreate"); fout.cd(); mCanvasPt->Write(); mCanvasEta->Write(); @@ -1063,6 +1439,13 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasPtRes2->Write(); mCanvasPtRes3->Write(); mCanvasPtRes4->Write(); + mCanvasRad->Write(); + mCanvasZ->Write(); + mCanvasRadD->Write(); + mCanvasZD->Write(); + canvas->Write(); + canvas2->Write(); + fout.Close(); } From 9c7c9991602d4b7247b8a549943f9b0f21f107bc Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Tue, 22 Aug 2023 19:17:25 +0200 Subject: [PATCH 06/19] fix formatting --- .../postprocessing/studies/src/TrackCheck.cxx | 170 +++++++++--------- 1 file changed, 83 insertions(+), 87 deletions(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 3373de9083f72..3731dba1374cb 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -262,7 +262,7 @@ class TrackCheckStudy : public Task std::unique_ptr mLegendZD; std::unique_ptr mLegendRadD; std::vector HistoMC; - std::vector> EffVec; + // std::vector> EffVec; float rLayer0 = 2.34; float rLayer1 = 3.15; @@ -292,9 +292,7 @@ void TrackCheckStudy::init(InitContext& ic) for (int i{0}; i <= pars.effHistBins; i++) { xbins[i] = pars.effPtCutLow * std::exp(i * a); } - // to do: cut a lot of lines (reminder: use form like bt, for canvas a vector + function and from bt) mGoodPt = std::make_unique("goodPt", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - //EffVec.push_back(mGoodPt); mGoodEta = std::make_unique("goodEta", ";#eta;Number of tracks", 60, -3, 3); mGoodChi2 = std::make_unique("goodChi2", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", 200, 0, 100); @@ -425,6 +423,74 @@ void TrackCheckStudy::init(InitContext& ic) mDenominatorPt->Sumw2(); mDenominatorSecRad->Sumw2(); mDenominatorSecZ->Sumw2(); + + histLength.resize(4); // fake clusters study + histLength1Fake.resize(4); + histLength2Fake.resize(4); + histLength3Fake.resize(2); + histLengthNoCl.resize(4); + histLength1FakeNoCl.resize(4); + histLength2FakeNoCl.resize(4); + histLength3FakeNoCl.resize(2); + stackLength.resize(4); + stackLength1Fake.resize(4); + stackLength2Fake.resize(4); + stackLength3Fake.resize(2); + legends.resize(4); + legends1Fake.resize(4); + legends2Fake.resize(4); + legends3Fake.resize(2); + + for (int iH{4}; iH < 8; ++iH) { + histLength[iH - 4] = new TH1I(Form("trk_len_%d", iH), "#exists cluster", 7, -.5, 6.5); + histLength[iH - 4]->SetFillColor(kGreen + 3); + histLength[iH - 4]->SetLineColor(kGreen + 3); + histLength[iH - 4]->SetFillStyle(3352); + histLengthNoCl[iH - 4] = new TH1I(Form("trk_len_%d_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); + histLengthNoCl[iH - 4]->SetFillColor(kOrange + 7); + histLengthNoCl[iH - 4]->SetLineColor(kOrange + 7); + histLengthNoCl[iH - 4]->SetFillStyle(3352); + stackLength[iH - 4] = new THStack(Form("stack_trk_len_%d", iH), Form("trk_len=%d", iH)); + stackLength[iH - 4]->Add(histLength[iH - 4]); + stackLength[iH - 4]->Add(histLengthNoCl[iH - 4]); + + histLength1Fake[iH - 4] = new TH1I(Form("trk_len_%d_1f", iH), "#exists cluster", 7, -.5, 6.5); + histLength1Fake[iH - 4]->SetFillColor(kGreen + 3); + histLength1Fake[iH - 4]->SetLineColor(kGreen + 3); + histLength1Fake[iH - 4]->SetFillStyle(3352); + histLength1FakeNoCl[iH - 4] = new TH1I(Form("trk_len_%d_1f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); + histLength1FakeNoCl[iH - 4]->SetFillColor(kOrange + 7); + histLength1FakeNoCl[iH - 4]->SetLineColor(kOrange + 7); + histLength1FakeNoCl[iH - 4]->SetFillStyle(3352); + stackLength1Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_1f", iH), Form("trk_len=%d, 1 Fake", iH)); + stackLength1Fake[iH - 4]->Add(histLength1Fake[iH - 4]); + stackLength1Fake[iH - 4]->Add(histLength1FakeNoCl[iH - 4]); + + histLength2Fake[iH - 4] = new TH1I(Form("trk_len_%d_2f", iH), "#exists cluster", 7, -.5, 6.5); + histLength2Fake[iH - 4]->SetFillColor(kGreen + 3); + histLength2Fake[iH - 4]->SetLineColor(kGreen + 3); + histLength2Fake[iH - 4]->SetFillStyle(3352); + histLength2FakeNoCl[iH - 4] = new TH1I(Form("trk_len_%d_2f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); + histLength2FakeNoCl[iH - 4]->SetFillColor(kOrange + 7); + histLength2FakeNoCl[iH - 4]->SetLineColor(kOrange + 7); + histLength2FakeNoCl[iH - 4]->SetFillStyle(3352); + stackLength2Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_2f", iH), Form("trk_len=%d, 2 Fake", iH)); + stackLength2Fake[iH - 4]->Add(histLength2Fake[iH - 4]); + stackLength2Fake[iH - 4]->Add(histLength2FakeNoCl[iH - 4]); + if (iH > 5) { + histLength3Fake[iH - 6] = new TH1I(Form("trk_len_%d_3f", iH), "#exists cluster", 7, -.5, 6.5); + histLength3Fake[iH - 6]->SetFillColor(kGreen + 3); + histLength3Fake[iH - 6]->SetLineColor(kGreen + 3); + histLength3Fake[iH - 6]->SetFillStyle(3352); + histLength3FakeNoCl[iH - 6] = new TH1I(Form("trk_len_%d_3f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); + histLength3FakeNoCl[iH - 6]->SetFillColor(kOrange + 7); + histLength3FakeNoCl[iH - 6]->SetLineColor(kOrange + 7); + histLength3FakeNoCl[iH - 6]->SetFillStyle(3352); + stackLength3Fake[iH - 6] = new THStack(Form("stack_trk_len_%d_3f", iH), Form("trk_len=%d, 3 Fake", iH)); + stackLength3Fake[iH - 6]->Add(histLength3Fake[iH - 6]); + stackLength3Fake[iH - 6]->Add(histLength3FakeNoCl[iH - 6]); + } + } } void TrackCheckStudy::run(ProcessingContext& pc) @@ -527,73 +593,6 @@ void TrackCheckStudy::process() LOGP(info, "\t- Total number of fakes: {} ({:.2f} %)", fakes, fakes * 100. / mTracks.size()); LOGP(info, "\t- Total number of good: {} ({:.2f} %)", good, good * 100. / mTracks.size()); - histLength.resize(4); - histLength1Fake.resize(4); - histLength2Fake.resize(4); - histLength3Fake.resize(2); - histLengthNoCl.resize(4); - histLength1FakeNoCl.resize(4); - histLength2FakeNoCl.resize(4); - histLength3FakeNoCl.resize(2); - stackLength.resize(4); - stackLength1Fake.resize(4); - stackLength2Fake.resize(4); - stackLength3Fake.resize(2); - legends.resize(4); - legends1Fake.resize(4); - legends2Fake.resize(4); - legends3Fake.resize(2); - - for (int iH{4}; iH < 8; ++iH) { - histLength[iH - 4] = new TH1I(Form("trk_len_%d", iH), "#exists cluster", 7, -.5, 6.5); - histLength[iH - 4]->SetFillColor(kGreen + 3); - histLength[iH - 4]->SetLineColor(kGreen + 3); - histLength[iH - 4]->SetFillStyle(3352); - histLengthNoCl[iH - 4] = new TH1I(Form("trk_len_%d_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); - histLengthNoCl[iH - 4]->SetFillColor(kOrange + 7); - histLengthNoCl[iH - 4]->SetLineColor(kOrange + 7); - histLengthNoCl[iH - 4]->SetFillStyle(3352); - stackLength[iH - 4] = new THStack(Form("stack_trk_len_%d", iH), Form("trk_len=%d", iH)); - stackLength[iH - 4]->Add(histLength[iH - 4]); - stackLength[iH - 4]->Add(histLengthNoCl[iH - 4]); - - histLength1Fake[iH - 4] = new TH1I(Form("trk_len_%d_1f", iH), "#exists cluster", 7, -.5, 6.5); - histLength1Fake[iH - 4]->SetFillColor(kGreen + 3); - histLength1Fake[iH - 4]->SetLineColor(kGreen + 3); - histLength1Fake[iH - 4]->SetFillStyle(3352); - histLength1FakeNoCl[iH - 4] = new TH1I(Form("trk_len_%d_1f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); - histLength1FakeNoCl[iH - 4]->SetFillColor(kOrange + 7); - histLength1FakeNoCl[iH - 4]->SetLineColor(kOrange + 7); - histLength1FakeNoCl[iH - 4]->SetFillStyle(3352); - stackLength1Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_1f", iH), Form("trk_len=%d, 1 Fake", iH)); - stackLength1Fake[iH - 4]->Add(histLength1Fake[iH - 4]); - stackLength1Fake[iH - 4]->Add(histLength1FakeNoCl[iH - 4]); - - histLength2Fake[iH - 4] = new TH1I(Form("trk_len_%d_2f", iH), "#exists cluster", 7, -.5, 6.5); - histLength2Fake[iH - 4]->SetFillColor(kGreen + 3); - histLength2Fake[iH - 4]->SetLineColor(kGreen + 3); - histLength2Fake[iH - 4]->SetFillStyle(3352); - histLength2FakeNoCl[iH - 4] = new TH1I(Form("trk_len_%d_2f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); - histLength2FakeNoCl[iH - 4]->SetFillColor(kOrange + 7); - histLength2FakeNoCl[iH - 4]->SetLineColor(kOrange + 7); - histLength2FakeNoCl[iH - 4]->SetFillStyle(3352); - stackLength2Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_2f", iH), Form("trk_len=%d, 2 Fake", iH)); - stackLength2Fake[iH - 4]->Add(histLength2Fake[iH - 4]); - stackLength2Fake[iH - 4]->Add(histLength2FakeNoCl[iH - 4]); - if (iH > 5) { - histLength3Fake[iH - 6] = new TH1I(Form("trk_len_%d_3f", iH), "#exists cluster", 7, -.5, 6.5); - histLength3Fake[iH - 6]->SetFillColor(kGreen + 3); - histLength3Fake[iH - 6]->SetLineColor(kGreen + 3); - histLength3Fake[iH - 6]->SetFillStyle(3352); - histLength3FakeNoCl[iH - 6] = new TH1I(Form("trk_len_%d_3f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); - histLength3FakeNoCl[iH - 6]->SetFillColor(kOrange + 7); - histLength3FakeNoCl[iH - 6]->SetLineColor(kOrange + 7); - histLength3FakeNoCl[iH - 6]->SetFillStyle(3352); - stackLength3Fake[iH - 6] = new THStack(Form("stack_trk_len_%d_3f", iH), Form("trk_len=%d, 3 Fake", iH)); - stackLength3Fake[iH - 6]->Add(histLength3Fake[iH - 6]); - stackLength3Fake[iH - 6]->Add(histLength3FakeNoCl[iH - 6]); - } - } LOGP(info, "** Filling histograms ... "); int evID = 0; int trackID = 0; @@ -840,7 +839,7 @@ void TrackCheckStudy::process() auto len = track.getNClusters(); for (int iLayer{0}; iLayer < 7; ++iLayer) { if (track.hasHitOnLayer(iLayer)) { - if (track.isFakeOnLayer(iLayer)) { // Reco track has fake cluster + if (track.isFakeOnLayer(iLayer)) { // Reco track has fake cluster if (part.clusters & (0x1 << iLayer)) { // Correct cluster exists histLength[len - 4]->Fill(iLayer); if (track.getNFakeClusters() == 1) { @@ -1195,7 +1194,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasRad->SetGrid(); mEffRad->Draw("pz"); mEffFakeRad->Draw("pz same"); - HistoMC[0].Draw("hist same"); // HistoMC[0] + HistoMC[0].Draw("hist same"); mCanvasRad->SetLogy(); mLegendRad = std::make_unique(0.8, 0.4, 0.95, 0.6); mLegendRad->SetHeader(Form("%zu events PP ", mKineReader->getNEvents(0)), "C"); @@ -1211,7 +1210,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasZ->SetLogy(); mEffZ->Draw("pz"); mEffFakeZ->Draw("pz same"); - HistoMC[3].Draw(" histsame"); // HistoMC[1] + HistoMC[3].Draw(" histsame"); mLegendZ = std::make_unique(0.19, 0.8, 0.40, 0.96); mLegendZ->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); mLegendZ->AddEntry("Good_Z", "good", "lep"); @@ -1248,11 +1247,10 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasZD->SetGrid(); mEffZk->Draw("pz"); mEffFakeZk->Draw("pz same"); - HistoMC[4].Draw("same hist"); // HistoMC[4] + HistoMC[4].Draw("same hist"); mEffZLam->Draw("pz same"); mEffFakeZLam->Draw("pz same"); - HistoMC[5].Draw("same hist"); // HistoMC[5] - mCanvasZD->SetLogy(); + HistoMC[5].Draw("same hist"); mLegendZD = std::make_unique(0.19, 0.5, 0.30, 0.7); mLegendZD->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); mLegendZD->AddEntry("Good_Zk", " k^{0}_{s} good", "lep"); @@ -1400,7 +1398,6 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) auto canvas = new TCanvas("fc_canvas", "Fake clusters", 1600, 1000); canvas->Divide(4, 2); - for (int iH{0}; iH < 4; ++iH) { canvas->cd(iH + 1); stackLength[iH]->Draw(); @@ -1414,20 +1411,20 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) canvas->SaveAs("fakeClusters2.png", "recreate"); -auto canvas2 = new TCanvas("fc_canvas2", "Fake clusters", 1600, 1000); - canvas2->Divide(4, 2); - - for (int iH{0}; iH < 4; ++iH) { - canvas2->cd(iH + 1); - stackLength2Fake[iH]->Draw(); - gPad->BuildLegend(); + auto canvas2 = new TCanvas("fc_canvas2", "Fake clusters", 1600, 1000); + canvas2->Divide(4, 2); + + for (int iH{0}; iH < 4; ++iH) { + canvas2->cd(iH + 1); + stackLength2Fake[iH]->Draw(); + gPad->BuildLegend(); } for (int iH{0}; iH < 2; ++iH) { - canvas2->cd(iH + 5); + canvas2->cd(iH + 5); stackLength3Fake[iH]->Draw(); gPad->BuildLegend(); } -canvas2->SaveAs("fakeClusters3.png", "recreate"); + canvas2->SaveAs("fakeClusters3.png", "recreate"); fout.cd(); mCanvasPt->Write(); mCanvasEta->Write(); @@ -1446,7 +1443,6 @@ canvas2->SaveAs("fakeClusters3.png", "recreate"); canvas->Write(); canvas2->Write(); - fout.Close(); } From 729455fda4a02f706968319647d472dbcb434885 Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Tue, 22 Aug 2023 19:21:44 +0200 Subject: [PATCH 07/19] fix formatting --- .../ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 3731dba1374cb..eb2f6412e972d 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -1414,10 +1414,10 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) auto canvas2 = new TCanvas("fc_canvas2", "Fake clusters", 1600, 1000); canvas2->Divide(4, 2); - for (int iH{0}; iH < 4; ++iH) { - canvas2->cd(iH + 1); - stackLength2Fake[iH]->Draw(); - gPad->BuildLegend(); + for (int iH{0}; iH < 4; ++iH) { + canvas2->cd(iH + 1); + stackLength2Fake[iH]->Draw(); + gPad->BuildLegend(); } for (int iH{0}; iH < 2; ++iH) { canvas2->cd(iH + 5); From bc00f89cfeb267450b52ff1c26d01b60137963b2 Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Fri, 25 Aug 2023 15:34:52 +0200 Subject: [PATCH 08/19] ITS-Study: change structure, add Fake cluster study --- .../postprocessing/studies/src/TrackCheck.cxx | 761 ++++++------------ 1 file changed, 262 insertions(+), 499 deletions(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index eb2f6412e972d..39b2eb2ad675d 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -77,6 +77,7 @@ class TrackCheckStudy : public Task LOGP(info, "Read MCKine reader with {} sources", mKineReader->getNSources()); } } + ~TrackCheckStudy() final = default; void init(InitContext&) final; void run(ProcessingContext&) final; @@ -84,6 +85,7 @@ class TrackCheckStudy : public Task void finaliseCCDB(ConcreteDataMatcher&, void*) final; void initialiseRun(o2::globaltracking::RecoContainer&); void process(); + void setEfficiencyGraph(std::unique_ptr&, const char*, const int, const double, const double, const int, const double); void setEfficiencyGraph(std::unique_ptr&, const char*, const char*, const int, const double, const double, const int, const double); void setHistoMCGraph(TH1D&, std::unique_ptr&, const char*, const char*, const int, const double); void NormalizeHistos(std::vector&); @@ -132,17 +134,14 @@ class TrackCheckStudy : public Task std::unique_ptr mFakeRad; std::unique_ptr mGoodZ; std::unique_ptr mFakeZ; - std::unique_ptr mRadk; // decay radius and z of sv for particle with mother k e lambda std::unique_ptr mZk; std::unique_ptr mRadLam; std::unique_ptr mZLam; - std::unique_ptr mGoodRadk; std::unique_ptr mFakeRadk; std::unique_ptr mGoodZk; std::unique_ptr mFakeZk; - std::unique_ptr mGoodRadLam; std::unique_ptr mFakeRadLam; std::unique_ptr mGoodZLam; @@ -151,79 +150,23 @@ class TrackCheckStudy : public Task std::unique_ptr mEffPt; // Eff vs Pt primary std::unique_ptr mEffFakePt; std::unique_ptr mEffClonesPt; - std::unique_ptr mEffEta; // Eff vs Eta primary std::unique_ptr mEffFakeEta; std::unique_ptr mEffClonesEta; std::unique_ptr mEffRad; // Eff vs Radius secondary std::unique_ptr mEffFakeRad; - std::unique_ptr mEffZ; // Eff vs Z of sv secondary std::unique_ptr mEffFakeZ; - std::unique_ptr mEffRadk; // Eff vs Z of sv and decay radius secondary for particle with mother k e lambda std::unique_ptr mEffFakeRadk; - std::unique_ptr mEffZk; std::unique_ptr mEffFakeZk; - std::unique_ptr mEffRadLam; std::unique_ptr mEffFakeRadLam; - std::unique_ptr mEffZLam; std::unique_ptr mEffFakeZLam; - std::unique_ptr mEff0Pt; // Eff vs Pt secondary for different layer - std::unique_ptr mEff1Pt; - std::unique_ptr mEff2Pt; - std::unique_ptr mEff3Pt; - - std::unique_ptr mEff0FakePt; - std::unique_ptr mEff1FakePt; - std::unique_ptr mEff2FakePt; - std::unique_ptr mEff3FakePt; - - std::unique_ptr mEff0Eta; // Eff vs eta secondary for different layer - std::unique_ptr mEff1Eta; - std::unique_ptr mEff2Eta; - std::unique_ptr mEff3Eta; - - std::unique_ptr mEff0FakeEta; - std::unique_ptr mEff1FakeEta; - std::unique_ptr mEff2FakeEta; - std::unique_ptr mEff3FakeEta; - - std::unique_ptr mGoodPt0; // Pt secondary for different layer - std::unique_ptr mGoodPt1; - std::unique_ptr mGoodPt2; - std::unique_ptr mGoodPt3; - - std::unique_ptr mFakePt0; - std::unique_ptr mFakePt1; - std::unique_ptr mFakePt2; - std::unique_ptr mFakePt3; - - std::unique_ptr mGoodEta0; // eta secondary for different layer - std::unique_ptr mGoodEta1; - std::unique_ptr mGoodEta2; - std::unique_ptr mGoodEta3; - - std::unique_ptr mFakeEta0; - std::unique_ptr mFakeEta1; - std::unique_ptr mFakeEta2; - std::unique_ptr mFakeEta3; - - std::unique_ptr mPtSec0Pt; - std::unique_ptr mPtSec1Pt; - std::unique_ptr mPtSec2Pt; - std::unique_ptr mPtSec3Pt; - - std::unique_ptr mPtSec0Eta; - std::unique_ptr mPtSec1Eta; - std::unique_ptr mPtSec2Eta; - std::unique_ptr mPtSec3Eta; - std::unique_ptr mPtResolution; // Pt resolution for both primary and secondary std::unique_ptr mPtResolution2D; std::unique_ptr mPtResolutionSec; @@ -233,7 +176,8 @@ class TrackCheckStudy : public Task std::vector histLength, histLength1Fake, histLength2Fake, histLength3Fake, histLengthNoCl, histLength1FakeNoCl, histLength2FakeNoCl, histLength3FakeNoCl; // FakeCluster Study std::vector stackLength, stackLength1Fake, stackLength2Fake, stackLength3Fake; std::vector legends, legends1Fake, legends2Fake, legends3Fake; - ParticleInfo pInfo; + std::vector> mGoodPts, mFakePts, mTotPts, mGoodEtas, mFakeEtas, mTotEtas, mGoodPtsK, mFakePtsK, mTotPtsK, mGoodPtsLam, mFakePtsLam, mTotPtsLam, mGoodPtsIperT, mFakePtsIperT, mTotPtsIperT; + std::vector> mEffGoodPts, mEffFakePts, mEffGoodEtas, mEffFakeEtas, mEffGoodPtsK, mEffFakePtsK, mEffGoodPtsLam, mEffFakePtsLam, mEffGoodPtsIperT, mEffFakePtsIperT; // Canvas & decorations std::unique_ptr mCanvasPt; std::unique_ptr mCanvasPt2; @@ -262,7 +206,6 @@ class TrackCheckStudy : public Task std::unique_ptr mLegendZD; std::unique_ptr mLegendRadD; std::vector HistoMC; - // std::vector> EffVec; float rLayer0 = 2.34; float rLayer1 = 3.15; @@ -278,6 +221,16 @@ class TrackCheckStudy : public Task std::unique_ptr mDBGOut; }; +void TrackCheckStudy::NormalizeHistos(std::vector& HistoMC) +{ + int nHist = HistoMC.size(); + for (int jh = 0; jh < nHist; jh++) { + double tot = HistoMC[jh].Integral(); + if (tot > 0) + HistoMC[jh].Scale(1. / tot); + } +} + void TrackCheckStudy::init(InitContext& ic) { o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest); @@ -309,8 +262,8 @@ void TrackCheckStudy::init(InitContext& ic) mFakeRad = std::make_unique("fakeRad", ";#Radius [cm];Number of tracks", 100, 0, 25); mFakeZ = std::make_unique("fakeZ", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); - mFakeRadk = std::make_unique("fakeRadLam", ";#Radius [cm];Number of tracks", 100, 0, 25); - mFakeZk = std::make_unique("fakeZLam", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); + mFakeRadk = std::make_unique("fakeRadK", ";#Radius [cm];Number of tracks", 100, 0, 25); + mFakeZk = std::make_unique("fakeZk", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); mFakeRadLam = std::make_unique("fakeRadLam", ";#Radius [cm];Number of tracks", 100, 0, 25); mFakeZLam = std::make_unique("fakeZLam", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); @@ -328,36 +281,67 @@ void TrackCheckStudy::init(InitContext& ic) mRadLam = std::make_unique("mRadLam", ";Radius [cm];Number of tracks", 100, 0, 25); mZk = std::make_unique("mZk", ";z of secondary vertex [cm]", 100, -50, 50); mZLam = std::make_unique("mZLam", ";z of secondary vertex [cm]", 100, -50, 50); - - mGoodPt0 = std::make_unique("goodPt0", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mGoodPt1 = std::make_unique("goodPt1", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mGoodPt2 = std::make_unique("goodPt2", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mGoodPt3 = std::make_unique("goodPt3", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - - mFakePt0 = std::make_unique("FakePt0", ";#it{p}_{T} (GeV/#it{c});Efficiency (Fake-track rate)", pars.effHistBins, xbins.data()); - mFakePt1 = std::make_unique("FakePt1", ";#it{p}_{T} (GeV/#it{c});Efficiency (Fake-track rate)", pars.effHistBins, xbins.data()); - mFakePt2 = std::make_unique("FakePt2", ";#it{p}_{T} (GeV/#it{c});Efficiency (Fake-track rate)", pars.effHistBins, xbins.data()); - mFakePt3 = std::make_unique("FakePt3", ";#it{p}_{T} (GeV/#it{c});Efficiency (Fake-track rate)", pars.effHistBins, xbins.data()); - - mGoodEta0 = std::make_unique("goodEta0", ";#eta;Number of tracks", 60, -3, 3); - mGoodEta1 = std::make_unique("goodEta1", ";#eta;Number of tracks", 60, -3, 3); - mGoodEta2 = std::make_unique("goodEta2", ";#eta;Number of tracks", 60, -3, 3); - mGoodEta3 = std::make_unique("goodEta3", ";#eta;Number of tracks", 60, -3, 3); - - mFakeEta0 = std::make_unique("FakeEta0", ";#eta;Number of tracks", 60, -3, 3); - mFakeEta1 = std::make_unique("FakeEta1", ";#eta;Number of tracks", 60, -3, 3); - mFakeEta2 = std::make_unique("FakeEta2", ";#eta;Number of tracks", 60, -3, 3); - mFakeEta3 = std::make_unique("FakeEta3", ";#eta;Number of tracks", 60, -3, 3); - - mPtSec0Pt = std::make_unique("mPtSec0Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})", pars.effHistBins, xbins.data()); - mPtSec1Pt = std::make_unique("mPtSec1Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})", pars.effHistBins, xbins.data()); - mPtSec2Pt = std::make_unique("mPtSec2Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})", pars.effHistBins, xbins.data()); - mPtSec3Pt = std::make_unique("mPtSec3Pt", ";#it{p}_{T} (GeV/#it{c}); ;#it{p}_{T} (GeV/#it{c})", pars.effHistBins, xbins.data()); - - mPtSec0Eta = std::make_unique("mPtSec0Eta", ";#eta;Number of tracks", 60, -3, 3); - mPtSec1Eta = std::make_unique("mPtSec1Eta", ";#eta;Number of tracks", 60, -3, 3); - mPtSec2Eta = std::make_unique("mPtSec2Eta", ";#eta;Number of tracks", 60, -3, 3); - mPtSec3Eta = std::make_unique("mPtSec3Eta", ";#eta;Number of tracks", 60, -3, 3); + mGoodPts.resize(4); + mFakePts.resize(4); + mTotPts.resize(4); + mGoodEtas.resize(4); + mFakeEtas.resize(4); + mTotEtas.resize(4); + mGoodPtsK.resize(4); + mFakePtsK.resize(4); + mTotPtsK.resize(4); + mGoodPtsLam.resize(4); + mFakePtsLam.resize(4); + mTotPtsLam.resize(4); + mGoodPtsIperT.resize(4); + mFakePtsIperT.resize(4); + mTotPtsIperT.resize(4); + mEffGoodPts.resize(4); + mEffFakePts.resize(4); + mEffGoodEtas.resize(4); + mEffFakeEtas.resize(4); + mEffGoodPtsK.resize(4); + mEffFakePtsK.resize(4); + mEffGoodPtsLam.resize(4); + mEffFakePtsLam.resize(4); + mEffGoodPtsIperT.resize(4); + mEffFakePtsIperT.resize(4); + + for (int yy = 0; yy < 4; yy++) { // divided by layer + mGoodPts[yy] = std::make_unique(Form("goodPts%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mFakePts[yy] = std::make_unique(Form("FakePs%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mTotPts[yy] = std::make_unique(Form("TotPts%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + + mGoodEtas[yy] = std::make_unique(Form("goodEtas%d", yy), ";#eta;Number of tracks", 60, -3, 3); + mFakeEtas[yy] = std::make_unique(Form("FakeEtas%d", yy), ";#eta;Number of tracks", 60, -3, 3); + mTotEtas[yy] = std::make_unique(Form("TotEtas%d", yy), ";#eta;Number of tracks", 60, -3, 3); + + mGoodPtsK[yy] = std::make_unique(Form("goodPtK%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mFakePtsK[yy] = std::make_unique(Form("FakePtK%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mTotPtsK[yy] = std::make_unique(Form("TotPtK%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mGoodPtsLam[yy] = std::make_unique(Form("goodPtLam%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mFakePtsLam[yy] = std::make_unique(Form("FakePtLam%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mTotPtsLam[yy] = std::make_unique(Form("TotPtLam%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mGoodPtsIperT[yy] = std::make_unique(Form("goodPtIperT%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mFakePtsIperT[yy] = std::make_unique(Form("FakePtIperT%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mTotPtsIperT[yy] = std::make_unique(Form("TotPtIperT%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + + mGoodPts[yy]->Sumw2(); + mFakePts[yy]->Sumw2(); + mTotPts[yy]->Sumw2(); + mGoodEtas[yy]->Sumw2(); + mFakeEtas[yy]->Sumw2(); + mTotEtas[yy]->Sumw2(); + mGoodPtsK[yy]->Sumw2(); + mFakePtsK[yy]->Sumw2(); + mTotPtsK[yy]->Sumw2(); + mGoodPtsLam[yy]->Sumw2(); + mFakePtsLam[yy]->Sumw2(); + mTotPtsLam[yy]->Sumw2(); + mGoodPtsIperT[yy]->Sumw2(); + mFakePtsIperT[yy]->Sumw2(); + mTotPtsIperT[yy]->Sumw2(); + } mPtResolution = std::make_unique("PtResolution", ";#it{p}_{T} ;Den", 100, -1, 1); mPtResolutionSec = std::make_unique("PtResolutionSec", ";#it{p}_{T} ;Den", 100, -1, 1); @@ -373,36 +357,6 @@ void TrackCheckStudy::init(InitContext& ic) mZk->Sumw2(); mZLam->Sumw2(); - mGoodPt0->Sumw2(); - mGoodPt1->Sumw2(); - mGoodPt2->Sumw2(); - mGoodPt3->Sumw2(); - - mFakePt0->Sumw2(); - mFakePt1->Sumw2(); - mFakePt2->Sumw2(); - mFakePt3->Sumw2(); - - mGoodEta0->Sumw2(); - mGoodEta1->Sumw2(); - mGoodEta2->Sumw2(); - mGoodEta3->Sumw2(); - - mFakeEta0->Sumw2(); - mFakeEta1->Sumw2(); - mFakeEta2->Sumw2(); - mFakeEta3->Sumw2(); - - mPtSec0Pt->Sumw2(); - mPtSec1Pt->Sumw2(); - mPtSec2Pt->Sumw2(); - mPtSec3Pt->Sumw2(); - - mPtSec0Eta->Sumw2(); - mPtSec1Eta->Sumw2(); - mPtSec2Eta->Sumw2(); - mPtSec3Eta->Sumw2(); - mGoodPt->Sumw2(); mGoodEta->Sumw2(); mGoodRad->Sumw2(); @@ -427,19 +381,19 @@ void TrackCheckStudy::init(InitContext& ic) histLength.resize(4); // fake clusters study histLength1Fake.resize(4); histLength2Fake.resize(4); - histLength3Fake.resize(2); + histLength3Fake.resize(4); histLengthNoCl.resize(4); histLength1FakeNoCl.resize(4); histLength2FakeNoCl.resize(4); - histLength3FakeNoCl.resize(2); + histLength3FakeNoCl.resize(4); stackLength.resize(4); stackLength1Fake.resize(4); stackLength2Fake.resize(4); - stackLength3Fake.resize(2); + stackLength3Fake.resize(4); legends.resize(4); legends1Fake.resize(4); legends2Fake.resize(4); - legends3Fake.resize(2); + legends3Fake.resize(4); for (int iH{4}; iH < 8; ++iH) { histLength[iH - 4] = new TH1I(Form("trk_len_%d", iH), "#exists cluster", 7, -.5, 6.5); @@ -477,19 +431,18 @@ void TrackCheckStudy::init(InitContext& ic) stackLength2Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_2f", iH), Form("trk_len=%d, 2 Fake", iH)); stackLength2Fake[iH - 4]->Add(histLength2Fake[iH - 4]); stackLength2Fake[iH - 4]->Add(histLength2FakeNoCl[iH - 4]); - if (iH > 5) { - histLength3Fake[iH - 6] = new TH1I(Form("trk_len_%d_3f", iH), "#exists cluster", 7, -.5, 6.5); - histLength3Fake[iH - 6]->SetFillColor(kGreen + 3); - histLength3Fake[iH - 6]->SetLineColor(kGreen + 3); - histLength3Fake[iH - 6]->SetFillStyle(3352); - histLength3FakeNoCl[iH - 6] = new TH1I(Form("trk_len_%d_3f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); - histLength3FakeNoCl[iH - 6]->SetFillColor(kOrange + 7); - histLength3FakeNoCl[iH - 6]->SetLineColor(kOrange + 7); - histLength3FakeNoCl[iH - 6]->SetFillStyle(3352); - stackLength3Fake[iH - 6] = new THStack(Form("stack_trk_len_%d_3f", iH), Form("trk_len=%d, 3 Fake", iH)); - stackLength3Fake[iH - 6]->Add(histLength3Fake[iH - 6]); - stackLength3Fake[iH - 6]->Add(histLength3FakeNoCl[iH - 6]); - } + + histLength3Fake[iH - 4] = new TH1I(Form("trk_len_%d_3f", iH), "#exists cluster", 7, -.5, 6.5); + histLength3Fake[iH - 4]->SetFillColor(kGreen + 3); + histLength3Fake[iH - 4]->SetLineColor(kGreen + 3); + histLength3Fake[iH - 4]->SetFillStyle(3352); + histLength3FakeNoCl[iH - 4] = new TH1I(Form("trk_len_%d_3f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); + histLength3FakeNoCl[iH - 4]->SetFillColor(kOrange + 7); + histLength3FakeNoCl[iH - 4]->SetLineColor(kOrange + 7); + histLength3FakeNoCl[iH - 4]->SetFillStyle(3352); + stackLength3Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_3f", iH), Form("trk_len=%d, 3 Fake", iH)); + stackLength3Fake[iH - 4]->Add(histLength3Fake[iH - 4]); + stackLength3Fake[iH - 4]->Add(histLength3FakeNoCl[iH - 4]); } } @@ -559,9 +512,10 @@ void TrackCheckStudy::process() } LOGP(info, "** Analysing tracks ... "); int unaccounted{0}, good{0}, fakes{0}, total{0}; - int good0 = 0, good1 = 0, good2 = 0, good3 = 0, totalsec = 0; // secondary + int good0 = 0, good1 = 0, good2 = 0, good3 = 0, totalsec = 0, totsectake = 0; // secondary int fake0 = 0, fake1 = 0, fake2 = 0, fake3 = 0; int totsec0 = 0, totsec1 = 0, totsec2 = 0, totsec3 = 0; + int nlayer = 999; for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { auto& lab = mTracksMCLabels[iTrack]; if (!lab.isSet() || lab.isNoise()) { @@ -596,6 +550,9 @@ void TrackCheckStudy::process() LOGP(info, "** Filling histograms ... "); int evID = 0; int trackID = 0; + int Ltot, Ktot, Itot; + int LtotG, KtotG, ItotG; + int LtotF, KtotF, ItotF; // Currently process only sourceID = 0, to be extended later if needed for (auto& evInfo : mParticleInfo[0]) { trackID = 0; @@ -606,7 +563,7 @@ void TrackCheckStudy::process() // part.clusters != 0x0f && part.clusters != 0x0f << 1 && part.clusters != 0x0f << 2 && part.clusters != 0x0f << 3) { // continue; - if (part.isPrimary) { + if (part.isPrimary) { // **Primary particle** mDenominatorPt->Fill(part.pt); mDenominatorEta->Fill(part.eta); if (part.isReco) { @@ -631,245 +588,123 @@ void TrackCheckStudy::process() } } - if (!part.isPrimary) { - + if (!part.isPrimary) { // **Secondary particle** totalsec++; int pdgcode = mParticleInfo[0][evID][part.mother].pdg; float rad = sqrt(pow(part.vx, 2) + pow(part.vy, 2)); if ((rad < rLayer0) && (part.clusters == 0x7f || part.clusters == 0x3f || part.clusters == 0x1f || part.clusters == 0x0f)) // layer 0 - { - if (pdgcode == 310) // k0s - { - mRadk->Fill(rad); - mZk->Fill(part.vz); - } - if (pdgcode == 3122) { // Lambda - mRadLam->Fill(rad); - mZLam->Fill(part.vz); - } - totsec0++; - mPtSec0Pt->Fill(part.pt); - mPtSec0Eta->Fill(part.eta); + nlayer = 0; + if (rad < rLayer1 && rad > rLayer0 && (part.clusters == 0x1e || part.clusters == 0x3e || part.clusters == 0x7e)) // layer 1 + nlayer = 1; + if (rad < rLayer2 && rad > rLayer1 && (part.clusters == 0x7c || part.clusters == 0x3c)) // layer 2 + nlayer = 2; + if (rad < rLayer3 && rad > rLayer2 && part.clusters == 0x78) // layer 3 + nlayer = 3; + if (nlayer == 0 || nlayer == 1 || nlayer == 2 || nlayer == 3) { mDenominatorSecRad->Fill(rad); mDenominatorSecZ->Fill(part.vz); + totsectake++; + mTotPts[nlayer]->Fill(part.pt); + mTotEtas[nlayer]->Fill(part.eta); + if (part.isReco) { - mGoodPt0->Fill(part.pt); - mGoodEta0->Fill(part.eta); - mGoodRad->Fill(rad); - mGoodZ->Fill(part.vz); - if (pdgcode == 310) { - mGoodRadk->Fill(rad); - mGoodZk->Fill(part.vz); - } - if (pdgcode == 3122) { - mGoodRadLam->Fill(rad); - mGoodZLam->Fill(part.vz); - } - good0++; + mGoodPts[nlayer]->Fill(part.pt); + mGoodEtas[nlayer]->Fill(part.eta); } if (part.isFake) { - mFakePt0->Fill(part.pt); - mFakeEta0->Fill(part.eta); - mFakeRad->Fill(rad); - mFakeZ->Fill(part.vz); - if (pdgcode == 310) { - mFakeRadk->Fill(rad); - mFakeZk->Fill(part.vz); - } - if (pdgcode == 3122) { - mFakeRadLam->Fill(rad); - mFakeZLam->Fill(part.vz); - } - fake0++; + mFakePts[nlayer]->Fill(part.pt); + mFakeEtas[nlayer]->Fill(part.eta); } - } - - if (rad < rLayer1 && rad > rLayer0 && (part.clusters == 0x1e || part.clusters == 0x3e || part.clusters == 0x7e)) // layer 1 - { - if (pdgcode == 310) { + if (pdgcode == 310) // k0s + { mRadk->Fill(rad); mZk->Fill(part.vz); - } - if (pdgcode == 3122) { - mRadLam->Fill(rad); - mZLam->Fill(part.vz); - } - totsec1++; - mPtSec1Pt->Fill(part.pt); - mPtSec1Eta->Fill(part.eta); - mDenominatorSecRad->Fill(rad); - mDenominatorSecZ->Fill(part.vz); - if (part.isReco) { - mGoodPt1->Fill(part.pt); - mGoodEta1->Fill(part.eta); - mGoodRad->Fill(rad); - mGoodZ->Fill(part.vz); - if (pdgcode == 310) { + mTotPtsK[nlayer]->Fill(part.pt); + if (part.isReco) { mGoodRadk->Fill(rad); mGoodZk->Fill(part.vz); + mGoodPtsK[nlayer]->Fill(part.pt); } - if (pdgcode == 3122) { - mGoodRadLam->Fill(rad); - mGoodZLam->Fill(part.vz); - } - good1++; - } - if (part.isFake) { - mFakePt1->Fill(part.pt); - mFakeEta1->Fill(part.eta); - mFakeRad->Fill(rad); - mFakeZ->Fill(part.vz); - if (pdgcode == 310) { + if (part.isFake) { mFakeRadk->Fill(rad); mFakeZk->Fill(part.vz); + mFakePtsK[nlayer]->Fill(part.pt); } - if (pdgcode == 3122) { - mFakeRadLam->Fill(rad); - mFakeZLam->Fill(part.vz); - } - fake1++; } - } - - if (rad < rLayer2 && rad > rLayer1 && (part.clusters == 0x7c || part.clusters == 0x3c)) // layer 2 - { - if (pdgcode == 310) { - mRadk->Fill(rad); - mZk->Fill(part.vz); - } - if (pdgcode == 3122) { + if (pdgcode == 3122) // Lambda + { mRadLam->Fill(rad); mZLam->Fill(part.vz); - } - totsec2++; - mPtSec2Pt->Fill(part.pt); - mPtSec2Eta->Fill(part.eta); - mDenominatorSecRad->Fill(rad); - mDenominatorSecZ->Fill(part.vz); - if (part.isReco) { - mGoodPt2->Fill(part.pt); - mGoodEta2->Fill(part.eta); - mGoodRad->Fill(rad); - mGoodZ->Fill(part.vz); - if (pdgcode == 310) { - mGoodRadk->Fill(rad); - mGoodZk->Fill(part.vz); - } - if (pdgcode == 3122) { + mTotPtsLam[nlayer]->Fill(part.pt); + if (part.isReco) { mGoodRadLam->Fill(rad); mGoodZLam->Fill(part.vz); + mGoodPtsLam[nlayer]->Fill(part.pt); } - good2++; - } - if (part.isFake) { - mFakePt2->Fill(part.pt); - mFakeEta2->Fill(part.eta); - mFakeRad->Fill(rad); - mFakeZ->Fill(part.vz); - if (pdgcode == 310) { - mFakeRadk->Fill(rad); - mFakeZk->Fill(part.vz); - } - if (pdgcode == 3122) { + if (part.isFake) { mFakeRadLam->Fill(rad); mFakeZLam->Fill(part.vz); + mFakePtsLam[nlayer]->Fill(part.pt); } - fake2++; - } - } - - if (rad < rLayer3 && rad > rLayer2 && part.clusters == 0x78) // layer 3 - { - if (pdgcode == 310) { - mRadk->Fill(rad); - mZk->Fill(part.vz); } - if (pdgcode == 3122) { - mRadLam->Fill(rad); - mZLam->Fill(part.vz); - } - totsec3++; - mPtSec3Pt->Fill(part.pt); - mPtSec3Eta->Fill(part.eta); - mDenominatorSecRad->Fill(rad); - mDenominatorSecZ->Fill(part.vz); - if (part.isReco) { - mGoodPt3->Fill(part.pt); - mGoodEta3->Fill(part.eta); - mGoodRad->Fill(rad); - mGoodZ->Fill(part.vz); - if (pdgcode == 310) { - mGoodRadk->Fill(rad); - mGoodZk->Fill(part.vz); - } - if (pdgcode == 3122) { - mGoodRadLam->Fill(rad); - mGoodZLam->Fill(part.vz); - } - good3++; - } - if (part.isFake) { - mFakePt3->Fill(part.pt); - mFakeEta3->Fill(part.eta); - mFakeRad->Fill(rad); - mFakeZ->Fill(part.vz); - if (pdgcode == 310) { - mFakeRadk->Fill(rad); - mFakeZk->Fill(part.vz); + if (pdgcode == 1010010030) // IperT + { + mTotPtsIperT[nlayer]->Fill(part.pt); + if (part.isReco) { + mGoodPtsIperT[nlayer]->Fill(part.pt); } - if (pdgcode == 3122) { - mFakeRadLam->Fill(rad); - mFakeZLam->Fill(part.vz); + if (part.isFake) { + mFakePtsIperT[nlayer]->Fill(part.pt); } - fake3++; } - } - // Analysing fake clusters + // Analysing fake clusters - int nCl{0}; - for (unsigned int bit{0}; bit < sizeof(part.clusters) * 8; ++bit) { - nCl += bool(part.clusters & (1 << bit)); - } - if (nCl < 3) { - continue; - } - auto& track = part.track; - auto len = track.getNClusters(); - for (int iLayer{0}; iLayer < 7; ++iLayer) { - if (track.hasHitOnLayer(iLayer)) { - if (track.isFakeOnLayer(iLayer)) { // Reco track has fake cluster - if (part.clusters & (0x1 << iLayer)) { // Correct cluster exists - histLength[len - 4]->Fill(iLayer); - if (track.getNFakeClusters() == 1) { - histLength1Fake[len - 4]->Fill(iLayer); - } - if (track.getNFakeClusters() == 2) { - histLength2Fake[len - 4]->Fill(iLayer); - } - if (track.getNFakeClusters() == 3) { - histLength3Fake[len - 6]->Fill(iLayer); - } - - } else { - histLengthNoCl[len - 4]->Fill(iLayer); - if (track.getNFakeClusters() == 1) { - histLength1FakeNoCl[len - 4]->Fill(iLayer); - } - if (track.getNFakeClusters() == 2) { - histLength2FakeNoCl[len - 4]->Fill(iLayer); - } - if (track.getNFakeClusters() == 3) { - histLength3FakeNoCl[len - 6]->Fill(iLayer); + int nCl{0}; + for (unsigned int bit{0}; bit < sizeof(part.clusters) * 8; ++bit) { + nCl += bool(part.clusters & (1 << bit)); + } + if (nCl < 3) { + continue; + } + auto& track = part.track; + auto len = track.getNClusters(); + for (int iLayer{0}; iLayer < 7; ++iLayer) { + if (track.hasHitOnLayer(iLayer)) { + if (track.isFakeOnLayer(iLayer)) { // Reco track has fake cluster + if (part.clusters & (0x1 << iLayer)) { // Correct cluster exists + histLength[len - 4]->Fill(iLayer); + if (track.getNFakeClusters() == 1) { + histLength1Fake[len - 4]->Fill(iLayer); + } + if (track.getNFakeClusters() == 2) { + histLength2Fake[len - 4]->Fill(iLayer); + } + if (track.getNFakeClusters() == 3) { + histLength3Fake[len - 4]->Fill(iLayer); + } + } else { + histLengthNoCl[len - 4]->Fill(iLayer); + if (track.getNFakeClusters() == 1) { + histLength1FakeNoCl[len - 4]->Fill(iLayer); + } + if (track.getNFakeClusters() == 2) { + histLength2FakeNoCl[len - 4]->Fill(iLayer); + } + if (track.getNFakeClusters() == 3) { + histLength3FakeNoCl[len - 4]->Fill(iLayer); + } } } } } } } + nlayer = 999; trackID++; } + evID++; } @@ -916,25 +751,19 @@ void TrackCheckStudy::process() mEffZLam = std::make_unique(*mGoodZLam, *mZLam); mEffFakeZLam = std::make_unique(*mFakeZLam, *mZLam); - mEff0Pt = std::make_unique(*mGoodPt0, *mPtSec0Pt); - mEff1Pt = std::make_unique(*mGoodPt1, *mPtSec1Pt); - mEff2Pt = std::make_unique(*mGoodPt2, *mPtSec2Pt); - mEff3Pt = std::make_unique(*mGoodPt3, *mPtSec3Pt); - - mEff0FakePt = std::make_unique(*mFakePt0, *mPtSec0Pt); - mEff1FakePt = std::make_unique(*mFakePt1, *mPtSec1Pt); - mEff2FakePt = std::make_unique(*mFakePt2, *mPtSec2Pt); - mEff3FakePt = std::make_unique(*mFakePt3, *mPtSec3Pt); - - mEff0Eta = std::make_unique(*mGoodEta0, *mPtSec0Eta); - mEff1Eta = std::make_unique(*mGoodEta1, *mPtSec1Eta); - mEff2Eta = std::make_unique(*mGoodEta2, *mPtSec2Eta); - mEff3Eta = std::make_unique(*mGoodEta3, *mPtSec3Eta); - - mEff0FakeEta = std::make_unique(*mFakeEta0, *mPtSec0Eta); - mEff1FakeEta = std::make_unique(*mFakeEta1, *mPtSec1Eta); - mEff2FakeEta = std::make_unique(*mFakeEta2, *mPtSec2Eta); - mEff3FakeEta = std::make_unique(*mFakeEta3, *mPtSec3Eta); + for (int ii = 0; ii < 4; ii++) { + mEffGoodPts[ii] = std::make_unique(*mGoodPts[ii], *mTotPts[ii]); + mEffFakePts[ii] = std::make_unique(*mFakePts[ii], *mTotPts[ii]); + mEffGoodEtas[ii] = std::make_unique(*mGoodEtas[ii], *mTotEtas[ii]); + mEffFakeEtas[ii] = std::make_unique(*mFakeEtas[ii], *mTotEtas[ii]); + + mEffGoodPtsK[ii] = std::make_unique(*mGoodPtsK[ii], *mTotPtsK[ii]); + mEffFakePtsK[ii] = std::make_unique(*mFakePtsK[ii], *mTotPtsK[ii]); + mEffGoodPtsLam[ii] = std::make_unique(*mGoodPtsLam[ii], *mTotPtsLam[ii]); + mEffFakePtsLam[ii] = std::make_unique(*mFakePtsLam[ii], *mTotPtsLam[ii]); + mEffGoodPtsIperT[ii] = std::make_unique(*mGoodPtsIperT[ii], *mTotPtsIperT[ii]); + mEffFakePtsIperT[ii] = std::make_unique(*mFakePtsIperT[ii], *mTotPtsIperT[ii]); + } LOGP(info, "** Analysing pT resolution..."); for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { @@ -947,7 +776,6 @@ void TrackCheckStudy::process() bool pass{true}; if (srcID == 99) continue; // skip QED - // PtResVec[iTrack]=(mParticleInfo[srcID][evID][trackID].pt-mTracks[iTrack].getPt())/mParticleInfo[srcID][evID][trackID].pt; mPtResolution->Fill((mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); mPtResolution2D->Fill(mParticleInfo[srcID][evID][trackID].pt, (mParticleInfo[srcID][evID][trackID].pt - mTracks[iTrack].getPt()) / mParticleInfo[srcID][evID][trackID].pt); if (!mParticleInfo[srcID][evID][trackID].isPrimary) @@ -973,15 +801,21 @@ void TrackCheckStudy::process() aa[yy] = 0.0125; } } -} -void TrackCheckStudy::NormalizeHistos(std::vector& HistoMC) -{ - int nHist = HistoMC.size(); - for (int jh = 0; jh < nHist; jh++) { - double tot = HistoMC[jh].Integral(); - if (tot > 0) - HistoMC[jh].Scale(1. / tot); + LOGP(info, "** Analysing fake clusters ** ... "); + for (auto iSource{0}; iSource < mParticleInfo.size(); ++iSource) { + for (auto iCluster{0}; iCluster < mClusters.size(); ++iCluster) { + auto labs = mClustersMCLCont->getLabels(iCluster); // ideally I can have more than one label per cluster + for (auto& lab : labs) { + if (!lab.isValid()) { + continue; // We want to skip channels related to noise, e.g. sID = 99: QED + } + int trackID, evID, srcID; + bool fake; + const_cast(lab).get(trackID, evID, srcID, fake); + + } + } } } @@ -1024,13 +858,18 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) { TFile fout(mOutFileName.c_str(), "recreate"); NormalizeHistos(HistoMC); + // std::unique_ptr mEffPt1; + // mEffPt1=mEffPt->Clone(); setEfficiencyGraph(mEffPt, "Good_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kAzure + 4, 0.65); fout.WriteTObject(mEffPt.get()); - setEfficiencyGraph(mEffFakePt, "Fake_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kRed + 1, 0.65); + setEfficiencyGraph(mEffFakePt, "Fake_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kRed, 0.65); fout.WriteTObject(mEffFakePt.get()); + setEfficiencyGraph(mEffPt, "Tot Prim G Tracks", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kBlack, 1); + setEfficiencyGraph(mEffFakePt, "Tot Prim F Tracks", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kBlack, 1); + setEfficiencyGraph(mEffClonesPt, "Clone_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kGreen + 2, 0.65); fout.WriteTObject(mEffClonesPt.get()); @@ -1079,54 +918,40 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) setEfficiencyGraph(mEffFakeZLam, "Fake_ZLam", ";z of sv [cm];efficiency secondary particle", kMagenta - 9); fout.WriteTObject(mEffFakeZLam.get()); - setEfficiencyGraph(mEff0Pt, "Good_pt0", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kAzure + 4); - fout.WriteTObject(mEff0Pt.get()); - - setEfficiencyGraph(mEff0FakePt, "Fake_pt0", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kAzure + 4); - fout.WriteTObject(mEff0FakePt.get()); - - setEfficiencyGraph(mEff0Eta, "Good_eta0", ";#eta;efficiency secondary particle ", kAzure + 4); - fout.WriteTObject(mEff0Eta.get()); - - setEfficiencyGraph(mEff0FakeEta, "Fake_eta0", ";#eta;efficiency secondary particle ", kAzure + 4); - fout.WriteTObject(mEff0FakeEta.get()); - - setEfficiencyGraph(mEff1Pt, "Good_pt1", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kRed); - fout.WriteTObject(mEff1Pt.get()); - - setEfficiencyGraph(mEff1FakePt, "Fake_pt1", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kRed); - fout.WriteTObject(mEff1FakePt.get()); - - setEfficiencyGraph(mEff1Eta, "Good_eta1", ";#eta;efficiency secondary particle ", kRed); - fout.WriteTObject(mEff1Eta.get()); - - setEfficiencyGraph(mEff1FakeEta, "Fake_eta1", ";#eta;efficiency secondary particle ", kRed); - fout.WriteTObject(mEff1FakeEta.get()); - - setEfficiencyGraph(mEff2Pt, "Good_pt2", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kGreen + 1); - fout.WriteTObject(mEff2Pt.get()); - - setEfficiencyGraph(mEff2FakePt, "Fake_pt2", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kGreen + 1); - fout.WriteTObject(mEff2FakePt.get()); - - setEfficiencyGraph(mEff2Eta, "Good_eta2", ";#eta;efficiency secondary particle ", kGreen + 1); - fout.WriteTObject(mEff2Eta.get()); - - setEfficiencyGraph(mEff2FakeEta, "Fake_eta2", ";#eta;efficiency secondary particle ", kGreen + 1); - fout.WriteTObject(mEff2FakeEta.get()); - - setEfficiencyGraph(mEff3Pt, "Good_pt3", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kOrange - 3); - fout.WriteTObject(mEff3Pt.get()); - - setEfficiencyGraph(mEff3FakePt, "Fake_pt3", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", kOrange - 3); - fout.WriteTObject(mEff3FakePt.get()); - - setEfficiencyGraph(mEff3Eta, "Good_eta3", ";#eta;efficiency secondary particle", kOrange - 3); - fout.WriteTObject(mEff3Eta.get()); - - setEfficiencyGraph(mEff3FakeEta, "Fake_eta3", ";#eta;efficiency secondary particle", kOrange - 3); - fout.WriteTObject(mEff3FakeEta.get()); - + for (int aa = 0; aa < 4; aa++) { + setEfficiencyGraph(mEffGoodPts[aa], Form("EffPtGoodl%d", aa), Form("Tot Sec G Tracks, L%d" + ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", + aa), + kGray); + setEfficiencyGraph(mEffFakePts[aa], Form("EffPtFakel%d", aa), Form("Tot Sec F Tracks, L%d" + ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", + aa), + kGray); + setEfficiencyGraph(mEffGoodEtas[aa], Form("EffEtaGoodl%d", aa), Form("Tot Sec G Tracks, L%d" + ";eta ;efficiency secondary particle ", + aa), + kAzure + 4); + setEfficiencyGraph(mEffFakeEtas[aa], Form("EffEtaFakel%d", aa), Form("Tot Sec F Tracks, L%d" + ";eta ;efficiency secondary particle ", + aa), + kAzure + 4); + setEfficiencyGraph(mEffGoodPtsK[aa], Form("EffPtGoodKl%d", aa), Form("k^{0}_{s} Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kBlue); + setEfficiencyGraph(mEffFakePtsK[aa], Form("EffPtFakeKl%d", aa), Form("k^{0}_{s} Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kBlue); + setEfficiencyGraph(mEffGoodPtsLam[aa], Form("EffPtGoodLaml%d", aa), Form("#Lambda Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kRed); + setEfficiencyGraph(mEffFakePtsLam[aa], Form("EffPtFakeLaml%d", aa), Form("#Lambda Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kRed); + setEfficiencyGraph(mEffGoodPtsIperT[aa], Form("EffPtGoodIperTl%d", aa), Form("_{#Lambda}^{3}H Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kGreen + 1); + setEfficiencyGraph(mEffFakePtsIperT[aa], Form("EffPtFakeIperTl%d", aa), Form("_{#Lambda}^{3}H Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kGreen + 1); + fout.WriteTObject(mEffGoodPts[aa].get()); + fout.WriteTObject(mEffFakePts[aa].get()); + fout.WriteTObject(mEffGoodEtas[aa].get()); + fout.WriteTObject(mEffFakeEtas[aa].get()); + fout.WriteTObject(mEffGoodPtsK[aa].get()); + fout.WriteTObject(mEffGoodPtsLam[aa].get()); + fout.WriteTObject(mEffGoodPtsIperT[aa].get()); + fout.WriteTObject(mEffFakePtsK[aa].get()); + fout.WriteTObject(mEffFakePtsLam[aa].get()); + fout.WriteTObject(mEffFakePtsIperT[aa].get()); + } setHistoMCGraph(HistoMC[0], mDenominatorSecRad, "Decay_Radius_MC", ";Decay Radius ;Entries", kGray, 0.4); fout.WriteTObject(mDenominatorSecRad.get()); @@ -1242,7 +1067,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mLegendRadD->Draw(); mCanvasRadD->SaveAs("eff_RadD_sec_MC.png"); - mCanvasZD = std::make_unique("cZ", "cZ", 1600, 1200); + mCanvasZD = std::make_unique("cZd", "cZd", 1600, 1200); mCanvasZD->cd(); mCanvasZD->SetGrid(); mEffZk->Draw("pz"); @@ -1263,82 +1088,6 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mLegendZD->Draw(); mCanvasZD->SaveAs("eff_ZD_sec_MC.png"); - mCanvasPt2 = std::make_unique("cPt2", "cPt2", 1600, 1200); - mCanvasPt2->cd(); - mCanvasPt2->SetLogx(); - mCanvasPt2->SetGrid(); - mEff0Pt->Draw("pz"); - mEff1Pt->Draw("pz same"); - mEff2Pt->Draw("pz same"); - mEff3Pt->Draw("pz same"); - - mLegendPt2 = std::make_unique(0.19, 0.8, 0.40, 0.96); - mLegendPt2->SetHeader(Form("%zu events PP, good tracks", mKineReader->getNEvents(0)), "C"); - mLegendPt2->AddEntry("Good_pt0", "Layer 0", "lep"); - mLegendPt2->AddEntry("Good_pt1", "Layer 1", "lep"); - mLegendPt2->AddEntry("Good_pt2", "Layer 2", "lep"); - mLegendPt2->AddEntry("Good_pt3", "Layer 3", "lep"); - - mLegendPt2->Draw(); - mCanvasPt2->SaveAs("eff_sec_pt.png"); - - mCanvasEta2 = std::make_unique("cEta2", "cEta2", 1600, 1200); - mCanvasEta2->cd(); - - mCanvasEta2->SetGrid(); - mEff0Eta->Draw("pz"); - mEff1Eta->Draw("pz same"); - mEff2Eta->Draw("pz same"); - mEff3Eta->Draw("pz same"); - - mLegendEta2 = std::make_unique(0.19, 0.8, 0.40, 0.96); - mLegendEta2->SetHeader(Form("%zu events PP, good tracks", mKineReader->getNEvents(0)), "C"); - mLegendEta2->AddEntry("Good_eta0", "Layer 0", "lep"); - mLegendEta2->AddEntry("Good_eta1", "Layer 1", "lep"); - mLegendEta2->AddEntry("Good_eta2", "Layer 2", "lep"); - mLegendEta2->AddEntry("Good_eta3", "Layer 3", "lep"); - - mLegendEta2->Draw(); - mCanvasEta2->SaveAs("eff_sec_eta.png"); - - mCanvasPt2fake = std::make_unique("cPt2fake", "cPt2fake", 1600, 1200); - mCanvasPt2fake->cd(); - mCanvasPt2fake->SetLogx(); - mCanvasPt2fake->SetGrid(); - mEff0FakePt->Draw("pz"); - mEff1FakePt->Draw("pz same"); - mEff2FakePt->Draw("pz same"); - mEff3FakePt->Draw("pz same"); - - mLegendPt2Fake = std::make_unique(0.19, 0.8, 0.40, 0.96); - mLegendPt2Fake->SetHeader(Form("%zu events PP, fake tracks ", mKineReader->getNEvents(0)), "C"); - mLegendPt2Fake->AddEntry("Fake_pt0", "Layer 0", "lep"); - mLegendPt2Fake->AddEntry("Fake_pt1", "Layer 1", "lep"); - mLegendPt2Fake->AddEntry("Fake_pt2", "Layer 2", "lep"); - mLegendPt2Fake->AddEntry("Fake_pt3", "Layer 3", "lep"); - - mLegendPt2Fake->Draw(); - mCanvasPt2fake->SaveAs("eff_sec_pt_fake.png"); - - mCanvasEta2fake = std::make_unique("cEta2fake", "cEta2fake", 1600, 1200); - mCanvasEta2fake->cd(); - - mCanvasEta2fake->SetGrid(); - mEff0FakeEta->Draw("pz"); - mEff1FakeEta->Draw("pz same"); - mEff2FakeEta->Draw("pz same"); - mEff3FakeEta->Draw("pz same"); - - mLegendEta2Fake = std::make_unique(0.19, 0.8, 0.40, 0.96); - mLegendEta2Fake->SetHeader(Form("%zu events PP, fake tracks ", mKineReader->getNEvents(0)), "C"); - mLegendEta2Fake->AddEntry("Fake_eta0", "Layer 0", "lep"); - mLegendEta2Fake->AddEntry("Fake_eta1", "Layer 1", "lep"); - mLegendEta2Fake->AddEntry("Fake_eta2", "Layer 2", "lep"); - mLegendEta2Fake->AddEntry("Fake_eta3", "Layer 3", "lep"); - - mLegendEta2Fake->Draw(); - mCanvasEta2fake->SaveAs("eff_sec_Eta_fake.png"); - mPtResolution->SetName("#it{p}_{T} resolution"); mPtResolution->SetTitle(";#Delta p_{T}/p_{T_{MC}} ;Entries"); mPtResolution->SetFillColor(kAzure + 4); @@ -1419,19 +1168,33 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) stackLength2Fake[iH]->Draw(); gPad->BuildLegend(); } - for (int iH{0}; iH < 2; ++iH) { + for (int iH{0}; iH < 4; ++iH) { canvas2->cd(iH + 5); stackLength3Fake[iH]->Draw(); gPad->BuildLegend(); } canvas2->SaveAs("fakeClusters3.png", "recreate"); + + auto canvasPtfake = new TCanvas("canvasPtfake", "Fake clusters", 1600, 1000); + canvasPtfake->Divide(2, 2); + + for (int iH{0}; iH < 4; ++iH) { + canvasPtfake->cd(iH + 1); + mEffFakePtsK[iH]->Draw(); + mEffFakePtsLam[iH]->Draw("same"); + mEffFakePtsIperT[iH]->Draw("same"); + mEffFakePt->Draw("same"); + mEffFakePts[iH]->Draw("same"); + gPad->BuildLegend(); + gPad->SetGrid(); + gPad->SetTitle(Form("#it{p}_{T}, Fake Tracks, layer %d", iH)); + gPad->SetName(Form("#it{p}_{T}, Fake Tracks, layer %d", iH)); + } + canvasPtfake->SaveAs("PtforPart1.png", "recreate"); + fout.cd(); mCanvasPt->Write(); mCanvasEta->Write(); - mCanvasPt2->Write(); - mCanvasPt2fake->Write(); - mCanvasEta2->Write(); - mCanvasEta2fake->Write(); mCanvasPtRes->Write(); mCanvasPtRes2->Write(); mCanvasPtRes3->Write(); @@ -1442,7 +1205,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasZD->Write(); canvas->Write(); canvas2->Write(); - + canvasPtfake->Write(); fout.Close(); } From 3cbf85aa766fc6e8fdaf4081f7e07bc86364c00b Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Tue, 29 Aug 2023 11:21:45 +0200 Subject: [PATCH 09/19] ITS-Study:add fake clusters identification --- .../postprocessing/studies/src/TrackCheck.cxx | 265 +++++++++++++----- 1 file changed, 198 insertions(+), 67 deletions(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 39b2eb2ad675d..e8a702e1c1657 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -24,6 +24,8 @@ #include "DetectorsBase/GRPGeomHelper.h" #include +#include +#include #include #include #include @@ -63,6 +65,8 @@ class TrackCheckStudy : public Task unsigned char isFake = 0u; bool isPrimary = 0u; unsigned char storedStatus = 2; /// not stored = 2, fake = 1, good = 0 + const char* prodProcessName; + int prodProcess; o2::its::TrackITS track; }; @@ -87,7 +91,8 @@ class TrackCheckStudy : public Task void process(); void setEfficiencyGraph(std::unique_ptr&, const char*, const int, const double, const double, const int, const double); void setEfficiencyGraph(std::unique_ptr&, const char*, const char*, const int, const double, const double, const int, const double); - void setHistoMCGraph(TH1D&, std::unique_ptr&, const char*, const char*, const int, const double); + void setHistoGraph(TH1D&, std::unique_ptr&, const char*, const char*, const int, const double); + // void setHistoGraph(TH1D&, const char*, const char*, const int, const double); void NormalizeHistos(std::vector&); private: @@ -101,6 +106,7 @@ class TrackCheckStudy : public Task gsl::span mTracks; gsl::span mTracksMCLabels; gsl::span mClusters; + gsl::span mInputITSidxs; const o2::dataformats::MCLabelContainer* mClustersMCLCont; // Data @@ -173,6 +179,15 @@ class TrackCheckStudy : public Task std::unique_ptr mPtResolutionPrim; std::unique_ptr g1; + std::unique_ptr mIperTClusterfake; + std::unique_ptr mKClusterfake; + std::unique_ptr mLamClusterfake; + std::unique_ptr mIperTClusterfake1D; + std::unique_ptr mKClusterfake1D; + std::unique_ptr mLamClusterfake1D; + const char* ParticleName[10] = {"e^{+}", "e^{-}", "#pi^{-}", "#pi^{+}", "p", "^{2}H","^{2}H^{-}", "^{3}He","^{3}He^{-}","_{#Lambda}^{3}H"}; + const char* ProcessName[50]; + std::vector histLength, histLength1Fake, histLength2Fake, histLength3Fake, histLengthNoCl, histLength1FakeNoCl, histLength2FakeNoCl, histLength3FakeNoCl; // FakeCluster Study std::vector stackLength, stackLength1Fake, stackLength2Fake, stackLength3Fake; std::vector legends, legends1Fake, legends2Fake, legends3Fake; @@ -205,7 +220,7 @@ class TrackCheckStudy : public Task std::unique_ptr mLegendRad; std::unique_ptr mLegendZD; std::unique_ptr mLegendRadD; - std::vector HistoMC; + std::vector Histo; float rLayer0 = 2.34; float rLayer1 = 3.15; @@ -221,13 +236,13 @@ class TrackCheckStudy : public Task std::unique_ptr mDBGOut; }; -void TrackCheckStudy::NormalizeHistos(std::vector& HistoMC) +void TrackCheckStudy::NormalizeHistos(std::vector& Histo) { - int nHist = HistoMC.size(); + int nHist = Histo.size(); for (int jh = 0; jh < nHist; jh++) { - double tot = HistoMC[jh].Integral(); + double tot = Histo[jh].Integral(); if (tot > 0) - HistoMC[jh].Scale(1. / tot); + Histo[jh].Scale(1. / tot); } } @@ -277,6 +292,13 @@ void TrackCheckStudy::init(InitContext& ic) mDenominatorSecRad = std::make_unique("denominatorSecRad", ";Radius [cm];Number of tracks", 100, 0, 25); mDenominatorSecZ = std::make_unique("denominatorSecZ", ";z of secondary vertex [cm];Number of tracks", 100, -50, 50); + mIperTClusterfake1D = std::make_unique("IperTClusterfake1D", ";pdg code of fake cluster;Entries", 10, 0., 10.); + mKClusterfake1D = std::make_unique("KClusterfake1D", ";pdg code of fake cluster;Entries", 10, 0., 10.); + mLamClusterfake1D = std::make_unique("LamClusterfake1D", ";pdg code of fake cluster;Entries", 10, 0., 10.); + mIperTClusterfake = std::make_unique("IperT_Clusters_fake", ";particle generating fake cluster; production process", 10, 0., 10., 50, 0, 50); + mKClusterfake = std::make_unique("K0s_Clusters_fake", ";particle generating fake cluster; production process", 10, 0., 10., 50, 0, 50); + mLamClusterfake = std::make_unique("#Lambda_Clusters_fake", ";particle generating fake cluster; production process", 10, 0., 10., 50, 0, 50); + mRadk = std::make_unique("mRadk", ";Radius [cm];Number of tracks", 100, 0, 25); mRadLam = std::make_unique("mRadLam", ";Radius [cm];Number of tracks", 100, 0, 25); mZk = std::make_unique("mZk", ";z of secondary vertex [cm]", 100, -50, 50); @@ -463,6 +485,7 @@ void TrackCheckStudy::initialiseRun(o2::globaltracking::RecoContainer& recoData) mTracksMCLabels = recoData.getITSTracksMCLabels(); mClusters = recoData.getITSClusters(); mClustersMCLCont = recoData.getITSClustersMCLabels(); + mInputITSidxs = recoData.getITSTracksClusterRefs(); LOGP(info, "** Found in {} rofs:\n\t- {} clusters with {} labels\n\t- {} tracks with {} labels", mTracksROFRecords.size(), mClusters.size(), mClustersMCLCont->getIndexedSize(), mTracks.size(), mTracksMCLabels.size()); @@ -489,7 +512,8 @@ void TrackCheckStudy::process() mParticleInfo[iSource][iEvent][iPart].vz = part.Vz(); mParticleInfo[iSource][iEvent][iPart].isPrimary = part.isPrimary(); mParticleInfo[iSource][iEvent][iPart].mother = part.getMotherTrackId(); - // mParticleInfo[iSource][iEvent][iPart].first = part.getFirstDaughterTrackId(); + mParticleInfo[iSource][iEvent][iPart].prodProcessName = part.getProdProcessAsString(); + mParticleInfo[iSource][iEvent][iPart].prodProcess = part.getProcess(); } } } @@ -553,10 +577,15 @@ void TrackCheckStudy::process() int Ltot, Ktot, Itot; int LtotG, KtotG, ItotG; int LtotF, KtotF, ItotF; + + for (int yy = 0; yy < 50; yy++) { + ProcessName[yy]= " "; + } // Currently process only sourceID = 0, to be extended later if needed for (auto& evInfo : mParticleInfo[0]) { trackID = 0; for (auto& part : evInfo) { + if ((part.clusters & 0x7f) == mMask) { // part.clusters != 0x3f && part.clusters != 0x3f << 1 && // part.clusters != 0x1f && part.clusters != 0x1f << 1 && part.clusters != 0x1f << 2 && @@ -589,8 +618,10 @@ void TrackCheckStudy::process() } if (!part.isPrimary) { // **Secondary particle** + int TrackID, EvID, SrcID; totalsec++; int pdgcode = mParticleInfo[0][evID][part.mother].pdg; + float rad = sqrt(pow(part.vx, 2) + pow(part.vy, 2)); if ((rad < rLayer0) && (part.clusters == 0x7f || part.clusters == 0x3f || part.clusters == 0x1f || part.clusters == 0x0f)) // layer 0 @@ -616,7 +647,7 @@ void TrackCheckStudy::process() mFakePts[nlayer]->Fill(part.pt); mFakeEtas[nlayer]->Fill(part.eta); } - if (pdgcode == 310) // k0s + if (pdgcode == 310) // mother particle = k0s { mRadk->Fill(rad); mZk->Fill(part.vz); @@ -632,11 +663,12 @@ void TrackCheckStudy::process() mFakePtsK[nlayer]->Fill(part.pt); } } - if (pdgcode == 3122) // Lambda + if (pdgcode == 3122) // mother particle = Lambda { mRadLam->Fill(rad); mZLam->Fill(part.vz); mTotPtsLam[nlayer]->Fill(part.pt); + if (part.isReco) { mGoodRadLam->Fill(rad); mGoodZLam->Fill(part.vz); @@ -648,8 +680,9 @@ void TrackCheckStudy::process() mFakePtsLam[nlayer]->Fill(part.pt); } } - if (pdgcode == 1010010030) // IperT + if (pdgcode == 1010010030 ) // mother particle = IperT { + mTotPtsIperT[nlayer]->Fill(part.pt); if (part.isReco) { mGoodPtsIperT[nlayer]->Fill(part.pt); @@ -668,11 +701,15 @@ void TrackCheckStudy::process() if (nCl < 3) { continue; } + auto& track = part.track; auto len = track.getNClusters(); + int nclu = track.getNumberOfClusters(); + int firstclu = track.getFirstClusterEntry(); for (int iLayer{0}; iLayer < 7; ++iLayer) { if (track.hasHitOnLayer(iLayer)) { - if (track.isFakeOnLayer(iLayer)) { // Reco track has fake cluster + if (track.isFakeOnLayer(iLayer)) { + // Reco track has fake cluster if (part.clusters & (0x1 << iLayer)) { // Correct cluster exists histLength[len - 4]->Fill(iLayer); if (track.getNFakeClusters() == 1) { @@ -685,6 +722,7 @@ void TrackCheckStudy::process() histLength3Fake[len - 4]->Fill(iLayer); } } else { + histLengthNoCl[len - 4]->Fill(iLayer); if (track.getNFakeClusters() == 1) { histLength1FakeNoCl[len - 4]->Fill(iLayer); @@ -695,25 +733,81 @@ void TrackCheckStudy::process() if (track.getNFakeClusters() == 3) { histLength3FakeNoCl[len - 4]->Fill(iLayer); } + //LOGP(info,"aaaaa"); + } + LOGP(info,"first clu index: {}, first cluster layer={}, ilayer={}",firstclu,track.getFirstClusterLayer(),iLayer); + auto labs = mClustersMCLCont->getLabels(mInputITSidxs[firstclu + (iLayer - track.getFirstClusterLayer())]); + + for (auto& lab : labs) { + if (!lab.isValid()) { + continue; // We want to skip channels related to noise, e.g. sID = 99: QED + } + + + bool fakec; + const_cast(lab).get(TrackID, EvID, SrcID, fakec); + double intHisto = 0; + LOGP(info,"Ev ID, track ID part ={}-{}, evID trackID cluster= {}-{}",evID,trackID,EvID,TrackID); + //if(nlayer==1) LOGP(info,"pdg code cluster fake= {}",mParticleInfo[SrcID][EvID][TrackID].pdg); + if (mParticleInfo[SrcID][EvID][TrackID].pdg == -11) + intHisto = 0.5; // "e^{+}" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 11) + intHisto = 1.5; // "e^{-}" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == -211) + intHisto = 2.5; // "#pi^{-}" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 211) + intHisto = 3.5; // "#pi^{+}" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 2212) + intHisto = 4.5; // "p" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1000010020) + intHisto = 5.5; // "^{2}H" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == -1000010020) + intHisto = 6.5; // "^{2}H-" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1000020030) + intHisto = 7.5; // "^{3}He" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == -1000020030) + intHisto = 8.5; // "^{3}He-" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1010010030) + intHisto = 9.5; // "IperT" + ProcessName[mParticleInfo[SrcID][EvID][TrackID].prodProcess]=mParticleInfo[SrcID][EvID][TrackID].prodProcessName; + //if(nlayer==1) LOGP(info,"pdg code cluster fake = {}",mParticleInfo[SrcID][EvID][TrackID].pdg); + if (pdgcode == 1010010030){ + //if(nlayer==1) LOGP(info,"pdg code cluster fake m=iperT= {}",mParticleInfo[SrcID][EvID][TrackID].pdg); + mIperTClusterfake->Fill(intHisto,mParticleInfo[SrcID][EvID][TrackID].prodProcess); + mIperTClusterfake1D->Fill(intHisto); + } + if (pdgcode == 3122){ + //if(nlayer==1) LOGP(info,"pdg code cluster fake m=lam= {}",mParticleInfo[SrcID][EvID][TrackID].pdg); + mLamClusterfake->Fill(intHisto,mParticleInfo[SrcID][EvID][TrackID].prodProcess); + mLamClusterfake1D->Fill(intHisto); + } + if (pdgcode == 310) + { + //if(nlayer==1) LOGP(info,"pdg code cluster fake m=k= {}",mParticleInfo[SrcID][EvID][TrackID].pdg); + mKClusterfake->Fill(intHisto,mParticleInfo[SrcID][EvID][TrackID].prodProcess); + mKClusterfake1D->Fill(intHisto); + } } } } } } + nlayer = 999; } - nlayer = 999; trackID++; } - evID++; } - HistoMC.push_back(*mDenominatorSecRad); - HistoMC.push_back(*mRadk); - HistoMC.push_back(*mRadLam); - HistoMC.push_back(*mDenominatorSecZ); - HistoMC.push_back(*mZk); - HistoMC.push_back(*mZLam); + Histo.push_back(*mDenominatorSecRad); + Histo.push_back(*mRadk); + Histo.push_back(*mRadLam); + Histo.push_back(*mDenominatorSecZ); + Histo.push_back(*mZk); + Histo.push_back(*mZLam); + Histo.push_back(*mIperTClusterfake1D); + Histo.push_back(*mLamClusterfake1D); + Histo.push_back(*mKClusterfake1D); LOGP(info, "** Some statistics on secondary tracks:"); @@ -801,22 +895,6 @@ void TrackCheckStudy::process() aa[yy] = 0.0125; } } - - LOGP(info, "** Analysing fake clusters ** ... "); - for (auto iSource{0}; iSource < mParticleInfo.size(); ++iSource) { - for (auto iCluster{0}; iCluster < mClusters.size(); ++iCluster) { - auto labs = mClustersMCLCont->getLabels(iCluster); // ideally I can have more than one label per cluster - for (auto& lab : labs) { - if (!lab.isValid()) { - continue; // We want to skip channels related to noise, e.g. sID = 99: QED - } - int trackID, evID, srcID; - bool fake; - const_cast(lab).get(trackID, evID, srcID, fake); - - } - } - } } void TrackCheckStudy::setEfficiencyGraph(std::unique_ptr& eff, const char* name, const char* title, const int color, const double alpha = 1, const double linew = 2, const int markerStyle = kFullCircle, const double markersize = 1.7) @@ -833,7 +911,7 @@ void TrackCheckStudy::setEfficiencyGraph(std::unique_ptr& eff, cons eff->SetDirectory(gDirectory); } -void TrackCheckStudy::setHistoMCGraph(TH1D& histo, std::unique_ptr& histo2, const char* name, const char* title, const int color, const double alpha = 0.5) +void TrackCheckStudy::setHistoGraph(TH1D& histo, std::unique_ptr& histo2, const char* name, const char* title, const int color, const double alpha = 0.5) { histo.SetName(name); histo2->SetName(name); @@ -843,6 +921,15 @@ void TrackCheckStudy::setHistoMCGraph(TH1D& histo, std::unique_ptr& histo2 histo.SetDirectory(gDirectory); } +/*void TrackCheckStudy::setHistoGraph(TH1& histo, const char* name, const char* title, const int color, const double alpha = 0.5) +{ + histo.SetName(name); + histo.SetTitle(title); + histo.SetFillColor(color); + histo.SetFillColorAlpha(color, alpha); + histo.SetDirectory(gDirectory); +}*/ + void TrackCheckStudy::updateTimeDependentParams(ProcessingContext& pc) { static bool initOnceDone = false; @@ -857,7 +944,7 @@ void TrackCheckStudy::updateTimeDependentParams(ProcessingContext& pc) void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) { TFile fout(mOutFileName.c_str(), "recreate"); - NormalizeHistos(HistoMC); + NormalizeHistos(Histo); // std::unique_ptr mEffPt1; // mEffPt1=mEffPt->Clone(); @@ -919,28 +1006,16 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) fout.WriteTObject(mEffFakeZLam.get()); for (int aa = 0; aa < 4; aa++) { - setEfficiencyGraph(mEffGoodPts[aa], Form("EffPtGoodl%d", aa), Form("Tot Sec G Tracks, L%d" - ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", - aa), - kGray); - setEfficiencyGraph(mEffFakePts[aa], Form("EffPtFakel%d", aa), Form("Tot Sec F Tracks, L%d" - ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", - aa), - kGray); - setEfficiencyGraph(mEffGoodEtas[aa], Form("EffEtaGoodl%d", aa), Form("Tot Sec G Tracks, L%d" - ";eta ;efficiency secondary particle ", - aa), - kAzure + 4); - setEfficiencyGraph(mEffFakeEtas[aa], Form("EffEtaFakel%d", aa), Form("Tot Sec F Tracks, L%d" - ";eta ;efficiency secondary particle ", - aa), - kAzure + 4); + setEfficiencyGraph(mEffGoodPts[aa], Form("EffPtGoodl%d", aa), Form("Tot Sec G Tracks, L%d"";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ",aa),kGray); + setEfficiencyGraph(mEffFakePts[aa], Form("EffPtFakel%d", aa), Form("Tot Sec F Tracks, L%d"";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ",aa), kGray); + setEfficiencyGraph(mEffGoodEtas[aa], Form("EffEtaGoodl%d", aa), Form("Tot Sec G Tracks, L%d"";eta ;efficiency secondary particle ", aa),kAzure + 4); + setEfficiencyGraph(mEffFakeEtas[aa], Form("EffEtaFakel%d", aa), Form("Tot Sec F Tracks, L%d"";eta ;efficiency secondary particle ",aa),kAzure + 4); setEfficiencyGraph(mEffGoodPtsK[aa], Form("EffPtGoodKl%d", aa), Form("k^{0}_{s} Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kBlue); setEfficiencyGraph(mEffFakePtsK[aa], Form("EffPtFakeKl%d", aa), Form("k^{0}_{s} Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kBlue); setEfficiencyGraph(mEffGoodPtsLam[aa], Form("EffPtGoodLaml%d", aa), Form("#Lambda Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kRed); setEfficiencyGraph(mEffFakePtsLam[aa], Form("EffPtFakeLaml%d", aa), Form("#Lambda Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kRed); - setEfficiencyGraph(mEffGoodPtsIperT[aa], Form("EffPtGoodIperTl%d", aa), Form("_{#Lambda}^{3}H Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kGreen + 1); - setEfficiencyGraph(mEffFakePtsIperT[aa], Form("EffPtFakeIperTl%d", aa), Form("_{#Lambda}^{3}H Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kGreen + 1); + setEfficiencyGraph(mEffGoodPtsIperT[aa], Form("EffPtGoodIperTl%d", aa), Form("_{#Lambda}^{3}H Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kGreen + 2); + setEfficiencyGraph(mEffFakePtsIperT[aa], Form("EffPtFakeIperTl%d", aa), Form("_{#Lambda}^{3}H Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kGreen + 2); fout.WriteTObject(mEffGoodPts[aa].get()); fout.WriteTObject(mEffFakePts[aa].get()); fout.WriteTObject(mEffGoodEtas[aa].get()); @@ -952,24 +1027,49 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) fout.WriteTObject(mEffFakePtsLam[aa].get()); fout.WriteTObject(mEffFakePtsIperT[aa].get()); } - setHistoMCGraph(HistoMC[0], mDenominatorSecRad, "Decay_Radius_MC", ";Decay Radius ;Entries", kGray, 0.4); + setHistoGraph(Histo[0], mDenominatorSecRad, "Decay_Radius_MC", ";Decay Radius ;Entries", kGray, 0.4); fout.WriteTObject(mDenominatorSecRad.get()); - setHistoMCGraph(HistoMC[3], mDenominatorSecZ, "Zsv_MC", ";z of secondary vertex ;Entries", kGray, 0.4); + setHistoGraph(Histo[3], mDenominatorSecZ, "Zsv_MC", ";z of secondary vertex ;Entries", kGray, 0.4); fout.WriteTObject(mDenominatorSecZ.get()); - setHistoMCGraph(HistoMC[1], mRadk, "Decay_Radius_MC_k", ";Decay Radius ;Entries", kBlue, 0.2); + setHistoGraph(Histo[1], mRadk, "Decay_Radius_MC_k", ";Decay Radius ;Entries", kBlue, 0.2); fout.WriteTObject(mRadk.get()); - setHistoMCGraph(HistoMC[4], mZk, "Zsv_MC_k", ";Zsv ;Entries", kBlue, 0.2); + setHistoGraph(Histo[4], mZk, "Zsv_MC_k", ";Zsv ;Entries", kBlue, 0.2); fout.WriteTObject(mZk.get()); - setHistoMCGraph(HistoMC[2], mRadLam, "Decay_Radius_MC_Lam", ";Decay Radius ;Entries", kRed, 0.2); + setHistoGraph(Histo[2], mRadLam, "Decay_Radius_MC_Lam", ";Decay Radius ;Entries", kRed, 0.2); fout.WriteTObject(mRadLam.get()); - setHistoMCGraph(HistoMC[5], mZLam, "Zsv_MC_Lam", ";Zsv ;Entries", kRed, 0.2); + setHistoGraph(Histo[5], mZLam, "Zsv_MC_Lam", ";Zsv ;Entries", kRed, 0.2); fout.WriteTObject(mZLam.get()); + setHistoGraph(Histo[6], mIperTClusterfake1D, "IperTClusterfake1D", "; of fake cluster ;Entries", kGreen + 2, 1); + fout.WriteTObject(mIperTClusterfake1D.get()); + + setHistoGraph(Histo[7], mLamClusterfake1D, "LamClusterfake1D", "; of fake cluster ;Entries", kRed, 1); + fout.WriteTObject(mLamClusterfake1D.get()); + + setHistoGraph(Histo[8], mKClusterfake1D, "KClusterfake1D", "; of fake cluster ;Entries", kBlue, 1); + fout.WriteTObject(mKClusterfake1D.get()); + for (int y = 6; y < 9; y++) { + for (int i = 1; i <= 10; i++) { + Histo[y].GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); + } + } + for (int i = 1; i <= 10; i++) { + mIperTClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); + mLamClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); + mKClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); + } + for(int i=1;i<=50;i++) + { + mIperTClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + mLamClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + mKClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + } + // Paint the histograms // todo: delegate to a dedicated helper gStyle->SetTitleSize(0.035, "xy"); @@ -1019,7 +1119,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasRad->SetGrid(); mEffRad->Draw("pz"); mEffFakeRad->Draw("pz same"); - HistoMC[0].Draw("hist same"); + Histo[0].Draw("hist same"); mCanvasRad->SetLogy(); mLegendRad = std::make_unique(0.8, 0.4, 0.95, 0.6); mLegendRad->SetHeader(Form("%zu events PP ", mKineReader->getNEvents(0)), "C"); @@ -1035,7 +1135,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasZ->SetLogy(); mEffZ->Draw("pz"); mEffFakeZ->Draw("pz same"); - HistoMC[3].Draw(" histsame"); + Histo[3].Draw(" hist same"); mLegendZ = std::make_unique(0.19, 0.8, 0.40, 0.96); mLegendZ->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); mLegendZ->AddEntry("Good_Z", "good", "lep"); @@ -1050,10 +1150,10 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasRadD->SetGrid(); mEffRadk->Draw("pz"); mEffFakeRadk->Draw("pz same"); - HistoMC[1].Draw(" hist same"); + Histo[1].Draw(" hist same"); mEffRadLam->Draw("pz same"); mEffFakeRadLam->Draw("pz same"); - HistoMC[2].Draw(" hist same"); + Histo[2].Draw(" hist same"); mCanvasRadD->SetLogy(); mLegendRadD = std::make_unique(0.8, 0.64, 0.95, 0.8); mLegendRadD->SetHeader(Form("%zu events PP ", mKineReader->getNEvents(0)), "C"); @@ -1072,10 +1172,10 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mCanvasZD->SetGrid(); mEffZk->Draw("pz"); mEffFakeZk->Draw("pz same"); - HistoMC[4].Draw("same hist"); + Histo[4].Draw("same hist"); mEffZLam->Draw("pz same"); mEffFakeZLam->Draw("pz same"); - HistoMC[5].Draw("same hist"); + Histo[5].Draw("same hist"); mLegendZD = std::make_unique(0.19, 0.5, 0.30, 0.7); mLegendZD->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); mLegendZD->AddEntry("Good_Zk", " k^{0}_{s} good", "lep"); @@ -1192,6 +1292,34 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) } canvasPtfake->SaveAs("PtforPart1.png", "recreate"); + auto canvasClusterFake = new TCanvas("canvasClusterFake", "canvasClusterFake", 1600, 1000); + canvasClusterFake->Divide(3, 1); + canvasClusterFake->cd(1); + Histo[6].SetTitle("Secondary tracks, mother particle:_{#Lambda}^{3}H"); + Histo[6].Draw("hist"); + canvasClusterFake->cd(2); + Histo[7].SetTitle("Secondary tracks, mother particle: #Lambda"); + Histo[7].Draw("hist"); + canvasClusterFake->cd(3); + Histo[8].SetTitle("Secondary tracks, mother particle: k^{0}_{s} "); + Histo[8].Draw("hist"); + canvasClusterFake->SaveAs("CluFake.png", "recreate"); + + auto canvasI = new TCanvas("canvasI", "canvasI", 1600, 1000); + canvasI->cd(); + mIperTClusterfake->Draw("COLZ"); + canvasI->SaveAs("Iper2D.png", "recreate"); + + auto canvasL = new TCanvas("canvasL", "canvasL", 1600, 1000); + canvasL->cd(); + mLamClusterfake->Draw("COLZ"); + canvasL->SaveAs("Lam2D.png", "recreate"); + + auto canvasK = new TCanvas("canvasK", "canvasK", 1600, 1000); + canvasK->cd(); + mKClusterfake->Draw("COLZ"); + canvasK->SaveAs("K2D.png", "recreate"); + fout.cd(); mCanvasPt->Write(); mCanvasEta->Write(); @@ -1206,6 +1334,9 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) canvas->Write(); canvas2->Write(); canvasPtfake->Write(); + canvasI->Write(); + canvasL->Write(); + canvasK->Write(); fout.Close(); } From e434e87afa3a512543125ffccc815a4679125bce Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Thu, 31 Aug 2023 17:44:55 +0200 Subject: [PATCH 10/19] [WIP] ITS-Study: completed study on fake clusters --- .../postprocessing/studies/src/TrackCheck.cxx | 663 ++++++++++++------ 1 file changed, 443 insertions(+), 220 deletions(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index e8a702e1c1657..6a7339b546bda 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -35,6 +35,7 @@ #include #include #include +#include namespace o2 { @@ -92,7 +93,6 @@ class TrackCheckStudy : public Task void setEfficiencyGraph(std::unique_ptr&, const char*, const int, const double, const double, const int, const double); void setEfficiencyGraph(std::unique_ptr&, const char*, const char*, const int, const double, const double, const int, const double); void setHistoGraph(TH1D&, std::unique_ptr&, const char*, const char*, const int, const double); - // void setHistoGraph(TH1D&, const char*, const char*, const int, const double); void NormalizeHistos(std::vector&); private: @@ -113,8 +113,6 @@ class TrackCheckStudy : public Task GTrackID::mask_t mTracksSrc{}; std::shared_ptr mDataRequest; std::vector>> mParticleInfo; // src/event/track - std::vector mParticleInfoPrim; - std::vector mParticleInfoSec; unsigned short mMask = 0x7f; // Utils @@ -144,6 +142,8 @@ class TrackCheckStudy : public Task std::unique_ptr mZk; std::unique_ptr mRadLam; std::unique_ptr mZLam; + std::unique_ptr mRadIperT; + std::unique_ptr mZIperT; std::unique_ptr mGoodRadk; std::unique_ptr mFakeRadk; std::unique_ptr mGoodZk; @@ -152,6 +152,11 @@ class TrackCheckStudy : public Task std::unique_ptr mFakeRadLam; std::unique_ptr mGoodZLam; std::unique_ptr mFakeZLam; + std::unique_ptr mGoodRadIperT; + std::unique_ptr mFakeRadIperT; + std::unique_ptr mGoodZIperT; + std::unique_ptr mFakeZIperT; + std::unique_ptr pdgcodeHisto; std::unique_ptr mEffPt; // Eff vs Pt primary std::unique_ptr mEffFakePt; @@ -164,7 +169,8 @@ class TrackCheckStudy : public Task std::unique_ptr mEffFakeRad; std::unique_ptr mEffZ; // Eff vs Z of sv secondary std::unique_ptr mEffFakeZ; - std::unique_ptr mEffRadk; // Eff vs Z of sv and decay radius secondary for particle with mother k e lambda + + std::unique_ptr mEffRadk; // Eff vs Z of sv and decay radius secondary for particle with mother k0s, IperTbda,iperT std::unique_ptr mEffFakeRadk; std::unique_ptr mEffZk; std::unique_ptr mEffFakeZk; @@ -172,6 +178,10 @@ class TrackCheckStudy : public Task std::unique_ptr mEffFakeRadLam; std::unique_ptr mEffZLam; std::unique_ptr mEffFakeZLam; + std::unique_ptr mEffRadIperT; + std::unique_ptr mEffFakeRadIperT; + std::unique_ptr mEffZIperT; + std::unique_ptr mEffFakeZIperT; std::unique_ptr mPtResolution; // Pt resolution for both primary and secondary std::unique_ptr mPtResolution2D; @@ -185,14 +195,17 @@ class TrackCheckStudy : public Task std::unique_ptr mIperTClusterfake1D; std::unique_ptr mKClusterfake1D; std::unique_ptr mLamClusterfake1D; - const char* ParticleName[10] = {"e^{+}", "e^{-}", "#pi^{-}", "#pi^{+}", "p", "^{2}H","^{2}H^{-}", "^{3}He","^{3}He^{-}","_{#Lambda}^{3}H"}; + const char* ParticleName[14] = {"e^{+}", "e^{-}", "#pi^{-}", "#pi^{+}", "p", "p^{-}", "^{2}H", "^{2}H^{-}", "^{3}He", "^{3}He^{-}", "_{#Lambda}^{3}H", "_{#Lambda}^{3}H^{-}", "k^{+}", "k^{-}"}; + const char* tt[3] = {"_{#Lambda}^{3}H", "#Lambda", "k^{0}_{s}"}; const char* ProcessName[50]; - std::vector histLength, histLength1Fake, histLength2Fake, histLength3Fake, histLengthNoCl, histLength1FakeNoCl, histLength2FakeNoCl, histLength3FakeNoCl; // FakeCluster Study + std::vector> histLength, histLength1Fake, histLength2Fake, histLength3Fake, histLengthNoCl, histLength1FakeNoCl, histLength2FakeNoCl, histLength3FakeNoCl; // FakeCluster Study std::vector stackLength, stackLength1Fake, stackLength2Fake, stackLength3Fake; std::vector legends, legends1Fake, legends2Fake, legends3Fake; - std::vector> mGoodPts, mFakePts, mTotPts, mGoodEtas, mFakeEtas, mTotEtas, mGoodPtsK, mFakePtsK, mTotPtsK, mGoodPtsLam, mFakePtsLam, mTotPtsLam, mGoodPtsIperT, mFakePtsIperT, mTotPtsIperT; - std::vector> mEffGoodPts, mEffFakePts, mEffGoodEtas, mEffFakeEtas, mEffGoodPtsK, mEffFakePtsK, mEffGoodPtsLam, mEffFakePtsLam, mEffGoodPtsIperT, mEffFakePtsIperT; + std::vector> mGoodPts, mFakePts, mTotPts, mGoodPtsK, mFakePtsK, mTotPtsK, mGoodPtsLam, mFakePtsLam, mTotPtsLam, mGoodPtsIperT, mFakePtsIperT, mTotPtsIperT; + std::vector> mEffGoodPts, mEffFakePts, mEffGoodPtsK, mEffFakePtsK, mEffGoodPtsLam, mEffFakePtsLam, mEffGoodPtsIperT, mEffFakePtsIperT; + std::vector> mGoodEtas, mTotEtas, mFakeEtas, mGoodEtasK, mFakeEtasK, mTotEtasK, mGoodEtasLam, mFakeEtasLam, mTotEtasLam, mGoodEtasIperT, mFakeEtasIperT, mTotEtasIperT; + std::vector> mEffGoodEtas, mEffFakeEtas, mEffGoodEtasK, mEffFakeEtasK, mEffGoodEtasLam, mEffFakeEtasLam, mEffGoodEtasIperT, mEffFakeEtasIperT; // Canvas & decorations std::unique_ptr mCanvasPt; std::unique_ptr mCanvasPt2; @@ -202,18 +215,12 @@ class TrackCheckStudy : public Task std::unique_ptr mCanvasZ; std::unique_ptr mCanvasRadD; std::unique_ptr mCanvasZD; - std::unique_ptr mCanvasEta2; - std::unique_ptr mCanvasEta2fake; std::unique_ptr mCanvasPtRes; std::unique_ptr mCanvasPtRes2; std::unique_ptr mCanvasPtRes3; std::unique_ptr mCanvasPtRes4; std::unique_ptr mLegendPt; - std::unique_ptr mLegendPt2; - std::unique_ptr mLegendPt2Fake; std::unique_ptr mLegendEta; - std::unique_ptr mLegendEta2; - std::unique_ptr mLegendEta2Fake; std::unique_ptr mLegendPtRes; std::unique_ptr mLegendPtRes2; std::unique_ptr mLegendZ; @@ -270,6 +277,8 @@ void TrackCheckStudy::init(InitContext& ic) mGoodZk = std::make_unique("goodZk", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); mGoodRadLam = std::make_unique("goodRadLam", ";#Radius [cm];Number of tracks", 100, 0, 25); mGoodZLam = std::make_unique("goodZLam", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); + mGoodRadIperT = std::make_unique("goodRadiperT", ";#Radius [cm];Number of tracks", 100, 0, 25); + mGoodZIperT = std::make_unique("goodZiperT", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); mFakePt = std::make_unique("fakePt", ";#it{p}_{T} (GeV/#it{c});Fak", pars.effHistBins, xbins.data()); mFakeEta = std::make_unique("fakeEta", ";#eta;Number of tracks", 60, -3, 3); @@ -281,6 +290,8 @@ void TrackCheckStudy::init(InitContext& ic) mFakeZk = std::make_unique("fakeZk", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); mFakeRadLam = std::make_unique("fakeRadLam", ";#Radius [cm];Number of tracks", 100, 0, 25); mFakeZLam = std::make_unique("fakeZLam", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); + mFakeRadIperT = std::make_unique("fakeRadIperT", ";#Radius [cm];Number of tracks", 100, 0, 25); + mFakeZIperT = std::make_unique("fakeZIperT", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); mMultiFake = std::make_unique("multiFake", ";#it{p}_{T} (GeV/#it{c});Fak", pars.effHistBins, xbins.data()); @@ -292,17 +303,20 @@ void TrackCheckStudy::init(InitContext& ic) mDenominatorSecRad = std::make_unique("denominatorSecRad", ";Radius [cm];Number of tracks", 100, 0, 25); mDenominatorSecZ = std::make_unique("denominatorSecZ", ";z of secondary vertex [cm];Number of tracks", 100, -50, 50); - mIperTClusterfake1D = std::make_unique("IperTClusterfake1D", ";pdg code of fake cluster;Entries", 10, 0., 10.); - mKClusterfake1D = std::make_unique("KClusterfake1D", ";pdg code of fake cluster;Entries", 10, 0., 10.); - mLamClusterfake1D = std::make_unique("LamClusterfake1D", ";pdg code of fake cluster;Entries", 10, 0., 10.); - mIperTClusterfake = std::make_unique("IperT_Clusters_fake", ";particle generating fake cluster; production process", 10, 0., 10., 50, 0, 50); - mKClusterfake = std::make_unique("K0s_Clusters_fake", ";particle generating fake cluster; production process", 10, 0., 10., 50, 0, 50); - mLamClusterfake = std::make_unique("#Lambda_Clusters_fake", ";particle generating fake cluster; production process", 10, 0., 10., 50, 0, 50); + mIperTClusterfake1D = std::make_unique("IperTClusterfake1D", ";particle generating fake cluster;Entries", 14, 0., 14.); + mKClusterfake1D = std::make_unique("KClusterfake1D", ";particle generating fake cluster;Entries", 14, 0., 14.); + mLamClusterfake1D = std::make_unique("LamClusterfake1D", ";particle generating fake cluster;Entries", 14, 0., 14.); + mIperTClusterfake = std::make_unique("IperT_Clusters_fake", ";particle generating fake cluster; production process", 14, 0., 14., 50, 0, 50); + mKClusterfake = std::make_unique("K0s_Clusters_fake", ";particle generating fake cluster; production process", 14, 0., 14., 50, 0, 50); + mLamClusterfake = std::make_unique("#Lambda_Clusters_fake", ";particle generating fake cluster; production process", 14, 0., 14., 50, 0, 50); mRadk = std::make_unique("mRadk", ";Radius [cm];Number of tracks", 100, 0, 25); mRadLam = std::make_unique("mRadLam", ";Radius [cm];Number of tracks", 100, 0, 25); mZk = std::make_unique("mZk", ";z of secondary vertex [cm]", 100, -50, 50); mZLam = std::make_unique("mZLam", ";z of secondary vertex [cm]", 100, -50, 50); + mRadIperT = std::make_unique("mRadIperT", ";Radius [cm];Number of tracks", 100, 0, 25); + mZIperT = std::make_unique("mZIperT", ";z of secondary vertex [cm]", 100, -50, 50); + pdgcodeHisto = std::make_unique("pdgcodeHisto", ";pdgcode of mother particle", 4000, 0, 4000); mGoodPts.resize(4); mFakePts.resize(4); mTotPts.resize(4); @@ -318,6 +332,15 @@ void TrackCheckStudy::init(InitContext& ic) mGoodPtsIperT.resize(4); mFakePtsIperT.resize(4); mTotPtsIperT.resize(4); + mGoodEtasK.resize(4); + mFakeEtasK.resize(4); + mTotEtasK.resize(4); + mGoodEtasLam.resize(4); + mFakeEtasLam.resize(4); + mTotEtasLam.resize(4); + mGoodEtasIperT.resize(4); + mFakeEtasIperT.resize(4); + mTotEtasIperT.resize(4); mEffGoodPts.resize(4); mEffFakePts.resize(4); mEffGoodEtas.resize(4); @@ -328,7 +351,12 @@ void TrackCheckStudy::init(InitContext& ic) mEffFakePtsLam.resize(4); mEffGoodPtsIperT.resize(4); mEffFakePtsIperT.resize(4); - + mEffGoodEtasK.resize(4); + mEffFakeEtasK.resize(4); + mEffGoodEtasLam.resize(4); + mEffFakeEtasLam.resize(4); + mEffGoodEtasIperT.resize(4); + mEffFakeEtasIperT.resize(4); for (int yy = 0; yy < 4; yy++) { // divided by layer mGoodPts[yy] = std::make_unique(Form("goodPts%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); mFakePts[yy] = std::make_unique(Form("FakePs%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); @@ -338,15 +366,25 @@ void TrackCheckStudy::init(InitContext& ic) mFakeEtas[yy] = std::make_unique(Form("FakeEtas%d", yy), ";#eta;Number of tracks", 60, -3, 3); mTotEtas[yy] = std::make_unique(Form("TotEtas%d", yy), ";#eta;Number of tracks", 60, -3, 3); - mGoodPtsK[yy] = std::make_unique(Form("goodPtK%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mFakePtsK[yy] = std::make_unique(Form("FakePtK%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mTotPtsK[yy] = std::make_unique(Form("TotPtK%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mGoodPtsLam[yy] = std::make_unique(Form("goodPtLam%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mFakePtsLam[yy] = std::make_unique(Form("FakePtLam%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mTotPtsLam[yy] = std::make_unique(Form("TotPtLam%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mGoodPtsIperT[yy] = std::make_unique(Form("goodPtIperT%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mFakePtsIperT[yy] = std::make_unique(Form("FakePtIperT%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mTotPtsIperT[yy] = std::make_unique(Form("TotPtIperT%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mGoodPtsK[yy] = std::make_unique(Form("goodPtK%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mFakePtsK[yy] = std::make_unique(Form("FakePtK%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mTotPtsK[yy] = std::make_unique(Form("TotPtK%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mGoodPtsLam[yy] = std::make_unique(Form("goodPtLam%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mFakePtsLam[yy] = std::make_unique(Form("FakePtLam%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mTotPtsLam[yy] = std::make_unique(Form("TotPtLam%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mGoodPtsIperT[yy] = std::make_unique(Form("goodPtIperT%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mFakePtsIperT[yy] = std::make_unique(Form("FakePtIperT%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mTotPtsIperT[yy] = std::make_unique(Form("TotPtIperT%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + + mGoodEtasK[yy] = std::make_unique(Form("goodEtaK%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); + mFakeEtasK[yy] = std::make_unique(Form("FakeEtaK%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); + mTotEtasK[yy] = std::make_unique(Form("TotEtaK%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); + mGoodEtasLam[yy] = std::make_unique(Form("goodEtaLam%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); + mFakeEtasLam[yy] = std::make_unique(Form("FakeEtaLam%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); + mTotEtasLam[yy] = std::make_unique(Form("TotEtaLam%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); + mGoodEtasIperT[yy] = std::make_unique(Form("goodEtaIperT%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); + mFakeEtasIperT[yy] = std::make_unique(Form("FakeEtaIperT%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); + mTotEtasIperT[yy] = std::make_unique(Form("TotEtaIperT%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); mGoodPts[yy]->Sumw2(); mFakePts[yy]->Sumw2(); @@ -363,6 +401,15 @@ void TrackCheckStudy::init(InitContext& ic) mGoodPtsIperT[yy]->Sumw2(); mFakePtsIperT[yy]->Sumw2(); mTotPtsIperT[yy]->Sumw2(); + mGoodEtasK[yy]->Sumw2(); + mFakeEtasK[yy]->Sumw2(); + mTotEtasK[yy]->Sumw2(); + mGoodEtasLam[yy]->Sumw2(); + mFakeEtasLam[yy]->Sumw2(); + mTotEtasLam[yy]->Sumw2(); + mGoodEtasIperT[yy]->Sumw2(); + mFakeEtasIperT[yy]->Sumw2(); + mTotEtasIperT[yy]->Sumw2(); } mPtResolution = std::make_unique("PtResolution", ";#it{p}_{T} ;Den", 100, -1, 1); @@ -385,10 +432,14 @@ void TrackCheckStudy::init(InitContext& ic) mGoodZ->Sumw2(); mGoodRadk->Sumw2(); mGoodZk->Sumw2(); + mGoodRadIperT->Sumw2(); + mGoodZIperT->Sumw2(); mGoodRadLam->Sumw2(); mGoodZLam->Sumw2(); mFakeRadk->Sumw2(); mFakeZk->Sumw2(); + mFakeRadIperT->Sumw2(); + mFakeZIperT->Sumw2(); mFakeRadLam->Sumw2(); mFakeZLam->Sumw2(); mFakePt->Sumw2(); @@ -412,59 +463,68 @@ void TrackCheckStudy::init(InitContext& ic) stackLength1Fake.resize(4); stackLength2Fake.resize(4); stackLength3Fake.resize(4); + for (int yy = 0; yy < 4; yy++) { + histLength[yy].resize(3); + histLength1Fake[yy].resize(3); + histLength2Fake[yy].resize(3); + histLength3Fake[yy].resize(3); + histLengthNoCl[yy].resize(3); + histLength1FakeNoCl[yy].resize(3); + histLength2FakeNoCl[yy].resize(3); + histLength3FakeNoCl[yy].resize(3); + } legends.resize(4); legends1Fake.resize(4); legends2Fake.resize(4); legends3Fake.resize(4); - + int colorArr[3] = {kGreen, kRed, kBlue}; for (int iH{4}; iH < 8; ++iH) { - histLength[iH - 4] = new TH1I(Form("trk_len_%d", iH), "#exists cluster", 7, -.5, 6.5); - histLength[iH - 4]->SetFillColor(kGreen + 3); - histLength[iH - 4]->SetLineColor(kGreen + 3); - histLength[iH - 4]->SetFillStyle(3352); - histLengthNoCl[iH - 4] = new TH1I(Form("trk_len_%d_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); - histLengthNoCl[iH - 4]->SetFillColor(kOrange + 7); - histLengthNoCl[iH - 4]->SetLineColor(kOrange + 7); - histLengthNoCl[iH - 4]->SetFillStyle(3352); - stackLength[iH - 4] = new THStack(Form("stack_trk_len_%d", iH), Form("trk_len=%d", iH)); - stackLength[iH - 4]->Add(histLength[iH - 4]); - stackLength[iH - 4]->Add(histLengthNoCl[iH - 4]); - - histLength1Fake[iH - 4] = new TH1I(Form("trk_len_%d_1f", iH), "#exists cluster", 7, -.5, 6.5); - histLength1Fake[iH - 4]->SetFillColor(kGreen + 3); - histLength1Fake[iH - 4]->SetLineColor(kGreen + 3); - histLength1Fake[iH - 4]->SetFillStyle(3352); - histLength1FakeNoCl[iH - 4] = new TH1I(Form("trk_len_%d_1f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); - histLength1FakeNoCl[iH - 4]->SetFillColor(kOrange + 7); - histLength1FakeNoCl[iH - 4]->SetLineColor(kOrange + 7); - histLength1FakeNoCl[iH - 4]->SetFillStyle(3352); - stackLength1Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_1f", iH), Form("trk_len=%d, 1 Fake", iH)); - stackLength1Fake[iH - 4]->Add(histLength1Fake[iH - 4]); - stackLength1Fake[iH - 4]->Add(histLength1FakeNoCl[iH - 4]); - - histLength2Fake[iH - 4] = new TH1I(Form("trk_len_%d_2f", iH), "#exists cluster", 7, -.5, 6.5); - histLength2Fake[iH - 4]->SetFillColor(kGreen + 3); - histLength2Fake[iH - 4]->SetLineColor(kGreen + 3); - histLength2Fake[iH - 4]->SetFillStyle(3352); - histLength2FakeNoCl[iH - 4] = new TH1I(Form("trk_len_%d_2f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); - histLength2FakeNoCl[iH - 4]->SetFillColor(kOrange + 7); - histLength2FakeNoCl[iH - 4]->SetLineColor(kOrange + 7); - histLength2FakeNoCl[iH - 4]->SetFillStyle(3352); - stackLength2Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_2f", iH), Form("trk_len=%d, 2 Fake", iH)); - stackLength2Fake[iH - 4]->Add(histLength2Fake[iH - 4]); - stackLength2Fake[iH - 4]->Add(histLength2FakeNoCl[iH - 4]); - - histLength3Fake[iH - 4] = new TH1I(Form("trk_len_%d_3f", iH), "#exists cluster", 7, -.5, 6.5); - histLength3Fake[iH - 4]->SetFillColor(kGreen + 3); - histLength3Fake[iH - 4]->SetLineColor(kGreen + 3); - histLength3Fake[iH - 4]->SetFillStyle(3352); - histLength3FakeNoCl[iH - 4] = new TH1I(Form("trk_len_%d_3f_nocl", iH), "#slash{#exists} cluster", 7, -.5, 6.5); - histLength3FakeNoCl[iH - 4]->SetFillColor(kOrange + 7); - histLength3FakeNoCl[iH - 4]->SetLineColor(kOrange + 7); - histLength3FakeNoCl[iH - 4]->SetFillStyle(3352); - stackLength3Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_3f", iH), Form("trk_len=%d, 3 Fake", iH)); - stackLength3Fake[iH - 4]->Add(histLength3Fake[iH - 4]); - stackLength3Fake[iH - 4]->Add(histLength3FakeNoCl[iH - 4]); + for (int jj = 0; jj < 3; jj++) { + histLength[iH - 4][jj] = new TH1I(Form("trk_len_%d_%s", iH, tt[jj]), Form("#exists cluster %s", tt), 7, -.5, 6.5); + histLength[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); + histLength[iH - 4][jj]->SetLineColor(colorArr[jj] - 9); + histLengthNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_nocl_%s", iH, tt[jj]), Form("#slash{#exists} cluster %s", tt), 7, -.5, 6.5); + histLengthNoCl[iH - 4][jj]->SetFillColor(colorArr[jj] + 1); + histLengthNoCl[iH - 4][jj]->SetLineColor(colorArr[jj] + 1); + if (jj == 0) + stackLength[iH - 4] = new THStack(Form("stack_trk_len_%d", iH), Form("trk_len=%d", iH)); + stackLength[iH - 4]->Add(histLength[iH - 4][jj]); + stackLength[iH - 4]->Add(histLengthNoCl[iH - 4][jj]); + + histLength1Fake[iH - 4][jj] = new TH1I(Form("trk_len_%d_1f_%s", iH, tt[jj]), Form("#exists cluster %s", tt[jj]), 7, -.5, 6.5); + histLength1Fake[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); + histLength1Fake[iH - 4][jj]->SetLineColor(colorArr[jj] - 9); + histLength1FakeNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_1f_nocl_%s", iH, tt[jj]), Form("#slash{#exists} cluster %s", tt[jj]), 7, -.5, 6.5); + histLength1FakeNoCl[iH - 4][jj]->SetFillColor(colorArr[jj] + 1); + histLength1FakeNoCl[iH - 4][jj]->SetLineColor(colorArr[jj] + 1); + if (jj == 0) + stackLength1Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_1f", iH), Form("trk_len=%d, 1 Fake", iH)); + stackLength1Fake[iH - 4]->Add(histLength1Fake[iH - 4][jj]); + stackLength1Fake[iH - 4]->Add(histLength1FakeNoCl[iH - 4][jj]); + + histLength2Fake[iH - 4][jj] = new TH1I(Form("trk_len_%d_2f_%s", iH, tt[jj]), Form("#exists cluster %s", tt[jj]), 7, -.5, 6.5); + histLength2Fake[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); + histLength2Fake[iH - 4][jj]->SetLineColor(colorArr[jj] - 9); + histLength2FakeNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_2f_nocl_%s", iH, tt[jj]), Form("#slash{#exists} cluster %s", tt[jj]), 7, -.5, 6.5); + histLength2FakeNoCl[iH - 4][jj]->SetFillColor(colorArr[jj] + 1); + histLength2FakeNoCl[iH - 4][jj]->SetLineColor(colorArr[jj] + 1); + if (jj == 0) + stackLength2Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_2f", iH), Form("trk_len=%d, 2 Fake", iH)); + stackLength2Fake[iH - 4]->Add(histLength2Fake[iH - 4][jj]); + stackLength2Fake[iH - 4]->Add(histLength2FakeNoCl[iH - 4][jj]); + + histLength3Fake[iH - 4][jj] = new TH1I(Form("trk_len_%d_3f_%s", iH, tt[jj]), Form("#exists cluster %s", tt[jj]), 7, -.5, 6.5); + histLength3Fake[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); + histLength3Fake[iH - 4][jj]->SetLineColor(colorArr[jj] - 9); + + histLength3FakeNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_3f_nocl_%s", iH, tt[jj]), Form("#slash{#exists} cluster %s", tt[jj]), 7, -.5, 6.5); + histLength3FakeNoCl[iH - 4][jj]->SetFillColor(colorArr[jj] + 1); + histLength3FakeNoCl[iH - 4][jj]->SetLineColor(colorArr[jj] + 1); + if (jj == 0) + stackLength3Fake[iH - 4] = new THStack(Form("stack_trk_len_%d_3f", iH), Form("trk_len=%d, 3 Fake", iH)); + stackLength3Fake[iH - 4]->Add(histLength3Fake[iH - 4][jj]); + stackLength3Fake[iH - 4]->Add(histLength3FakeNoCl[iH - 4][jj]); + } } } @@ -536,10 +596,25 @@ void TrackCheckStudy::process() } LOGP(info, "** Analysing tracks ... "); int unaccounted{0}, good{0}, fakes{0}, total{0}; - int good0 = 0, good1 = 0, good2 = 0, good3 = 0, totalsec = 0, totsectake = 0; // secondary - int fake0 = 0, fake1 = 0, fake2 = 0, fake3 = 0; - int totsec0 = 0, totsec1 = 0, totsec2 = 0, totsec3 = 0; + // ***secondary tracks*** + int nPartForSpec[4][4]; // total number [particle 0=IperT 1=Lambda 2=k][n layer] + int nPartGoodorFake[4][4][2]; // number of good or fake [particle 0=IperT 1=Lambda 2=k][n layer][n layer][good=1 fake=0] + for(int n=0;n<4;n++) + { + for(int m=0;m<4;m++) + { + nPartForSpec[n][m]=0; + for(int h=0;h<2;h++) + { + nPartGoodorFake[n][m][h]=0; + } + } + } int nlayer = 999; + int ngoodfake = 0; + int totsec = 0; + int totsecCont = 0; + for (auto iTrack{0}; iTrack < mTracks.size(); ++iTrack) { auto& lab = mTracksMCLabels[iTrack]; if (!lab.isSet() || lab.isNoise()) { @@ -574,12 +649,9 @@ void TrackCheckStudy::process() LOGP(info, "** Filling histograms ... "); int evID = 0; int trackID = 0; - int Ltot, Ktot, Itot; - int LtotG, KtotG, ItotG; - int LtotF, KtotF, ItotF; for (int yy = 0; yy < 50; yy++) { - ProcessName[yy]= " "; + ProcessName[yy] = " "; } // Currently process only sourceID = 0, to be extended later if needed for (auto& evInfo : mParticleInfo[0]) { @@ -617,13 +689,16 @@ void TrackCheckStudy::process() } } - if (!part.isPrimary) { // **Secondary particle** + // **Secondary particle** + nlayer = 999; + ngoodfake = 2; + if (!part.isPrimary) { + int TrackID, EvID, SrcID; - totalsec++; int pdgcode = mParticleInfo[0][evID][part.mother].pdg; - + int idxPart = 4; float rad = sqrt(pow(part.vx, 2) + pow(part.vy, 2)); - + totsec++; if ((rad < rLayer0) && (part.clusters == 0x7f || part.clusters == 0x3f || part.clusters == 0x1f || part.clusters == 0x0f)) // layer 0 nlayer = 0; if (rad < rLayer1 && rad > rLayer0 && (part.clusters == 0x1e || part.clusters == 0x3e || part.clusters == 0x7e)) // layer 1 @@ -633,65 +708,82 @@ void TrackCheckStudy::process() if (rad < rLayer3 && rad > rLayer2 && part.clusters == 0x78) // layer 3 nlayer = 3; if (nlayer == 0 || nlayer == 1 || nlayer == 2 || nlayer == 3) { + totsecCont++; mDenominatorSecRad->Fill(rad); mDenominatorSecZ->Fill(part.vz); - totsectake++; mTotPts[nlayer]->Fill(part.pt); mTotEtas[nlayer]->Fill(part.eta); - if (part.isReco) { + ngoodfake = 1; mGoodPts[nlayer]->Fill(part.pt); mGoodEtas[nlayer]->Fill(part.eta); } if (part.isFake) { + ngoodfake = 0; mFakePts[nlayer]->Fill(part.pt); mFakeEtas[nlayer]->Fill(part.eta); } - if (pdgcode == 310) // mother particle = k0s + if (pdgcode == 310 ||pdgcode == -310 ) // mother particle = k0s or anti k0s { + idxPart = 2; mRadk->Fill(rad); mZk->Fill(part.vz); mTotPtsK[nlayer]->Fill(part.pt); + mTotEtasK[nlayer]->Fill(part.eta); if (part.isReco) { mGoodRadk->Fill(rad); mGoodZk->Fill(part.vz); mGoodPtsK[nlayer]->Fill(part.pt); + mGoodEtasK[nlayer]->Fill(part.eta); } if (part.isFake) { mFakeRadk->Fill(rad); mFakeZk->Fill(part.vz); mFakePtsK[nlayer]->Fill(part.pt); + mFakeEtasK[nlayer]->Fill(part.eta); } } - if (pdgcode == 3122) // mother particle = Lambda + if (pdgcode == 3122 || pdgcode == -3122 ) // mother particle = Lambda or anti Lambda { + idxPart = 1; mRadLam->Fill(rad); mZLam->Fill(part.vz); mTotPtsLam[nlayer]->Fill(part.pt); - + mTotEtasLam[nlayer]->Fill(part.eta); if (part.isReco) { mGoodRadLam->Fill(rad); mGoodZLam->Fill(part.vz); mGoodPtsLam[nlayer]->Fill(part.pt); + mGoodEtasLam[nlayer]->Fill(part.eta); } if (part.isFake) { mFakeRadLam->Fill(rad); mFakeZLam->Fill(part.vz); mFakePtsLam[nlayer]->Fill(part.pt); + mFakeEtasLam[nlayer]->Fill(part.eta); } } - if (pdgcode == 1010010030 ) // mother particle = IperT + if (pdgcode == 1010010030 ||pdgcode == -1010010030 ) // mother particle = IperT or anti IperT { - + idxPart = 0; mTotPtsIperT[nlayer]->Fill(part.pt); + mTotEtasIperT[nlayer]->Fill(part.eta); if (part.isReco) { mGoodPtsIperT[nlayer]->Fill(part.pt); + mGoodEtasIperT[nlayer]->Fill(part.eta); } if (part.isFake) { mFakePtsIperT[nlayer]->Fill(part.pt); + mFakeEtasIperT[nlayer]->Fill(part.eta); } } - + if (pdgcode != 1010010030 && pdgcode != 3122 && pdgcode != 310 && pdgcode != -1010010030) { + idxPart = 3; + pdgcodeHisto->Fill(pdgcode); + } + if (ngoodfake == 1 || ngoodfake == 0) + nPartGoodorFake[idxPart][nlayer][ngoodfake]++; + nPartForSpec[idxPart][nlayer]=nPartForSpec[idxPart][nlayer]+1; // Analysing fake clusters int nCl{0}; @@ -701,91 +793,90 @@ void TrackCheckStudy::process() if (nCl < 3) { continue; } - - auto& track = part.track; - auto len = track.getNClusters(); - int nclu = track.getNumberOfClusters(); - int firstclu = track.getFirstClusterEntry(); - for (int iLayer{0}; iLayer < 7; ++iLayer) { - if (track.hasHitOnLayer(iLayer)) { - if (track.isFakeOnLayer(iLayer)) { - // Reco track has fake cluster - if (part.clusters & (0x1 << iLayer)) { // Correct cluster exists - histLength[len - 4]->Fill(iLayer); - if (track.getNFakeClusters() == 1) { - histLength1Fake[len - 4]->Fill(iLayer); - } - if (track.getNFakeClusters() == 2) { - histLength2Fake[len - 4]->Fill(iLayer); - } - if (track.getNFakeClusters() == 3) { - histLength3Fake[len - 4]->Fill(iLayer); - } - } else { - - histLengthNoCl[len - 4]->Fill(iLayer); - if (track.getNFakeClusters() == 1) { - histLength1FakeNoCl[len - 4]->Fill(iLayer); - } - if (track.getNFakeClusters() == 2) { - histLength2FakeNoCl[len - 4]->Fill(iLayer); - } - if (track.getNFakeClusters() == 3) { - histLength3FakeNoCl[len - 4]->Fill(iLayer); - } - //LOGP(info,"aaaaa"); - } - LOGP(info,"first clu index: {}, first cluster layer={}, ilayer={}",firstclu,track.getFirstClusterLayer(),iLayer); - auto labs = mClustersMCLCont->getLabels(mInputITSidxs[firstclu + (iLayer - track.getFirstClusterLayer())]); - - for (auto& lab : labs) { - if (!lab.isValid()) { - continue; // We want to skip channels related to noise, e.g. sID = 99: QED + if (idxPart < 3) { + auto& track = part.track; + auto len = track.getNClusters(); + int nclu = track.getNumberOfClusters(); + int firstclu = track.getFirstClusterEntry(); + for (int iLayer{0}; iLayer < 7; ++iLayer) { + if (track.hasHitOnLayer(iLayer)) { + if (track.isFakeOnLayer(iLayer)) { + // Reco track has fake cluster + if (part.clusters & (0x1 << iLayer)) { // Correct cluster exists + histLength[len - 4][idxPart]->Fill(iLayer); + if (track.getNFakeClusters() == 1) { + histLength1Fake[len - 4][idxPart]->Fill(iLayer); + } + if (track.getNFakeClusters() == 2) { + histLength2Fake[len - 4][idxPart]->Fill(iLayer); + } + if (track.getNFakeClusters() == 3) { + histLength3Fake[len - 4][idxPart]->Fill(iLayer); + } + } else { + + histLengthNoCl[len - 4][idxPart]->Fill(iLayer); + if (track.getNFakeClusters() == 1) { + histLength1FakeNoCl[len - 4][idxPart]->Fill(iLayer); + } + if (track.getNFakeClusters() == 2) { + histLength2FakeNoCl[len - 4][idxPart]->Fill(iLayer); + } + if (track.getNFakeClusters() == 3) { + histLength3FakeNoCl[len - 4][idxPart]->Fill(iLayer); + } } - - - bool fakec; - const_cast(lab).get(TrackID, EvID, SrcID, fakec); - double intHisto = 0; - LOGP(info,"Ev ID, track ID part ={}-{}, evID trackID cluster= {}-{}",evID,trackID,EvID,TrackID); - //if(nlayer==1) LOGP(info,"pdg code cluster fake= {}",mParticleInfo[SrcID][EvID][TrackID].pdg); - if (mParticleInfo[SrcID][EvID][TrackID].pdg == -11) - intHisto = 0.5; // "e^{+}" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 11) - intHisto = 1.5; // "e^{-}" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == -211) - intHisto = 2.5; // "#pi^{-}" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 211) - intHisto = 3.5; // "#pi^{+}" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 2212) - intHisto = 4.5; // "p" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1000010020) - intHisto = 5.5; // "^{2}H" + auto labs = mClustersMCLCont->getLabels(mInputITSidxs[firstclu - 1 - iLayer + track.getFirstClusterLayer() + nclu]); + + for (auto& lab : labs) { + if (!lab.isValid()) { + continue; // We want to skip channels related to noise, e.g. sID = 99: QED + } + + bool fakec; + const_cast(lab).get(TrackID, EvID, SrcID, fakec); + double intHisto = 0; + if (mParticleInfo[SrcID][EvID][TrackID].pdg == -11) + intHisto = 0.5; // "e^{+}" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 11) + intHisto = 1.5; // "e^{-}" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == -211) + intHisto = 2.5; // "#pi^{-}" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 211) + intHisto = 3.5; // "#pi^{+}" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 2212) + intHisto = 4.5; // "p" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == -2212) + intHisto = 5.5; // "anti p" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1000010020) + intHisto = 6.5; // "^{2}H" if (mParticleInfo[SrcID][EvID][TrackID].pdg == -1000010020) - intHisto = 6.5; // "^{2}H-" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1000020030) - intHisto = 7.5; // "^{3}He" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == -1000020030) - intHisto = 8.5; // "^{3}He-" + intHisto = 7.5; // "^{2}H-" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1000020030) + intHisto = 8.5; // "^{3}He" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == -1000020030) + intHisto = 9.5; // "^{3}He-" if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1010010030) - intHisto = 9.5; // "IperT" - ProcessName[mParticleInfo[SrcID][EvID][TrackID].prodProcess]=mParticleInfo[SrcID][EvID][TrackID].prodProcessName; - //if(nlayer==1) LOGP(info,"pdg code cluster fake = {}",mParticleInfo[SrcID][EvID][TrackID].pdg); - if (pdgcode == 1010010030){ - //if(nlayer==1) LOGP(info,"pdg code cluster fake m=iperT= {}",mParticleInfo[SrcID][EvID][TrackID].pdg); - mIperTClusterfake->Fill(intHisto,mParticleInfo[SrcID][EvID][TrackID].prodProcess); - mIperTClusterfake1D->Fill(intHisto); - } - if (pdgcode == 3122){ - //if(nlayer==1) LOGP(info,"pdg code cluster fake m=lam= {}",mParticleInfo[SrcID][EvID][TrackID].pdg); - mLamClusterfake->Fill(intHisto,mParticleInfo[SrcID][EvID][TrackID].prodProcess); - mLamClusterfake1D->Fill(intHisto); - } - if (pdgcode == 310) - { - //if(nlayer==1) LOGP(info,"pdg code cluster fake m=k= {}",mParticleInfo[SrcID][EvID][TrackID].pdg); - mKClusterfake->Fill(intHisto,mParticleInfo[SrcID][EvID][TrackID].prodProcess); - mKClusterfake1D->Fill(intHisto); + intHisto = 10.5; // "IperT" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == -1010010030) + intHisto = 11.5; // " AntiIperT" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == 321) + intHisto = 12.5; // "K+" + if (mParticleInfo[SrcID][EvID][TrackID].pdg == -321) + intHisto = 13.5; // "K-" + ProcessName[mParticleInfo[SrcID][EvID][TrackID].prodProcess] = mParticleInfo[SrcID][EvID][TrackID].prodProcessName; + if (pdgcode == 1010010030) { + mIperTClusterfake->Fill(intHisto, mParticleInfo[SrcID][EvID][TrackID].prodProcess); + mIperTClusterfake1D->Fill(intHisto); + } + if (pdgcode == 3122) { + mLamClusterfake->Fill(intHisto, mParticleInfo[SrcID][EvID][TrackID].prodProcess); + mLamClusterfake1D->Fill(intHisto); + } + if (pdgcode == 310) { + mKClusterfake->Fill(intHisto, mParticleInfo[SrcID][EvID][TrackID].prodProcess); + mKClusterfake1D->Fill(intHisto); + } } } } @@ -798,6 +889,51 @@ void TrackCheckStudy::process() } evID++; } + + /*int totgood{0}, totfake{0}, totI{0}, totL{0}, totK{0}, totO{0}; + for (int u = 0; u < 4; u++) { + for (int v = 0; v < 4; v++) { + totgood = totgood + nPartGoodorFake[u][v][1]; + totfake = totfake + nPartGoodorFake[u][v][0]; + if (u == 0) + totI = totI + nPartForSpec[u][v]; + if (u == 1) + totL = totL + nPartForSpec[u][v]; + if (u == 2) + totK = totK + nPartForSpec[u][v]; + if (u == 3) + { + totO = totO + nPartForSpec[u][v]; + LOGP(info, "cout5"); + } + } + }*/ + int totgood{0}, totfake{0}, totI{0}, totL{0}, totK{0}, totO{0}; + for(int xx=0;xx<4;xx++) + { + for(int yy=0;yy<4;yy++) + { + totgood = totgood + nPartGoodorFake[xx][yy][1]; + totfake = totfake + nPartGoodorFake[xx][yy][0]; + if(xx==0) totI = totI + nPartForSpec[0][yy]; + if(xx==1) totL = totL + nPartForSpec[1][yy]; + if(xx==2) totK = totK + nPartForSpec[2][yy]; + if(xx==3) totO = totO + nPartForSpec[3][yy]; + + } + } + LOGP(info, "cout6"); + LOGP(info, "** Some statistics on secondary tracks:"); + + LOGP(info, "\t- Total number of secondary tracks: {}", totsec); + LOGP(info, "\t- Total number of secondary accepted tracks : {}", totsecCont); + LOGP(info, "\t- Total number of secondary accepted tracks good: {}, fake: {}", totgood, totfake); + LOGP(info, "\t- Total number of secondary accepted tracks from IperT: {} = {} %", totI, 100 * totI / totsecCont); + LOGP(info, "\t- Total number of secondary accepted tracks from Lam: {} = {} %", totL, 100 * totL / totsecCont); + LOGP(info, "\t- Total number of secondary accepted tracks from k: {} = {} %", totK, 100 * totK / totsecCont); + LOGP(info, "\t- Total number of secondary accepted tracks from Other: {} = {} %", totO, 100 * totO / totsecCont); + + // LOGP(info, "fraction of k = {}, fraction of lambda= {}", (*mRadk).GetEntries() / (*mDenominatorSecRad).GetEntries(), (*mRadLam).GetEntries() / (*mDenominatorSecRad).GetEntries()); Histo.push_back(*mDenominatorSecRad); Histo.push_back(*mRadk); @@ -808,15 +944,8 @@ void TrackCheckStudy::process() Histo.push_back(*mIperTClusterfake1D); Histo.push_back(*mLamClusterfake1D); Histo.push_back(*mKClusterfake1D); + Histo.push_back(*pdgcodeHisto); - LOGP(info, "** Some statistics on secondary tracks:"); - - LOGP(info, "\t- Total number of secondary tracks: {}", totalsec); - LOGP(info, "\t- Total number of secondary tracks on layer O: {}, good: {}, fake: {}", totsec0, good0, fake0); - LOGP(info, "\t- Total number of secondary tracks on layer 1: {}, good: {}, fake: {}", totsec1, good1, fake1); - LOGP(info, "\t- Total number of secondary tracks on layer 2: {}, good: {}, fake: {}", totsec2, good2, fake2); - LOGP(info, "\t- Total number of secondary tracks on layer 3: {}, good: {}, fake: {}", totsec3, good3, fake3); - LOGP(info, "fraction of k = {}, fraction of lambda= {}", (*mRadk).GetEntries() / (*mDenominatorSecRad).GetEntries(), (*mRadLam).GetEntries() / (*mDenominatorSecRad).GetEntries()); LOGP(info, "** Computing efficiencies ..."); mEffPt = std::make_unique(*mGoodPt, *mDenominatorPt); @@ -848,15 +977,20 @@ void TrackCheckStudy::process() for (int ii = 0; ii < 4; ii++) { mEffGoodPts[ii] = std::make_unique(*mGoodPts[ii], *mTotPts[ii]); mEffFakePts[ii] = std::make_unique(*mFakePts[ii], *mTotPts[ii]); - mEffGoodEtas[ii] = std::make_unique(*mGoodEtas[ii], *mTotEtas[ii]); - mEffFakeEtas[ii] = std::make_unique(*mFakeEtas[ii], *mTotEtas[ii]); - mEffGoodPtsK[ii] = std::make_unique(*mGoodPtsK[ii], *mTotPtsK[ii]); mEffFakePtsK[ii] = std::make_unique(*mFakePtsK[ii], *mTotPtsK[ii]); mEffGoodPtsLam[ii] = std::make_unique(*mGoodPtsLam[ii], *mTotPtsLam[ii]); mEffFakePtsLam[ii] = std::make_unique(*mFakePtsLam[ii], *mTotPtsLam[ii]); mEffGoodPtsIperT[ii] = std::make_unique(*mGoodPtsIperT[ii], *mTotPtsIperT[ii]); mEffFakePtsIperT[ii] = std::make_unique(*mFakePtsIperT[ii], *mTotPtsIperT[ii]); + mEffGoodEtasK[ii] = std::make_unique(*mGoodEtasK[ii], *mTotEtasK[ii]); + mEffFakeEtasK[ii] = std::make_unique(*mFakeEtasK[ii], *mTotEtasK[ii]); + mEffGoodEtasLam[ii] = std::make_unique(*mGoodEtasLam[ii], *mTotEtasLam[ii]); + mEffFakeEtasLam[ii] = std::make_unique(*mFakeEtasLam[ii], *mTotEtasLam[ii]); + mEffGoodEtasIperT[ii] = std::make_unique(*mGoodEtasIperT[ii], *mTotEtasIperT[ii]); + mEffFakeEtasIperT[ii] = std::make_unique(*mFakeEtasIperT[ii], *mTotEtasIperT[ii]); + mEffGoodEtas[ii] = std::make_unique(*mGoodEtas[ii], *mTotEtas[ii]); + mEffFakeEtas[ii] = std::make_unique(*mFakeEtas[ii], *mTotEtas[ii]); } LOGP(info, "** Analysing pT resolution..."); @@ -921,15 +1055,6 @@ void TrackCheckStudy::setHistoGraph(TH1D& histo, std::unique_ptr& histo2, histo.SetDirectory(gDirectory); } -/*void TrackCheckStudy::setHistoGraph(TH1& histo, const char* name, const char* title, const int color, const double alpha = 0.5) -{ - histo.SetName(name); - histo.SetTitle(title); - histo.SetFillColor(color); - histo.SetFillColorAlpha(color, alpha); - histo.SetDirectory(gDirectory); -}*/ - void TrackCheckStudy::updateTimeDependentParams(ProcessingContext& pc) { static bool initOnceDone = false; @@ -945,8 +1070,6 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) { TFile fout(mOutFileName.c_str(), "recreate"); NormalizeHistos(Histo); - // std::unique_ptr mEffPt1; - // mEffPt1=mEffPt->Clone(); setEfficiencyGraph(mEffPt, "Good_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kAzure + 4, 0.65); fout.WriteTObject(mEffPt.get()); @@ -1006,26 +1129,63 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) fout.WriteTObject(mEffFakeZLam.get()); for (int aa = 0; aa < 4; aa++) { - setEfficiencyGraph(mEffGoodPts[aa], Form("EffPtGoodl%d", aa), Form("Tot Sec G Tracks, L%d"";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ",aa),kGray); - setEfficiencyGraph(mEffFakePts[aa], Form("EffPtFakel%d", aa), Form("Tot Sec F Tracks, L%d"";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ",aa), kGray); - setEfficiencyGraph(mEffGoodEtas[aa], Form("EffEtaGoodl%d", aa), Form("Tot Sec G Tracks, L%d"";eta ;efficiency secondary particle ", aa),kAzure + 4); - setEfficiencyGraph(mEffFakeEtas[aa], Form("EffEtaFakel%d", aa), Form("Tot Sec F Tracks, L%d"";eta ;efficiency secondary particle ",aa),kAzure + 4); + setEfficiencyGraph(mEffGoodPts[aa], Form("EffPtGoodl%d", aa), Form("Tot Sec G Tracks, L%d" + ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", + aa), + kGray); + setEfficiencyGraph(mEffFakePts[aa], Form("EffPtFakel%d", aa), Form("Tot Sec F Tracks, L%d" + ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", + aa), + kGray); + setEfficiencyGraph(mEffGoodEtas[aa], Form("EffEtaGoodl%d", aa), Form("Tot Sec G Tracks, L%d" + ";eta ;efficiency secondary particle ", + aa), + kAzure + 4); + setEfficiencyGraph(mEffFakeEtas[aa], Form("EffEtaFakel%d", aa), Form("Tot Sec F Tracks, L%d" + ";eta ;efficiency secondary particle ", + aa), + kAzure + 4); setEfficiencyGraph(mEffGoodPtsK[aa], Form("EffPtGoodKl%d", aa), Form("k^{0}_{s} Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kBlue); setEfficiencyGraph(mEffFakePtsK[aa], Form("EffPtFakeKl%d", aa), Form("k^{0}_{s} Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kBlue); setEfficiencyGraph(mEffGoodPtsLam[aa], Form("EffPtGoodLaml%d", aa), Form("#Lambda Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kRed); setEfficiencyGraph(mEffFakePtsLam[aa], Form("EffPtFakeLaml%d", aa), Form("#Lambda Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kRed); setEfficiencyGraph(mEffGoodPtsIperT[aa], Form("EffPtGoodIperTl%d", aa), Form("_{#Lambda}^{3}H Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kGreen + 2); setEfficiencyGraph(mEffFakePtsIperT[aa], Form("EffPtFakeIperTl%d", aa), Form("_{#Lambda}^{3}H Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kGreen + 2); + + setEfficiencyGraph(mEffGoodEtasK[aa], Form("EffEtaGoodKl%d", aa), Form("k^{0}_{s} Sec G Tracks, L%d ;#eta;efficiency secondary particle ", aa), kBlue); + setEfficiencyGraph(mEffFakeEtasK[aa], Form("EffEtaFakeKl%d", aa), Form("k^{0}_{s} Sec F Tracks, L%d ;#eta;efficiency secondary particle ", aa), kBlue); + setEfficiencyGraph(mEffGoodEtasLam[aa], Form("EffEtaGoodLaml%d", aa), Form("#Lambda Sec G Tracks, L%d ;#eta;efficiency secondary particle ", aa), kRed); + setEfficiencyGraph(mEffFakeEtasLam[aa], Form("EffEtaFakeLaml%d", aa), Form("#Lambda Sec F Tracks, L%d ;#eta;efficiency secondary particle ", aa), kRed); + setEfficiencyGraph(mEffGoodEtasIperT[aa], Form("EffEtaGoodIperTl%d", aa), Form("_{#Lambda}^{3}H Sec G Tracks, L%d ;#eta;efficiency secondary particle ", aa), kGreen + 2); + setEfficiencyGraph(mEffFakeEtasIperT[aa], Form("EffEtaFakeIperTl%d", aa), Form("_{#Lambda}^{3}H Sec F Tracks, L%d ;#eta;efficiency secondary particle ", aa), kGreen + 2); + fout.WriteTObject(mEffGoodPts[aa].get()); fout.WriteTObject(mEffFakePts[aa].get()); - fout.WriteTObject(mEffGoodEtas[aa].get()); - fout.WriteTObject(mEffFakeEtas[aa].get()); fout.WriteTObject(mEffGoodPtsK[aa].get()); fout.WriteTObject(mEffGoodPtsLam[aa].get()); fout.WriteTObject(mEffGoodPtsIperT[aa].get()); fout.WriteTObject(mEffFakePtsK[aa].get()); fout.WriteTObject(mEffFakePtsLam[aa].get()); fout.WriteTObject(mEffFakePtsIperT[aa].get()); + + fout.WriteTObject(mEffFakeEtasK[aa].get()); + fout.WriteTObject(mEffFakeEtasLam[aa].get()); + fout.WriteTObject(mEffFakeEtasIperT[aa].get()); + fout.WriteTObject(mEffGoodEtasK[aa].get()); + fout.WriteTObject(mEffGoodEtasLam[aa].get()); + fout.WriteTObject(mEffGoodEtasIperT[aa].get()); + fout.WriteTObject(mEffGoodEtas[aa].get()); + fout.WriteTObject(mEffFakeEtas[aa].get()); + for (int i = 0; i < 3; i++) { + fout.WriteTObject(histLength[aa][i], Form("trk_len_%d_%s", 4 + aa, tt[i])); + fout.WriteTObject(histLength1Fake[aa][i], Form("trk_len_%d_1f_%s", 4 + aa, tt[i])); + fout.WriteTObject(histLength2Fake[aa][i], Form("trk_len_%d_2f_%s", 4 + aa, tt[i])); + fout.WriteTObject(histLength3Fake[aa][i], Form("trk_len_%d_3f_%s", 4 + aa, tt[i])); + fout.WriteTObject(histLengthNoCl[aa][i], Form("trk_len_%d_nocl_%s", 4 + aa, tt[i])); + fout.WriteTObject(histLength1FakeNoCl[aa][i], Form("trk_len_%d_1f_nocl_%s", 4 + aa, tt[i])); + fout.WriteTObject(histLength2FakeNoCl[aa][i], Form("trk_len_%d_2f_nocl_%s", 4 + aa, tt[i])); + fout.WriteTObject(histLength3FakeNoCl[aa][i], Form("trk_len_%d_3f_nocl_%s", 4 + aa, tt[i])); + } } setHistoGraph(Histo[0], mDenominatorSecRad, "Decay_Radius_MC", ";Decay Radius ;Entries", kGray, 0.4); fout.WriteTObject(mDenominatorSecRad.get()); @@ -1054,21 +1214,23 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) setHistoGraph(Histo[8], mKClusterfake1D, "KClusterfake1D", "; of fake cluster ;Entries", kBlue, 1); fout.WriteTObject(mKClusterfake1D.get()); for (int y = 6; y < 9; y++) { - for (int i = 1; i <= 10; i++) { + for (int i = 1; i <= 14; i++) { Histo[y].GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); } } - for (int i = 1; i <= 10; i++) { - mIperTClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); - mLamClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); - mKClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); + for (int i = 1; i <= 14; i++) { + mIperTClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); + mLamClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); + mKClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); } - for(int i=1;i<=50;i++) - { - mIperTClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); - mLamClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); - mKClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); - } + for (int i = 1; i <= 50; i++) { + mIperTClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + mLamClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + mKClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + } + fout.WriteTObject(mIperTClusterfake.get()); + fout.WriteTObject(mLamClusterfake.get()); + fout.WriteTObject(mKClusterfake.get()); // Paint the histograms // todo: delegate to a dedicated helper @@ -1250,11 +1412,13 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) for (int iH{0}; iH < 4; ++iH) { canvas->cd(iH + 1); stackLength[iH]->Draw(); + stackLength[iH]->GetXaxis()->SetTitle("Layer"); gPad->BuildLegend(); } for (int iH{0}; iH < 4; ++iH) { canvas->cd(iH + 5); stackLength1Fake[iH]->Draw(); + stackLength1Fake[iH]->GetXaxis()->SetTitle("Layer"); gPad->BuildLegend(); } @@ -1266,16 +1430,18 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) for (int iH{0}; iH < 4; ++iH) { canvas2->cd(iH + 1); stackLength2Fake[iH]->Draw(); + stackLength2Fake[iH]->GetXaxis()->SetTitle("Layer"); gPad->BuildLegend(); } for (int iH{0}; iH < 4; ++iH) { canvas2->cd(iH + 5); stackLength3Fake[iH]->Draw(); + stackLength3Fake[iH]->GetXaxis()->SetTitle("Layer"); gPad->BuildLegend(); } canvas2->SaveAs("fakeClusters3.png", "recreate"); - auto canvasPtfake = new TCanvas("canvasPtfake", "Fake clusters", 1600, 1000); + auto canvasPtfake = new TCanvas("canvasPtfake", "Fake pt", 1600, 1000); canvasPtfake->Divide(2, 2); for (int iH{0}; iH < 4; ++iH) { @@ -1290,7 +1456,58 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) gPad->SetTitle(Form("#it{p}_{T}, Fake Tracks, layer %d", iH)); gPad->SetName(Form("#it{p}_{T}, Fake Tracks, layer %d", iH)); } - canvasPtfake->SaveAs("PtforPart1.png", "recreate"); + canvasPtfake->SaveAs("PtforPartFake.png", "recreate"); + + auto canvasPtGood = new TCanvas("canvasPtGood", "Good pt", 1600, 1000); + canvasPtGood->Divide(2, 2); + + for (int iH{0}; iH < 4; ++iH) { + canvasPtGood->cd(iH + 1); + mEffGoodPtsK[iH]->Draw(); + mEffGoodPtsLam[iH]->Draw("same"); + mEffGoodPtsIperT[iH]->Draw("same"); + mEffPt->Draw("same"); + mEffGoodPts[iH]->Draw("same"); + gPad->BuildLegend(); + gPad->SetGrid(); + gPad->SetTitle(Form("#it{p}_{T}, Good Tracks, layer %d", iH)); + gPad->SetName(Form("#it{p}_{T}, Good Tracks, layer %d", iH)); + } + canvasPtGood->SaveAs("PtforPartGood.png", "recreate"); + + auto canvasEtafake = new TCanvas("canvasEtafake", "Fake Eta", 1600, 1000); + canvasEtafake->Divide(2, 2); + + for (int iH{0}; iH < 4; ++iH) { + canvasEtafake->cd(iH + 1); + mEffFakeEtasK[iH]->Draw(); + mEffFakeEtasLam[iH]->Draw("same"); + mEffFakeEtasIperT[iH]->Draw("same"); + mEffFakeEta->Draw("same"); + mEffFakeEtas[iH]->Draw("same"); + gPad->BuildLegend(); + gPad->SetGrid(); + gPad->SetTitle(Form("#it{p}_{T}, Fake Tracks, layer %d", iH)); + gPad->SetName(Form("#it{p}_{T}, Fake Tracks, layer %d", iH)); + } + canvasEtafake->SaveAs("EtaforPartFake.png", "recreate"); + + auto canvasEtaGood = new TCanvas("canvasEtaGood", "Good Eta", 1600, 1000); + canvasEtaGood->Divide(2, 2); + + for (int iH{0}; iH < 4; ++iH) { + canvasEtaGood->cd(iH + 1); + mEffGoodEtasK[iH]->Draw(); + mEffGoodEtasLam[iH]->Draw("same"); + mEffGoodEtasIperT[iH]->Draw("same"); + mEffEta->Draw("same"); + mEffGoodEtas[iH]->Draw("same"); + gPad->BuildLegend(); + gPad->SetGrid(); + gPad->SetTitle(Form("#eta, Good Tracks, layer %d", iH)); + gPad->SetName(Form("#eta, Good Tracks, layer %d", iH)); + } + canvasEtaGood->SaveAs("EtaforPartGood.png", "recreate"); auto canvasClusterFake = new TCanvas("canvasClusterFake", "canvasClusterFake", 1600, 1000); canvasClusterFake->Divide(3, 1); @@ -1320,6 +1537,11 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mKClusterfake->Draw("COLZ"); canvasK->SaveAs("K2D.png", "recreate"); + auto canvaspdg = new TCanvas("canvaspdg", "canvaspdg", 1600, 1000); + canvaspdg->cd(); + Histo[9].Draw(); + canvaspdg->SaveAs("pdg.png", "recreate"); + fout.cd(); mCanvasPt->Write(); mCanvasEta->Write(); @@ -1337,6 +1559,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) canvasI->Write(); canvasL->Write(); canvasK->Write(); + canvaspdg->Write(); fout.Close(); } From 462d067f487de7d8809805923bbd64af6077e1c5 Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Mon, 11 Sep 2023 22:40:00 +0200 Subject: [PATCH 11/19] ITS-Study:Completed the study on secondary tracks and fake clusters, start study on Pt resolution --- .../postprocessing/studies/src/TrackCheck.cxx | 1097 +++++++---------- 1 file changed, 430 insertions(+), 667 deletions(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 6a7339b546bda..89310faa53102 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -90,10 +90,7 @@ class TrackCheckStudy : public Task void finaliseCCDB(ConcreteDataMatcher&, void*) final; void initialiseRun(o2::globaltracking::RecoContainer&); void process(); - void setEfficiencyGraph(std::unique_ptr&, const char*, const int, const double, const double, const int, const double); void setEfficiencyGraph(std::unique_ptr&, const char*, const char*, const int, const double, const double, const int, const double); - void setHistoGraph(TH1D&, std::unique_ptr&, const char*, const char*, const int, const double); - void NormalizeHistos(std::vector&); private: void updateTimeDependentParams(ProcessingContext& pc); @@ -121,9 +118,13 @@ class TrackCheckStudy : public Task // Histos std::unique_ptr mGoodPt; std::unique_ptr mGoodEta; + std::unique_ptr mGoodPtSec; + std::unique_ptr mGoodEtaSec; std::unique_ptr mGoodChi2; std::unique_ptr mFakePt; std::unique_ptr mFakeEta; + std::unique_ptr mFakePtSec; + std::unique_ptr mFakeEtaSec; std::unique_ptr mMultiFake; std::unique_ptr mFakeChi2; std::unique_ptr mClonePt; @@ -131,32 +132,14 @@ class TrackCheckStudy : public Task std::unique_ptr mDenominatorPt; std::unique_ptr mDenominatorEta; - std::unique_ptr mDenominatorSecRad; - std::unique_ptr mDenominatorSecZ; - - std::unique_ptr mGoodRad; // decay radius and z of sv for secondary particle - std::unique_ptr mFakeRad; - std::unique_ptr mGoodZ; - std::unique_ptr mFakeZ; - std::unique_ptr mRadk; // decay radius and z of sv for particle with mother k e lambda - std::unique_ptr mZk; - std::unique_ptr mRadLam; - std::unique_ptr mZLam; - std::unique_ptr mRadIperT; - std::unique_ptr mZIperT; - std::unique_ptr mGoodRadk; - std::unique_ptr mFakeRadk; - std::unique_ptr mGoodZk; - std::unique_ptr mFakeZk; - std::unique_ptr mGoodRadLam; - std::unique_ptr mFakeRadLam; - std::unique_ptr mGoodZLam; - std::unique_ptr mFakeZLam; - std::unique_ptr mGoodRadIperT; - std::unique_ptr mFakeRadIperT; - std::unique_ptr mGoodZIperT; - std::unique_ptr mFakeZIperT; - std::unique_ptr pdgcodeHisto; + std::unique_ptr mDenominatorPtSec; + std::unique_ptr mDenominatorEtaSec; + + std::unique_ptr processvsZ; // TH2D with production process + std::unique_ptr processvsRad; + std::unique_ptr processvsRadOther; + std::unique_ptr processvsRadNotTracked; + std::unique_ptr processvsEtaNotTracked; std::unique_ptr mEffPt; // Eff vs Pt primary std::unique_ptr mEffFakePt; @@ -165,52 +148,40 @@ class TrackCheckStudy : public Task std::unique_ptr mEffFakeEta; std::unique_ptr mEffClonesEta; - std::unique_ptr mEffRad; // Eff vs Radius secondary - std::unique_ptr mEffFakeRad; - std::unique_ptr mEffZ; // Eff vs Z of sv secondary - std::unique_ptr mEffFakeZ; - - std::unique_ptr mEffRadk; // Eff vs Z of sv and decay radius secondary for particle with mother k0s, IperTbda,iperT - std::unique_ptr mEffFakeRadk; - std::unique_ptr mEffZk; - std::unique_ptr mEffFakeZk; - std::unique_ptr mEffRadLam; - std::unique_ptr mEffFakeRadLam; - std::unique_ptr mEffZLam; - std::unique_ptr mEffFakeZLam; - std::unique_ptr mEffRadIperT; - std::unique_ptr mEffFakeRadIperT; - std::unique_ptr mEffZIperT; - std::unique_ptr mEffFakeZIperT; - + std::unique_ptr mEffPtSec; // Eff vs Pt secondary + std::unique_ptr mEffFakePtSec; + std::unique_ptr mEffEtaSec; // Eff vs Eta secondary + std::unique_ptr mEffFakeEtaSec; + std::unique_ptr mPtResolution; // Pt resolution for both primary and secondary std::unique_ptr mPtResolution2D; std::unique_ptr mPtResolutionSec; std::unique_ptr mPtResolutionPrim; std::unique_ptr g1; - std::unique_ptr mIperTClusterfake; - std::unique_ptr mKClusterfake; - std::unique_ptr mLamClusterfake; - std::unique_ptr mIperTClusterfake1D; - std::unique_ptr mKClusterfake1D; - std::unique_ptr mLamClusterfake1D; - const char* ParticleName[14] = {"e^{+}", "e^{-}", "#pi^{-}", "#pi^{+}", "p", "p^{-}", "^{2}H", "^{2}H^{-}", "^{3}He", "^{3}He^{-}", "_{#Lambda}^{3}H", "_{#Lambda}^{3}H^{-}", "k^{+}", "k^{-}"}; - const char* tt[3] = {"_{#Lambda}^{3}H", "#Lambda", "k^{0}_{s}"}; + const char* ParticleName[7] = {"e^{-/+}", "#pi^{-/+}", "p", "^{2}H", "^{3}He", "_{#Lambda}^{3}H", "k^{+/-}"}; + const int PdgcodeClusterFake[7] = {11, 211, 2212, 1000010020, 100002030, 1010010030, 321}; + const char* name[3] = {"_{#Lambda}^{3}H", "#Lambda", "k^{0}_{s}"}; + const char* particleToanalize[4] = {"IperT", "Lambda", "k0s", "Tot"}; // [3]=Total of secondary particle + const int PDG[3] = {1010010030, 3122, 310}; const char* ProcessName[50]; + int colorArr[4] = {kGreen, kRed, kBlue, kOrange}; std::vector> histLength, histLength1Fake, histLength2Fake, histLength3Fake, histLengthNoCl, histLength1FakeNoCl, histLength2FakeNoCl, histLength3FakeNoCl; // FakeCluster Study std::vector stackLength, stackLength1Fake, stackLength2Fake, stackLength3Fake; std::vector legends, legends1Fake, legends2Fake, legends3Fake; - std::vector> mGoodPts, mFakePts, mTotPts, mGoodPtsK, mFakePtsK, mTotPtsK, mGoodPtsLam, mFakePtsLam, mTotPtsLam, mGoodPtsIperT, mFakePtsIperT, mTotPtsIperT; - std::vector> mEffGoodPts, mEffFakePts, mEffGoodPtsK, mEffFakePtsK, mEffGoodPtsLam, mEffFakePtsLam, mEffGoodPtsIperT, mEffFakePtsIperT; - std::vector> mGoodEtas, mTotEtas, mFakeEtas, mGoodEtasK, mFakeEtasK, mTotEtasK, mGoodEtasLam, mFakeEtasLam, mTotEtasLam, mGoodEtasIperT, mFakeEtasIperT, mTotEtasIperT; - std::vector> mEffGoodEtas, mEffFakeEtas, mEffGoodEtasK, mEffFakeEtasK, mEffGoodEtasLam, mEffFakeEtasLam, mEffGoodEtasIperT, mEffFakeEtasIperT; - // Canvas & decorations + std::vector> mClusterFake; + std::vector>> mGoodPts, mFakePts, mTotPts, mGoodEtas, mTotEtas, mFakeEtas; + std::vector>> mEffGoodPts, mEffFakePts, mEffGoodEtas, mEffFakeEtas; + std::vector> mGoodRad, mFakeRad, mTotRad, mGoodZ, mFakeZ, mTotZ; + std::vector> mEffGoodRad, mEffFakeRad, mEffGoodZ, mEffFakeZ; + // Canvas & decorations std::unique_ptr mCanvasPt; + std::unique_ptr mCanvasPtSec; std::unique_ptr mCanvasPt2; std::unique_ptr mCanvasPt2fake; std::unique_ptr mCanvasEta; + std::unique_ptr mCanvasEtaSec; std::unique_ptr mCanvasRad; std::unique_ptr mCanvasZ; std::unique_ptr mCanvasRadD; @@ -221,6 +192,8 @@ class TrackCheckStudy : public Task std::unique_ptr mCanvasPtRes4; std::unique_ptr mLegendPt; std::unique_ptr mLegendEta; + std::unique_ptr mLegendPtSec; + std::unique_ptr mLegendEtaSec; std::unique_ptr mLegendPtRes; std::unique_ptr mLegendPtRes2; std::unique_ptr mLegendZ; @@ -229,7 +202,7 @@ class TrackCheckStudy : public Task std::unique_ptr mLegendRadD; std::vector Histo; - float rLayer0 = 2.34; + float rLayer0 = 2.34; // middle radius float rLayer1 = 3.15; float rLayer2 = 3.93; float rLayer3 = 19.605; @@ -243,16 +216,6 @@ class TrackCheckStudy : public Task std::unique_ptr mDBGOut; }; -void TrackCheckStudy::NormalizeHistos(std::vector& Histo) -{ - int nHist = Histo.size(); - for (int jh = 0; jh < nHist; jh++) { - double tot = Histo[jh].Integral(); - if (tot > 0) - Histo[jh].Scale(1. / tot); - } -} - void TrackCheckStudy::init(InitContext& ic) { o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest); @@ -267,32 +230,21 @@ void TrackCheckStudy::init(InitContext& ic) for (int i{0}; i <= pars.effHistBins; i++) { xbins[i] = pars.effPtCutLow * std::exp(i * a); } + for (int yy = 0; yy < 50; yy++) { + ProcessName[yy] = " "; + } mGoodPt = std::make_unique("goodPt", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); mGoodEta = std::make_unique("goodEta", ";#eta;Number of tracks", 60, -3, 3); + mGoodPtSec = std::make_unique("goodPtSec", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mGoodEtaSec = std::make_unique("goodEtaSec", ";#eta;Number of tracks", 60, -3, 3); mGoodChi2 = std::make_unique("goodChi2", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", 200, 0, 100); - mGoodRad = std::make_unique("goodRad", ";#Radius [cm];Number of tracks", 100, 0, 25); - mGoodZ = std::make_unique("goodZ", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); - mGoodRadk = std::make_unique("goodRadk", ";#Radius [cm];Number of tracks", 100, 0, 25); - mGoodZk = std::make_unique("goodZk", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); - mGoodRadLam = std::make_unique("goodRadLam", ";#Radius [cm];Number of tracks", 100, 0, 25); - mGoodZLam = std::make_unique("goodZLam", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); - mGoodRadIperT = std::make_unique("goodRadiperT", ";#Radius [cm];Number of tracks", 100, 0, 25); - mGoodZIperT = std::make_unique("goodZiperT", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); - mFakePt = std::make_unique("fakePt", ";#it{p}_{T} (GeV/#it{c});Fak", pars.effHistBins, xbins.data()); mFakeEta = std::make_unique("fakeEta", ";#eta;Number of tracks", 60, -3, 3); + mFakePtSec = std::make_unique("fakePtSec", ";#it{p}_{T} (GeV/#it{c});Fak", pars.effHistBins, xbins.data()); + mFakeEtaSec = std::make_unique("fakeEtaSec", ";#eta;Number of tracks", 60, -3, 3); mFakeChi2 = std::make_unique("fakeChi2", ";#it{p}_{T} (GeV/#it{c});Fak", 200, 0, 100); - mFakeRad = std::make_unique("fakeRad", ";#Radius [cm];Number of tracks", 100, 0, 25); - mFakeZ = std::make_unique("fakeZ", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); - mFakeRadk = std::make_unique("fakeRadK", ";#Radius [cm];Number of tracks", 100, 0, 25); - mFakeZk = std::make_unique("fakeZk", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); - mFakeRadLam = std::make_unique("fakeRadLam", ";#Radius [cm];Number of tracks", 100, 0, 25); - mFakeZLam = std::make_unique("fakeZLam", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); - mFakeRadIperT = std::make_unique("fakeRadIperT", ";#Radius [cm];Number of tracks", 100, 0, 25); - mFakeZIperT = std::make_unique("fakeZIperT", ";#z of secondary vertex [cm];Number of tracks", 100, -50, 50); - mMultiFake = std::make_unique("multiFake", ";#it{p}_{T} (GeV/#it{c});Fak", pars.effHistBins, xbins.data()); mClonePt = std::make_unique("clonePt", ";#it{p}_{T} (GeV/#it{c});Clone", pars.effHistBins, xbins.data()); @@ -300,116 +252,71 @@ void TrackCheckStudy::init(InitContext& ic) mDenominatorPt = std::make_unique("denominatorPt", ";#it{p}_{T} (GeV/#it{c});Den", pars.effHistBins, xbins.data()); mDenominatorEta = std::make_unique("denominatorEta", ";#eta;Number of tracks", 60, -3, 3); - mDenominatorSecRad = std::make_unique("denominatorSecRad", ";Radius [cm];Number of tracks", 100, 0, 25); - mDenominatorSecZ = std::make_unique("denominatorSecZ", ";z of secondary vertex [cm];Number of tracks", 100, -50, 50); - - mIperTClusterfake1D = std::make_unique("IperTClusterfake1D", ";particle generating fake cluster;Entries", 14, 0., 14.); - mKClusterfake1D = std::make_unique("KClusterfake1D", ";particle generating fake cluster;Entries", 14, 0., 14.); - mLamClusterfake1D = std::make_unique("LamClusterfake1D", ";particle generating fake cluster;Entries", 14, 0., 14.); - mIperTClusterfake = std::make_unique("IperT_Clusters_fake", ";particle generating fake cluster; production process", 14, 0., 14., 50, 0, 50); - mKClusterfake = std::make_unique("K0s_Clusters_fake", ";particle generating fake cluster; production process", 14, 0., 14., 50, 0, 50); - mLamClusterfake = std::make_unique("#Lambda_Clusters_fake", ";particle generating fake cluster; production process", 14, 0., 14., 50, 0, 50); - - mRadk = std::make_unique("mRadk", ";Radius [cm];Number of tracks", 100, 0, 25); - mRadLam = std::make_unique("mRadLam", ";Radius [cm];Number of tracks", 100, 0, 25); - mZk = std::make_unique("mZk", ";z of secondary vertex [cm]", 100, -50, 50); - mZLam = std::make_unique("mZLam", ";z of secondary vertex [cm]", 100, -50, 50); - mRadIperT = std::make_unique("mRadIperT", ";Radius [cm];Number of tracks", 100, 0, 25); - mZIperT = std::make_unique("mZIperT", ";z of secondary vertex [cm]", 100, -50, 50); - pdgcodeHisto = std::make_unique("pdgcodeHisto", ";pdgcode of mother particle", 4000, 0, 4000); + mDenominatorPtSec = std::make_unique("denominatorPtSec", ";#it{p}_{T} (GeV/#it{c});Den", pars.effHistBins, xbins.data()); + mDenominatorEtaSec = std::make_unique("denominatorEtaSec", ";#eta;Number of tracks", 60, -3, 3); + + processvsZ = std::make_unique("Process", ";z_{SV} [cm]; production process", 100, -50, 50., 50, 0, 50); + processvsRad = std::make_unique("ProcessR", ";decay radius [cm]; production process", 100, 0, 25., 50, 0, 50); + processvsRadOther = std::make_unique("ProcessRO", ";decay radius [cm]; production process", 200, 0, 25., 50, 0, 50); + processvsRadNotTracked = std::make_unique("ProcessRNoT", ";decay radius [cm]; production process", 200, 0, 25., 50, 0, 50); + processvsEtaNotTracked = std::make_unique("ProcessENoT", ";#eta; production process", 60, -3, 3, 50, 0, 50); + mGoodPts.resize(4); mFakePts.resize(4); mTotPts.resize(4); mGoodEtas.resize(4); mFakeEtas.resize(4); mTotEtas.resize(4); - mGoodPtsK.resize(4); - mFakePtsK.resize(4); - mTotPtsK.resize(4); - mGoodPtsLam.resize(4); - mFakePtsLam.resize(4); - mTotPtsLam.resize(4); - mGoodPtsIperT.resize(4); - mFakePtsIperT.resize(4); - mTotPtsIperT.resize(4); - mGoodEtasK.resize(4); - mFakeEtasK.resize(4); - mTotEtasK.resize(4); - mGoodEtasLam.resize(4); - mFakeEtasLam.resize(4); - mTotEtasLam.resize(4); - mGoodEtasIperT.resize(4); - mFakeEtasIperT.resize(4); - mTotEtasIperT.resize(4); - mEffGoodPts.resize(4); - mEffFakePts.resize(4); - mEffGoodEtas.resize(4); - mEffFakeEtas.resize(4); - mEffGoodPtsK.resize(4); - mEffFakePtsK.resize(4); - mEffGoodPtsLam.resize(4); - mEffFakePtsLam.resize(4); - mEffGoodPtsIperT.resize(4); - mEffFakePtsIperT.resize(4); - mEffGoodEtasK.resize(4); - mEffFakeEtasK.resize(4); - mEffGoodEtasLam.resize(4); - mEffFakeEtasLam.resize(4); - mEffGoodEtasIperT.resize(4); - mEffFakeEtasIperT.resize(4); - for (int yy = 0; yy < 4; yy++) { // divided by layer - mGoodPts[yy] = std::make_unique(Form("goodPts%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mFakePts[yy] = std::make_unique(Form("FakePs%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mTotPts[yy] = std::make_unique(Form("TotPts%d", yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - - mGoodEtas[yy] = std::make_unique(Form("goodEtas%d", yy), ";#eta;Number of tracks", 60, -3, 3); - mFakeEtas[yy] = std::make_unique(Form("FakeEtas%d", yy), ";#eta;Number of tracks", 60, -3, 3); - mTotEtas[yy] = std::make_unique(Form("TotEtas%d", yy), ";#eta;Number of tracks", 60, -3, 3); - - mGoodPtsK[yy] = std::make_unique(Form("goodPtK%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mFakePtsK[yy] = std::make_unique(Form("FakePtK%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mTotPtsK[yy] = std::make_unique(Form("TotPtK%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mGoodPtsLam[yy] = std::make_unique(Form("goodPtLam%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mFakePtsLam[yy] = std::make_unique(Form("FakePtLam%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mTotPtsLam[yy] = std::make_unique(Form("TotPtLam%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mGoodPtsIperT[yy] = std::make_unique(Form("goodPtIperT%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mFakePtsIperT[yy] = std::make_unique(Form("FakePtIperT%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - mTotPtsIperT[yy] = std::make_unique(Form("TotPtIperT%d", yy), ";#eta;Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); - - mGoodEtasK[yy] = std::make_unique(Form("goodEtaK%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); - mFakeEtasK[yy] = std::make_unique(Form("FakeEtaK%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); - mTotEtasK[yy] = std::make_unique(Form("TotEtaK%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); - mGoodEtasLam[yy] = std::make_unique(Form("goodEtaLam%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); - mFakeEtasLam[yy] = std::make_unique(Form("FakeEtaLam%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); - mTotEtasLam[yy] = std::make_unique(Form("TotEtaLam%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); - mGoodEtasIperT[yy] = std::make_unique(Form("goodEtaIperT%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); - mFakeEtasIperT[yy] = std::make_unique(Form("FakeEtaIperT%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); - mTotEtasIperT[yy] = std::make_unique(Form("TotEtaIperT%d", yy), ";#eta;Efficiency (fake-track rate)", 60, -3, 3); - - mGoodPts[yy]->Sumw2(); - mFakePts[yy]->Sumw2(); - mTotPts[yy]->Sumw2(); - mGoodEtas[yy]->Sumw2(); - mFakeEtas[yy]->Sumw2(); - mTotEtas[yy]->Sumw2(); - mGoodPtsK[yy]->Sumw2(); - mFakePtsK[yy]->Sumw2(); - mTotPtsK[yy]->Sumw2(); - mGoodPtsLam[yy]->Sumw2(); - mFakePtsLam[yy]->Sumw2(); - mTotPtsLam[yy]->Sumw2(); - mGoodPtsIperT[yy]->Sumw2(); - mFakePtsIperT[yy]->Sumw2(); - mTotPtsIperT[yy]->Sumw2(); - mGoodEtasK[yy]->Sumw2(); - mFakeEtasK[yy]->Sumw2(); - mTotEtasK[yy]->Sumw2(); - mGoodEtasLam[yy]->Sumw2(); - mFakeEtasLam[yy]->Sumw2(); - mTotEtasLam[yy]->Sumw2(); - mGoodEtasIperT[yy]->Sumw2(); - mFakeEtasIperT[yy]->Sumw2(); - mTotEtasIperT[yy]->Sumw2(); + mGoodRad.resize(4); + mFakeRad.resize(4); + mTotRad.resize(4); + mGoodZ.resize(4); + mFakeZ.resize(4); + mTotZ.resize(4); + mClusterFake.resize(4); + for (int i = 0; i < 4; i++) { + mGoodPts[i].resize(4); + mFakePts[i].resize(4); + mTotPts[i].resize(4); + mGoodEtas[i].resize(4); + mFakeEtas[i].resize(4); + mTotEtas[i].resize(4); + } + + for (int ii = 0; ii < 4; ii++) { + + mGoodRad[ii] = std::make_unique(Form("goodRad_%s", particleToanalize[ii]), ";z_{SV} [cm];Number of tracks", 100, 0., 20.); + mFakeRad[ii] = std::make_unique(Form("FakeRad_%s", particleToanalize[ii]), ";#eta;Number of tracks", 100, 0., 20.); + mTotRad[ii] = std::make_unique(Form("TotRad_%s", particleToanalize[ii]), ";#eta;Number of tracks", 100, 0., 20.); + + mGoodZ[ii] = std::make_unique(Form("goodZ_%s", particleToanalize[ii]), ";z_{SV} [cm];Number of tracks", 100, -50., 50.); + mFakeZ[ii] = std::make_unique(Form("FakeZ_%s", particleToanalize[ii]), ";z_{SV} [cm];Number of tracks", 100, -50., 50.); + mTotZ[ii] = std::make_unique(Form("TotZ_%s", particleToanalize[ii]), ";z_{SV} [cm];Number of tracks", 100, -50., 50.); + mClusterFake[ii] = std::make_unique(Form("Clusters_fake_%s", ParticleName[ii]), ";particle generating fake cluster; production process", 7, 0., 7., 50, 0, 50); + + mGoodRad[ii]->Sumw2(); + mFakeRad[ii]->Sumw2(); + mTotRad[ii]->Sumw2(); + mGoodZ[ii]->Sumw2(); + mFakeZ[ii]->Sumw2(); + mTotZ[ii]->Sumw2(); + + for (int yy = 0; yy < 4; yy++) { // divided by layer + mGoodPts[ii][yy] = std::make_unique(Form("goodPts_%s_%d", particleToanalize[ii], yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mFakePts[ii][yy] = std::make_unique(Form("FakePts_%s_%d", particleToanalize[ii], yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + mTotPts[ii][yy] = std::make_unique(Form("TotPts_%s_%d", particleToanalize[ii], yy), ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", pars.effHistBins, xbins.data()); + + mGoodEtas[ii][yy] = std::make_unique(Form("goodEtas_%s_%d", particleToanalize[ii], yy), ";#eta;Number of tracks", 60, -3, 3); + mFakeEtas[ii][yy] = std::make_unique(Form("FakeEtas_%s_%d", particleToanalize[ii], yy), ";#eta;Number of tracks", 60, -3, 3); + mTotEtas[ii][yy] = std::make_unique(Form("TotEtas_%s_%d", particleToanalize[ii], yy), ";#eta;Number of tracks", 60, -3, 3); + + mGoodPts[ii][yy]->Sumw2(); + mFakePts[ii][yy]->Sumw2(); + mTotPts[ii][yy]->Sumw2(); + mGoodEtas[ii][yy]->Sumw2(); + mFakeEtas[ii][yy]->Sumw2(); + mTotEtas[ii][yy]->Sumw2(); + } } mPtResolution = std::make_unique("PtResolution", ";#it{p}_{T} ;Den", 100, -1, 1); @@ -421,35 +328,17 @@ void TrackCheckStudy::init(InitContext& ic) mPtResolutionSec->Sumw2(); mPtResolutionPrim->Sumw2(); - mRadk->Sumw2(); - mRadLam->Sumw2(); - mZk->Sumw2(); - mZLam->Sumw2(); - mGoodPt->Sumw2(); mGoodEta->Sumw2(); - mGoodRad->Sumw2(); - mGoodZ->Sumw2(); - mGoodRadk->Sumw2(); - mGoodZk->Sumw2(); - mGoodRadIperT->Sumw2(); - mGoodZIperT->Sumw2(); - mGoodRadLam->Sumw2(); - mGoodZLam->Sumw2(); - mFakeRadk->Sumw2(); - mFakeZk->Sumw2(); - mFakeRadIperT->Sumw2(); - mFakeZIperT->Sumw2(); - mFakeRadLam->Sumw2(); - mFakeZLam->Sumw2(); + mGoodPtSec->Sumw2(); + mGoodEtaSec->Sumw2(); + mFakePt->Sumw2(); - mFakeRad->Sumw2(); - mFakeZ->Sumw2(); + mFakePtSec->Sumw2(); + mFakeEta->Sumw2(); mMultiFake->Sumw2(); mClonePt->Sumw2(); mDenominatorPt->Sumw2(); - mDenominatorSecRad->Sumw2(); - mDenominatorSecZ->Sumw2(); histLength.resize(4); // fake clusters study histLength1Fake.resize(4); @@ -477,13 +366,15 @@ void TrackCheckStudy::init(InitContext& ic) legends1Fake.resize(4); legends2Fake.resize(4); legends3Fake.resize(4); - int colorArr[3] = {kGreen, kRed, kBlue}; - for (int iH{4}; iH < 8; ++iH) { + + for (int iH{4}; iH < 8; ++iH) { + // check distributions on layers of fake clusters for tracks of different lengths. + // Different histograms if the correct cluster exist or not for (int jj = 0; jj < 3; jj++) { - histLength[iH - 4][jj] = new TH1I(Form("trk_len_%d_%s", iH, tt[jj]), Form("#exists cluster %s", tt), 7, -.5, 6.5); + histLength[iH - 4][jj] = new TH1I(Form("trk_len_%d_%s", iH, name[jj]), Form("#exists cluster %s", name), 7, -.5, 6.5); histLength[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); histLength[iH - 4][jj]->SetLineColor(colorArr[jj] - 9); - histLengthNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_nocl_%s", iH, tt[jj]), Form("#slash{#exists} cluster %s", tt), 7, -.5, 6.5); + histLengthNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_nocl_%s", iH, name[jj]), Form("#slash{#exists} cluster %s", name), 7, -.5, 6.5); histLengthNoCl[iH - 4][jj]->SetFillColor(colorArr[jj] + 1); histLengthNoCl[iH - 4][jj]->SetLineColor(colorArr[jj] + 1); if (jj == 0) @@ -491,10 +382,10 @@ void TrackCheckStudy::init(InitContext& ic) stackLength[iH - 4]->Add(histLength[iH - 4][jj]); stackLength[iH - 4]->Add(histLengthNoCl[iH - 4][jj]); - histLength1Fake[iH - 4][jj] = new TH1I(Form("trk_len_%d_1f_%s", iH, tt[jj]), Form("#exists cluster %s", tt[jj]), 7, -.5, 6.5); + histLength1Fake[iH - 4][jj] = new TH1I(Form("trk_len_%d_1f_%s", iH, name[jj]), Form("#exists cluster %s", name[jj]), 7, -.5, 6.5); histLength1Fake[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); histLength1Fake[iH - 4][jj]->SetLineColor(colorArr[jj] - 9); - histLength1FakeNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_1f_nocl_%s", iH, tt[jj]), Form("#slash{#exists} cluster %s", tt[jj]), 7, -.5, 6.5); + histLength1FakeNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_1f_nocl_%s", iH, name[jj]), Form("#slash{#exists} cluster %s", name[jj]), 7, -.5, 6.5); histLength1FakeNoCl[iH - 4][jj]->SetFillColor(colorArr[jj] + 1); histLength1FakeNoCl[iH - 4][jj]->SetLineColor(colorArr[jj] + 1); if (jj == 0) @@ -502,10 +393,10 @@ void TrackCheckStudy::init(InitContext& ic) stackLength1Fake[iH - 4]->Add(histLength1Fake[iH - 4][jj]); stackLength1Fake[iH - 4]->Add(histLength1FakeNoCl[iH - 4][jj]); - histLength2Fake[iH - 4][jj] = new TH1I(Form("trk_len_%d_2f_%s", iH, tt[jj]), Form("#exists cluster %s", tt[jj]), 7, -.5, 6.5); + histLength2Fake[iH - 4][jj] = new TH1I(Form("trk_len_%d_2f_%s", iH, name[jj]), Form("#exists cluster %s", name[jj]), 7, -.5, 6.5); histLength2Fake[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); histLength2Fake[iH - 4][jj]->SetLineColor(colorArr[jj] - 9); - histLength2FakeNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_2f_nocl_%s", iH, tt[jj]), Form("#slash{#exists} cluster %s", tt[jj]), 7, -.5, 6.5); + histLength2FakeNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_2f_nocl_%s", iH, name[jj]), Form("#slash{#exists} cluster %s", name[jj]), 7, -.5, 6.5); histLength2FakeNoCl[iH - 4][jj]->SetFillColor(colorArr[jj] + 1); histLength2FakeNoCl[iH - 4][jj]->SetLineColor(colorArr[jj] + 1); if (jj == 0) @@ -513,11 +404,11 @@ void TrackCheckStudy::init(InitContext& ic) stackLength2Fake[iH - 4]->Add(histLength2Fake[iH - 4][jj]); stackLength2Fake[iH - 4]->Add(histLength2FakeNoCl[iH - 4][jj]); - histLength3Fake[iH - 4][jj] = new TH1I(Form("trk_len_%d_3f_%s", iH, tt[jj]), Form("#exists cluster %s", tt[jj]), 7, -.5, 6.5); + histLength3Fake[iH - 4][jj] = new TH1I(Form("trk_len_%d_3f_%s", iH, name[jj]), Form("#exists cluster %s", name[jj]), 7, -.5, 6.5); histLength3Fake[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); histLength3Fake[iH - 4][jj]->SetLineColor(colorArr[jj] - 9); - histLength3FakeNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_3f_nocl_%s", iH, tt[jj]), Form("#slash{#exists} cluster %s", tt[jj]), 7, -.5, 6.5); + histLength3FakeNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_3f_nocl_%s", iH, name[jj]), Form("#slash{#exists} cluster %s", name[jj]), 7, -.5, 6.5); histLength3FakeNoCl[iH - 4][jj]->SetFillColor(colorArr[jj] + 1); histLength3FakeNoCl[iH - 4][jj]->SetLineColor(colorArr[jj] + 1); if (jj == 0) @@ -597,16 +488,13 @@ void TrackCheckStudy::process() LOGP(info, "** Analysing tracks ... "); int unaccounted{0}, good{0}, fakes{0}, total{0}; // ***secondary tracks*** - int nPartForSpec[4][4]; // total number [particle 0=IperT 1=Lambda 2=k][n layer] - int nPartGoodorFake[4][4][2]; // number of good or fake [particle 0=IperT 1=Lambda 2=k][n layer][n layer][good=1 fake=0] - for(int n=0;n<4;n++) - { - for(int m=0;m<4;m++) - { - nPartForSpec[n][m]=0; - for(int h=0;h<2;h++) - { - nPartGoodorFake[n][m][h]=0; + int nPartForSpec[4][4]; // total number [particle 0=IperT, 1=Lambda, 2=k, 3=Other][n layer] + int nPartGoodorFake[4][4][2]; // number of good or fake [particle 0=IperT, 1=Lambda, 2=k, 3=Other][n layer][good=1 fake=0] + for (int n = 0; n < 4; n++) { + for (int m = 0; m < 4; m++) { + nPartForSpec[n][m] = 0; + for (int h = 0; h < 2; h++) { + nPartGoodorFake[n][m][h] = 0; } } } @@ -649,15 +537,14 @@ void TrackCheckStudy::process() LOGP(info, "** Filling histograms ... "); int evID = 0; int trackID = 0; - - for (int yy = 0; yy < 50; yy++) { - ProcessName[yy] = " "; - } + int totP{0}, goodP{0}, fakeP{0}; // Currently process only sourceID = 0, to be extended later if needed for (auto& evInfo : mParticleInfo[0]) { trackID = 0; for (auto& part : evInfo) { + if (ProcessName[part.prodProcess] == " ") + ProcessName[part.prodProcess] = part.prodProcessName; if ((part.clusters & 0x7f) == mMask) { // part.clusters != 0x3f && part.clusters != 0x3f << 1 && // part.clusters != 0x1f && part.clusters != 0x1f << 1 && part.clusters != 0x1f << 2 && @@ -665,11 +552,13 @@ void TrackCheckStudy::process() // continue; if (part.isPrimary) { // **Primary particle** + totP++; mDenominatorPt->Fill(part.pt); mDenominatorEta->Fill(part.eta); if (part.isReco) { mGoodPt->Fill(part.pt); mGoodEta->Fill(part.eta); + goodP++; if (part.isReco > 1) { for (int _i{0}; _i < part.isReco - 1; ++_i) { mClonePt->Fill(part.pt); @@ -680,6 +569,7 @@ void TrackCheckStudy::process() if (part.isFake) { mFakePt->Fill(part.pt); mFakeEta->Fill(part.eta); + fakeP++; if (part.isFake > 1) { for (int _i{0}; _i < part.isFake - 1; ++_i) { mMultiFake->Fill(part.pt); @@ -693,12 +583,12 @@ void TrackCheckStudy::process() nlayer = 999; ngoodfake = 2; if (!part.isPrimary) { - int TrackID, EvID, SrcID; int pdgcode = mParticleInfo[0][evID][part.mother].pdg; - int idxPart = 4; + int idxPart = 999; float rad = sqrt(pow(part.vx, 2) + pow(part.vy, 2)); totsec++; + if ((rad < rLayer0) && (part.clusters == 0x7f || part.clusters == 0x3f || part.clusters == 0x1f || part.clusters == 0x0f)) // layer 0 nlayer = 0; if (rad < rLayer1 && rad > rLayer0 && (part.clusters == 0x1e || part.clusters == 0x3e || part.clusters == 0x7e)) // layer 1 @@ -707,85 +597,77 @@ void TrackCheckStudy::process() nlayer = 2; if (rad < rLayer3 && rad > rLayer2 && part.clusters == 0x78) // layer 3 nlayer = 3; - if (nlayer == 0 || nlayer == 1 || nlayer == 2 || nlayer == 3) { + if (nlayer == 0 || nlayer == 1 || nlayer == 2 || nlayer == 3) { // check if track is trackeable + totsecCont++; - mDenominatorSecRad->Fill(rad); - mDenominatorSecZ->Fill(part.vz); - mTotPts[nlayer]->Fill(part.pt); - mTotEtas[nlayer]->Fill(part.eta); + processvsZ->Fill(part.vz, part.prodProcess); + processvsRad->Fill(rad, part.prodProcess); + mDenominatorPtSec->Fill(part.pt); + mDenominatorEtaSec->Fill(part.eta); + mTotRad[3]->Fill(rad); + mTotZ[3]->Fill(part.vz); + mTotPts[nlayer][3]->Fill(part.pt); + mTotEtas[nlayer][3]->Fill(part.eta); + mTotPts[nlayer][3]->Fill(part.pt); + mTotEtas[nlayer][3]->Fill(part.eta); + if (pdgcode == PDG[0] || pdgcode == -1 * PDG[0]) + idxPart = 0; // IperT + if (pdgcode == PDG[1] || pdgcode == -1 * PDG[1]) + idxPart = 1; // Lambda + if (pdgcode == PDG[2] || pdgcode == -1 * PDG[2]) + idxPart = 2; // K0s if (part.isReco) { ngoodfake = 1; - mGoodPts[nlayer]->Fill(part.pt); - mGoodEtas[nlayer]->Fill(part.eta); + mGoodPts[3][nlayer]->Fill(part.pt); + mGoodEtas[3][nlayer]->Fill(part.eta); + mGoodPtSec->Fill(part.pt); + mGoodEtaSec->Fill(part.eta); + mGoodRad[3]->Fill(rad); + mGoodZ[3]->Fill(part.vz); } if (part.isFake) { ngoodfake = 0; - mFakePts[nlayer]->Fill(part.pt); - mFakeEtas[nlayer]->Fill(part.eta); + mFakePts[3][nlayer]->Fill(part.pt); + mFakeEtas[3][nlayer]->Fill(part.eta); + mFakePtSec->Fill(part.pt); + mFakeEtaSec->Fill(part.eta); + mFakeRad[3]->Fill(rad); + mFakeZ[3]->Fill(part.vz); } - if (pdgcode == 310 ||pdgcode == -310 ) // mother particle = k0s or anti k0s + if (idxPart < 3) // to change if the number of analysing particle changes { - idxPart = 2; - mRadk->Fill(rad); - mZk->Fill(part.vz); - mTotPtsK[nlayer]->Fill(part.pt); - mTotEtasK[nlayer]->Fill(part.eta); + mTotRad[idxPart]->Fill(rad); + mTotZ[idxPart]->Fill(part.vz); + mTotPts[idxPart][nlayer]->Fill(part.pt); + mTotEtas[idxPart][nlayer]->Fill(part.eta); if (part.isReco) { - mGoodRadk->Fill(rad); - mGoodZk->Fill(part.vz); - mGoodPtsK[nlayer]->Fill(part.pt); - mGoodEtasK[nlayer]->Fill(part.eta); + mGoodRad[idxPart]->Fill(rad); + mGoodZ[idxPart]->Fill(part.vz); + mGoodPts[idxPart][nlayer]->Fill(part.pt); + mGoodEtas[idxPart][nlayer]->Fill(part.eta); } if (part.isFake) { - mFakeRadk->Fill(rad); - mFakeZk->Fill(part.vz); - mFakePtsK[nlayer]->Fill(part.pt); - mFakeEtasK[nlayer]->Fill(part.eta); + mFakeRad[idxPart]->Fill(rad); + mFakeZ[idxPart]->Fill(part.vz); + mFakePts[idxPart][nlayer]->Fill(part.pt); + mFakeEtas[idxPart][nlayer]->Fill(part.eta); } } - if (pdgcode == 3122 || pdgcode == -3122 ) // mother particle = Lambda or anti Lambda - { - idxPart = 1; - mRadLam->Fill(rad); - mZLam->Fill(part.vz); - mTotPtsLam[nlayer]->Fill(part.pt); - mTotEtasLam[nlayer]->Fill(part.eta); - if (part.isReco) { - mGoodRadLam->Fill(rad); - mGoodZLam->Fill(part.vz); - mGoodPtsLam[nlayer]->Fill(part.pt); - mGoodEtasLam[nlayer]->Fill(part.eta); - } - if (part.isFake) { - mFakeRadLam->Fill(rad); - mFakeZLam->Fill(part.vz); - mFakePtsLam[nlayer]->Fill(part.pt); - mFakeEtasLam[nlayer]->Fill(part.eta); - } - } - if (pdgcode == 1010010030 ||pdgcode == -1010010030 ) // mother particle = IperT or anti IperT - { - idxPart = 0; - mTotPtsIperT[nlayer]->Fill(part.pt); - mTotEtasIperT[nlayer]->Fill(part.eta); - if (part.isReco) { - mGoodPtsIperT[nlayer]->Fill(part.pt); - mGoodEtasIperT[nlayer]->Fill(part.eta); - } - if (part.isFake) { - mFakePtsIperT[nlayer]->Fill(part.pt); - mFakeEtasIperT[nlayer]->Fill(part.eta); - } - } - if (pdgcode != 1010010030 && pdgcode != 3122 && pdgcode != 310 && pdgcode != -1010010030) { + + if (pdgcode != 1010010030 && pdgcode != 3122 && pdgcode != 310 && pdgcode != -1010010030 && pdgcode != -310 && pdgcode != -3122) { idxPart = 3; - pdgcodeHisto->Fill(pdgcode); + processvsRadOther->Fill(rad, part.prodProcess); + } + + if (!part.isFake && !part.isReco) { + processvsEtaNotTracked->Fill(part.eta, part.prodProcess); + processvsRadNotTracked->Fill(rad, part.prodProcess); } if (ngoodfake == 1 || ngoodfake == 0) nPartGoodorFake[idxPart][nlayer][ngoodfake]++; - nPartForSpec[idxPart][nlayer]=nPartForSpec[idxPart][nlayer]+1; - // Analysing fake clusters + nPartForSpec[idxPart][nlayer]++; + // Analysing fake clusters int nCl{0}; for (unsigned int bit{0}; bit < sizeof(part.clusters) * 8; ++bit) { nCl += bool(part.clusters & (1 << bit)); @@ -836,47 +718,12 @@ void TrackCheckStudy::process() bool fakec; const_cast(lab).get(TrackID, EvID, SrcID, fakec); double intHisto = 0; - if (mParticleInfo[SrcID][EvID][TrackID].pdg == -11) - intHisto = 0.5; // "e^{+}" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 11) - intHisto = 1.5; // "e^{-}" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == -211) - intHisto = 2.5; // "#pi^{-}" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 211) - intHisto = 3.5; // "#pi^{+}" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 2212) - intHisto = 4.5; // "p" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == -2212) - intHisto = 5.5; // "anti p" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1000010020) - intHisto = 6.5; // "^{2}H" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == -1000010020) - intHisto = 7.5; // "^{2}H-" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1000020030) - intHisto = 8.5; // "^{3}He" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == -1000020030) - intHisto = 9.5; // "^{3}He-" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 1010010030) - intHisto = 10.5; // "IperT" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == -1010010030) - intHisto = 11.5; // " AntiIperT" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == 321) - intHisto = 12.5; // "K+" - if (mParticleInfo[SrcID][EvID][TrackID].pdg == -321) - intHisto = 13.5; // "K-" - ProcessName[mParticleInfo[SrcID][EvID][TrackID].prodProcess] = mParticleInfo[SrcID][EvID][TrackID].prodProcessName; - if (pdgcode == 1010010030) { - mIperTClusterfake->Fill(intHisto, mParticleInfo[SrcID][EvID][TrackID].prodProcess); - mIperTClusterfake1D->Fill(intHisto); - } - if (pdgcode == 3122) { - mLamClusterfake->Fill(intHisto, mParticleInfo[SrcID][EvID][TrackID].prodProcess); - mLamClusterfake1D->Fill(intHisto); - } - if (pdgcode == 310) { - mKClusterfake->Fill(intHisto, mParticleInfo[SrcID][EvID][TrackID].prodProcess); - mKClusterfake1D->Fill(intHisto); + for (int hg = 0; hg < 7; hg++) { + if (mParticleInfo[SrcID][EvID][TrackID].pdg == PdgcodeClusterFake[hg] || mParticleInfo[SrcID][EvID][TrackID].pdg == -1*(PdgcodeClusterFake[hg])) + intHisto = hg + 0.5; } + if (idxPart < 3) + mClusterFake[idxPart]->Fill(intHisto, mParticleInfo[SrcID][EvID][TrackID].prodProcess); } } } @@ -889,62 +736,38 @@ void TrackCheckStudy::process() } evID++; } - - /*int totgood{0}, totfake{0}, totI{0}, totL{0}, totK{0}, totO{0}; - for (int u = 0; u < 4; u++) { - for (int v = 0; v < 4; v++) { - totgood = totgood + nPartGoodorFake[u][v][1]; - totfake = totfake + nPartGoodorFake[u][v][0]; - if (u == 0) - totI = totI + nPartForSpec[u][v]; - if (u == 1) - totL = totL + nPartForSpec[u][v]; - if (u == 2) - totK = totK + nPartForSpec[u][v]; - if (u == 3) - { - totO = totO + nPartForSpec[u][v]; - LOGP(info, "cout5"); - } - } - }*/ + int totgood{0}, totfake{0}, totI{0}, totL{0}, totK{0}, totO{0}; - for(int xx=0;xx<4;xx++) - { - for(int yy=0;yy<4;yy++) - { + for (int xx = 0; xx < 4; xx++) { + for (int yy = 0; yy < 4; yy++) { totgood = totgood + nPartGoodorFake[xx][yy][1]; totfake = totfake + nPartGoodorFake[xx][yy][0]; - if(xx==0) totI = totI + nPartForSpec[0][yy]; - if(xx==1) totL = totL + nPartForSpec[1][yy]; - if(xx==2) totK = totK + nPartForSpec[2][yy]; - if(xx==3) totO = totO + nPartForSpec[3][yy]; - + if (xx == 0) + totI = totI + nPartForSpec[0][yy]; + if (xx == 1) + totL = totL + nPartForSpec[1][yy]; + if (xx == 2) + totK = totK + nPartForSpec[2][yy]; + if (xx == 3) + totO = totO + nPartForSpec[3][yy]; } } - LOGP(info, "cout6"); + LOGP(info, "number of primary tracks: {}, good:{}, fake:{}", totP, goodP, fakeP); + int goodI = nPartGoodorFake[0][0][1] + nPartGoodorFake[0][1][1] + nPartGoodorFake[0][2][1] + nPartGoodorFake[0][3][1]; + int goodL = nPartGoodorFake[1][0][1] + nPartGoodorFake[1][1][1] + nPartGoodorFake[1][2][1] + nPartGoodorFake[1][3][1]; + int goodK = nPartGoodorFake[2][0][1] + nPartGoodorFake[2][1][1] + nPartGoodorFake[2][2][1] + nPartGoodorFake[2][3][1]; + int fakeI = nPartGoodorFake[0][0][0] + nPartGoodorFake[0][1][0] + nPartGoodorFake[0][2][0] + nPartGoodorFake[0][3][0]; + int fakeL = nPartGoodorFake[1][0][0] + nPartGoodorFake[1][1][0] + nPartGoodorFake[1][2][0] + nPartGoodorFake[1][3][0]; + int fakeK = nPartGoodorFake[2][0][0] + nPartGoodorFake[2][1][0] + nPartGoodorFake[2][2][0] + nPartGoodorFake[2][3][0]; LOGP(info, "** Some statistics on secondary tracks:"); LOGP(info, "\t- Total number of secondary tracks: {}", totsec); - LOGP(info, "\t- Total number of secondary accepted tracks : {}", totsecCont); - LOGP(info, "\t- Total number of secondary accepted tracks good: {}, fake: {}", totgood, totfake); - LOGP(info, "\t- Total number of secondary accepted tracks from IperT: {} = {} %", totI, 100 * totI / totsecCont); - LOGP(info, "\t- Total number of secondary accepted tracks from Lam: {} = {} %", totL, 100 * totL / totsecCont); - LOGP(info, "\t- Total number of secondary accepted tracks from k: {} = {} %", totK, 100 * totK / totsecCont); - LOGP(info, "\t- Total number of secondary accepted tracks from Other: {} = {} %", totO, 100 * totO / totsecCont); - - // LOGP(info, "fraction of k = {}, fraction of lambda= {}", (*mRadk).GetEntries() / (*mDenominatorSecRad).GetEntries(), (*mRadLam).GetEntries() / (*mDenominatorSecRad).GetEntries()); - - Histo.push_back(*mDenominatorSecRad); - Histo.push_back(*mRadk); - Histo.push_back(*mRadLam); - Histo.push_back(*mDenominatorSecZ); - Histo.push_back(*mZk); - Histo.push_back(*mZLam); - Histo.push_back(*mIperTClusterfake1D); - Histo.push_back(*mLamClusterfake1D); - Histo.push_back(*mKClusterfake1D); - Histo.push_back(*pdgcodeHisto); + LOGP(info, "\t- Total number of secondary trackeable tracks : {}", totsecCont); + LOGP(info, "\t- Total number of secondary trackeable tracks good: {}, fake: {}", totgood, totfake); + LOGP(info, "\t- Total number of secondary trackeable tracks from IperT: {} = {} %, Good={} % , fake={} %", totI, 100 * totI / totsecCont, 100 * goodI / totI, 100 * fakeI / totI); + LOGP(info, "\t- Total number of secondary trackeable tracks from Lam: {} = {} %, Good={} % , fake={} %", totL, 100 * totL / totsecCont, 100 * goodL / totL, 100 * fakeL / totL); + LOGP(info, "\t- Total number of secondary trackeable tracks from k: {} = {} %, Good={} % , fake={} %", totK, 100 * totK / totsecCont, 100 * goodK / totK, 100 * fakeK / totK); + LOGP(info, "\t- Total number of secondary trackeable tracks from Other: {} = {} %", totO, 100 * totO / totsecCont); LOGP(info, "** Computing efficiencies ..."); @@ -956,41 +779,23 @@ void TrackCheckStudy::process() mEffFakeEta = std::make_unique(*mFakeEta, *mDenominatorEta); mEffClonesEta = std::make_unique(*mCloneEta, *mDenominatorEta); - mEffRad = std::make_unique(*mGoodRad, *mDenominatorSecRad); - mEffFakeRad = std::make_unique(*mFakeRad, *mDenominatorSecRad); - - mEffZ = std::make_unique(*mGoodZ, *mDenominatorSecZ); - mEffFakeZ = std::make_unique(*mFakeZ, *mDenominatorSecZ); + mEffPtSec = std::make_unique(*mGoodPtSec, *mDenominatorPtSec); + mEffFakePtSec = std::make_unique(*mFakePtSec, *mDenominatorPtSec); - mEffRadk = std::make_unique(*mGoodRadk, *mRadk); - mEffFakeRadk = std::make_unique(*mFakeRadk, *mRadk); - - mEffZk = std::make_unique(*mGoodZk, *mZk); - mEffFakeZk = std::make_unique(*mFakeZk, *mZk); - - mEffRadLam = std::make_unique(*mGoodRadLam, *mRadLam); - mEffFakeRadLam = std::make_unique(*mFakeRadLam, *mRadLam); - - mEffZLam = std::make_unique(*mGoodZLam, *mZLam); - mEffFakeZLam = std::make_unique(*mFakeZLam, *mZLam); + mEffEtaSec = std::make_unique(*mGoodEtaSec, *mDenominatorEtaSec); + mEffFakeEtaSec = std::make_unique(*mFakeEtaSec, *mDenominatorEtaSec); for (int ii = 0; ii < 4; ii++) { - mEffGoodPts[ii] = std::make_unique(*mGoodPts[ii], *mTotPts[ii]); - mEffFakePts[ii] = std::make_unique(*mFakePts[ii], *mTotPts[ii]); - mEffGoodPtsK[ii] = std::make_unique(*mGoodPtsK[ii], *mTotPtsK[ii]); - mEffFakePtsK[ii] = std::make_unique(*mFakePtsK[ii], *mTotPtsK[ii]); - mEffGoodPtsLam[ii] = std::make_unique(*mGoodPtsLam[ii], *mTotPtsLam[ii]); - mEffFakePtsLam[ii] = std::make_unique(*mFakePtsLam[ii], *mTotPtsLam[ii]); - mEffGoodPtsIperT[ii] = std::make_unique(*mGoodPtsIperT[ii], *mTotPtsIperT[ii]); - mEffFakePtsIperT[ii] = std::make_unique(*mFakePtsIperT[ii], *mTotPtsIperT[ii]); - mEffGoodEtasK[ii] = std::make_unique(*mGoodEtasK[ii], *mTotEtasK[ii]); - mEffFakeEtasK[ii] = std::make_unique(*mFakeEtasK[ii], *mTotEtasK[ii]); - mEffGoodEtasLam[ii] = std::make_unique(*mGoodEtasLam[ii], *mTotEtasLam[ii]); - mEffFakeEtasLam[ii] = std::make_unique(*mFakeEtasLam[ii], *mTotEtasLam[ii]); - mEffGoodEtasIperT[ii] = std::make_unique(*mGoodEtasIperT[ii], *mTotEtasIperT[ii]); - mEffFakeEtasIperT[ii] = std::make_unique(*mFakeEtasIperT[ii], *mTotEtasIperT[ii]); - mEffGoodEtas[ii] = std::make_unique(*mGoodEtas[ii], *mTotEtas[ii]); - mEffFakeEtas[ii] = std::make_unique(*mFakeEtas[ii], *mTotEtas[ii]); + for (int yy = 0; yy < 4; yy++) { + mEffGoodPts[ii][yy] = std::make_unique(*mGoodPts[ii][yy], *mTotPts[ii][yy]); + mEffFakePts[ii][yy] = std::make_unique(*mFakePts[ii][yy], *mTotPts[ii][yy]); + mEffGoodEtas[ii][yy] = std::make_unique(*mGoodEtas[ii][yy], *mTotEtas[ii][yy]); + mEffFakeEtas[ii][yy] = std::make_unique(*mFakeEtas[ii][yy], *mTotEtas[ii][yy]); + } + mEffGoodRad[ii] = std::make_unique(*mGoodRad[ii], *mTotRad[ii]); + mEffFakeRad[ii] = std::make_unique(*mFakeRad[ii], *mTotRad[ii]); + mEffGoodZ[ii] = std::make_unique(*mGoodZ[ii], *mTotZ[ii]); + mEffFakeZ[ii] = std::make_unique(*mFakeZ[ii], *mTotZ[ii]); } LOGP(info, "** Analysing pT resolution..."); @@ -1045,16 +850,6 @@ void TrackCheckStudy::setEfficiencyGraph(std::unique_ptr& eff, cons eff->SetDirectory(gDirectory); } -void TrackCheckStudy::setHistoGraph(TH1D& histo, std::unique_ptr& histo2, const char* name, const char* title, const int color, const double alpha = 0.5) -{ - histo.SetName(name); - histo2->SetName(name); - histo.SetTitle(title); - histo.SetFillColor(color); - histo.SetFillColorAlpha(color, alpha); - histo.SetDirectory(gDirectory); -} - void TrackCheckStudy::updateTimeDependentParams(ProcessingContext& pc) { static bool initOnceDone = false; @@ -1069,7 +864,6 @@ void TrackCheckStudy::updateTimeDependentParams(ProcessingContext& pc) void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) { TFile fout(mOutFileName.c_str(), "recreate"); - NormalizeHistos(Histo); setEfficiencyGraph(mEffPt, "Good_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kAzure + 4, 0.65); fout.WriteTObject(mEffPt.get()); @@ -1077,160 +871,100 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) setEfficiencyGraph(mEffFakePt, "Fake_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kRed, 0.65); fout.WriteTObject(mEffFakePt.get()); - setEfficiencyGraph(mEffPt, "Tot Prim G Tracks", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kBlack, 1); - setEfficiencyGraph(mEffFakePt, "Tot Prim F Tracks", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kBlack, 1); + setEfficiencyGraph(mEffPtSec, "Good_ptSec", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle", kOrange + 7); + fout.WriteTObject(mEffPtSec.get()); + + setEfficiencyGraph(mEffFakePtSec, "Fake_ptSec", ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle", kGray + 2); + fout.WriteTObject(mEffFakePtSec.get()); setEfficiencyGraph(mEffClonesPt, "Clone_pt", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kGreen + 2, 0.65); fout.WriteTObject(mEffClonesPt.get()); - setEfficiencyGraph(mEffEta, "Good_eta", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kAzure + 4, 0.65); + setEfficiencyGraph(mEffEta, "Good_eta", ";#eta;efficiency primary particle", kAzure + 4, 0.65); fout.WriteTObject(mEffEta.get()); - setEfficiencyGraph(mEffFakeEta, "Fake_eta", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kRed + 1, 0.65); + setEfficiencyGraph(mEffFakeEta, "Fake_eta", ";#eta;efficiency primary particle", kRed + 1, 0.65); fout.WriteTObject(mEffFakeEta.get()); - setEfficiencyGraph(mEffClonesEta, "Clone_eta", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kGreen + 2, 0.65); - fout.WriteTObject(mEffClonesEta.get()); - - setEfficiencyGraph(mEffRad, "Good_Rad", ";Radius [cm];efficiency secondary particle", kBlue, 1); - fout.WriteTObject(mEffRad.get()); - - setEfficiencyGraph(mEffFakeRad, "Fake_Rad", ";Radius [cm];efficiency secondary particle", kOrange + 7, 1); - fout.WriteTObject(mEffFakeRad.get()); - - setEfficiencyGraph(mEffRadk, "Good_Radk", ";Radius [cm];efficiency secondary particle", kBlue, 1); - fout.WriteTObject(mEffRadk.get()); - - setEfficiencyGraph(mEffFakeRadk, "Fake_Radk", ";Radius [cm];efficiency secondary particle", kAzure + 10, 1); - fout.WriteTObject(mEffFakeRadk.get()); + setEfficiencyGraph(mEffEtaSec, "Good_etaSec", ";#eta;efficiency secondary particle", kOrange + 7); + fout.WriteTObject(mEffEtaSec.get()); - setEfficiencyGraph(mEffRadLam, "Good_RadLam", ";Radius [cm];efficiency secondary particle", kRed + 2, 1); - fout.WriteTObject(mEffRadLam.get()); + setEfficiencyGraph(mEffFakeEtaSec, "Fake_etaSec", ";#eta;efficiency secondary particle", kGray + 2); + fout.WriteTObject(mEffFakeEtaSec.get()); - setEfficiencyGraph(mEffFakeRadLam, "Fake_RadLam", ";Radius [cm];efficiency secondary particle", kMagenta - 9, 1); - fout.WriteTObject(mEffFakeRadLam.get()); - - setEfficiencyGraph(mEffZ, "Good_Z", ";z secondary vertex [cm];efficiency secondary particle", kTeal + 2, 1); - fout.WriteTObject(mEffZ.get()); - - setEfficiencyGraph(mEffFakeZ, "Fake_Z", ";z secondary vertex [cm];efficiency secondary particle", kMagenta - 4, 1); - fout.WriteTObject(mEffFakeZ.get()); - - setEfficiencyGraph(mEffZk, "Good_Zk", ";z of sv [cm];efficiency secondary particle", kBlue); - fout.WriteTObject(mEffZk.get()); - - setEfficiencyGraph(mEffFakeZk, "Fake_Zk", ";z of sv [cm];efficiency secondary particle", kAzure + 10); - fout.WriteTObject(mEffFakeZk.get()); - - setEfficiencyGraph(mEffZLam, "Good_ZLam", ";z of sv [cm];efficiency secondary particle", kRed + 2); - fout.WriteTObject(mEffZLam.get()); - - setEfficiencyGraph(mEffFakeZLam, "Fake_ZLam", ";z of sv [cm];efficiency secondary particle", kMagenta - 9); - fout.WriteTObject(mEffFakeZLam.get()); + setEfficiencyGraph(mEffClonesEta, "Clone_eta", ";#it{p}_{T} (GeV/#it{c});efficiency primary particle", kGreen + 2, 0.65); + fout.WriteTObject(mEffClonesEta.get()); for (int aa = 0; aa < 4; aa++) { - setEfficiencyGraph(mEffGoodPts[aa], Form("EffPtGoodl%d", aa), Form("Tot Sec G Tracks, L%d" - ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", - aa), - kGray); - setEfficiencyGraph(mEffFakePts[aa], Form("EffPtFakel%d", aa), Form("Tot Sec F Tracks, L%d" - ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", - aa), - kGray); - setEfficiencyGraph(mEffGoodEtas[aa], Form("EffEtaGoodl%d", aa), Form("Tot Sec G Tracks, L%d" - ";eta ;efficiency secondary particle ", - aa), - kAzure + 4); - setEfficiencyGraph(mEffFakeEtas[aa], Form("EffEtaFakel%d", aa), Form("Tot Sec F Tracks, L%d" - ";eta ;efficiency secondary particle ", - aa), - kAzure + 4); - setEfficiencyGraph(mEffGoodPtsK[aa], Form("EffPtGoodKl%d", aa), Form("k^{0}_{s} Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kBlue); - setEfficiencyGraph(mEffFakePtsK[aa], Form("EffPtFakeKl%d", aa), Form("k^{0}_{s} Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kBlue); - setEfficiencyGraph(mEffGoodPtsLam[aa], Form("EffPtGoodLaml%d", aa), Form("#Lambda Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kRed); - setEfficiencyGraph(mEffFakePtsLam[aa], Form("EffPtFakeLaml%d", aa), Form("#Lambda Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kRed); - setEfficiencyGraph(mEffGoodPtsIperT[aa], Form("EffPtGoodIperTl%d", aa), Form("_{#Lambda}^{3}H Sec G Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kGreen + 2); - setEfficiencyGraph(mEffFakePtsIperT[aa], Form("EffPtFakeIperTl%d", aa), Form("_{#Lambda}^{3}H Sec F Tracks, L%d ;#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", aa), kGreen + 2); - - setEfficiencyGraph(mEffGoodEtasK[aa], Form("EffEtaGoodKl%d", aa), Form("k^{0}_{s} Sec G Tracks, L%d ;#eta;efficiency secondary particle ", aa), kBlue); - setEfficiencyGraph(mEffFakeEtasK[aa], Form("EffEtaFakeKl%d", aa), Form("k^{0}_{s} Sec F Tracks, L%d ;#eta;efficiency secondary particle ", aa), kBlue); - setEfficiencyGraph(mEffGoodEtasLam[aa], Form("EffEtaGoodLaml%d", aa), Form("#Lambda Sec G Tracks, L%d ;#eta;efficiency secondary particle ", aa), kRed); - setEfficiencyGraph(mEffFakeEtasLam[aa], Form("EffEtaFakeLaml%d", aa), Form("#Lambda Sec F Tracks, L%d ;#eta;efficiency secondary particle ", aa), kRed); - setEfficiencyGraph(mEffGoodEtasIperT[aa], Form("EffEtaGoodIperTl%d", aa), Form("_{#Lambda}^{3}H Sec G Tracks, L%d ;#eta;efficiency secondary particle ", aa), kGreen + 2); - setEfficiencyGraph(mEffFakeEtasIperT[aa], Form("EffEtaFakeIperTl%d", aa), Form("_{#Lambda}^{3}H Sec F Tracks, L%d ;#eta;efficiency secondary particle ", aa), kGreen + 2); - - fout.WriteTObject(mEffGoodPts[aa].get()); - fout.WriteTObject(mEffFakePts[aa].get()); - fout.WriteTObject(mEffGoodPtsK[aa].get()); - fout.WriteTObject(mEffGoodPtsLam[aa].get()); - fout.WriteTObject(mEffGoodPtsIperT[aa].get()); - fout.WriteTObject(mEffFakePtsK[aa].get()); - fout.WriteTObject(mEffFakePtsLam[aa].get()); - fout.WriteTObject(mEffFakePtsIperT[aa].get()); - - fout.WriteTObject(mEffFakeEtasK[aa].get()); - fout.WriteTObject(mEffFakeEtasLam[aa].get()); - fout.WriteTObject(mEffFakeEtasIperT[aa].get()); - fout.WriteTObject(mEffGoodEtasK[aa].get()); - fout.WriteTObject(mEffGoodEtasLam[aa].get()); - fout.WriteTObject(mEffGoodEtasIperT[aa].get()); - fout.WriteTObject(mEffGoodEtas[aa].get()); - fout.WriteTObject(mEffFakeEtas[aa].get()); + setEfficiencyGraph(mEffGoodRad[aa], Form("Good_Rad_%s", particleToanalize[aa]), ";Radius [cm];efficiency secondary particle", colorArr[aa]); + fout.WriteTObject(mEffGoodRad[aa].get()); + + setEfficiencyGraph(mEffGoodRad[aa], Form("Fake_Rad_%s", particleToanalize[aa]), ";Radius [cm];efficiency secondary particle", colorArr[aa] - 9); + fout.WriteTObject(mEffGoodRad[aa].get()); + + setEfficiencyGraph(mEffGoodZ[aa], Form("Good_Z_%s", particleToanalize[aa]), ";Z_{sv} [cm];efficiency secondary particle", colorArr[aa]); + fout.WriteTObject(mEffGoodZ[aa].get()); + + setEfficiencyGraph(mEffGoodZ[aa], Form("Fake_Z_%s", particleToanalize[aa]), ";Z_{sv} [cm];efficiency secondary particle", colorArr[aa] - 9); + fout.WriteTObject(mEffGoodZ[aa].get()); + + for (int bb = 0; bb < 4; bb++) { + setEfficiencyGraph(mEffGoodPts[aa][bb], Form("EffPtGood_%sl%d", particleToanalize[aa], bb), Form("Good Sec Tracks_%s, L%d" + ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", + bb, particleToanalize[aa]), + colorArr[aa]); + setEfficiencyGraph(mEffFakePts[aa][bb], Form("EffPtFake_%sl%d", particleToanalize[aa], bb), Form("Fake Sec Tracks_%s, L%d" + ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", + bb, particleToanalize[aa]), + colorArr[aa]); + setEfficiencyGraph(mEffGoodEtas[aa][bb], Form("EffEtaGood_%sl%d", particleToanalize[aa], bb), Form("Good Sec Tracks_%s, L%d" + ";#eta ;efficiency secondary particle ", + bb, particleToanalize[aa]), + colorArr[aa]); + setEfficiencyGraph(mEffFakeEtas[aa][bb], Form("EffEtaFake_%sl%d", particleToanalize[aa], bb), Form("Fake Sec Tracks_%s, L%d" + ";#eta ;efficiency secondary particle ", + bb, particleToanalize[aa]), + colorArr[aa]); + + fout.WriteTObject(mEffGoodPts[aa][bb].get()); + fout.WriteTObject(mEffFakePts[aa][bb].get()); + fout.WriteTObject(mEffGoodEtas[aa][bb].get()); + fout.WriteTObject(mEffFakeEtas[aa][bb].get()); + } for (int i = 0; i < 3; i++) { - fout.WriteTObject(histLength[aa][i], Form("trk_len_%d_%s", 4 + aa, tt[i])); - fout.WriteTObject(histLength1Fake[aa][i], Form("trk_len_%d_1f_%s", 4 + aa, tt[i])); - fout.WriteTObject(histLength2Fake[aa][i], Form("trk_len_%d_2f_%s", 4 + aa, tt[i])); - fout.WriteTObject(histLength3Fake[aa][i], Form("trk_len_%d_3f_%s", 4 + aa, tt[i])); - fout.WriteTObject(histLengthNoCl[aa][i], Form("trk_len_%d_nocl_%s", 4 + aa, tt[i])); - fout.WriteTObject(histLength1FakeNoCl[aa][i], Form("trk_len_%d_1f_nocl_%s", 4 + aa, tt[i])); - fout.WriteTObject(histLength2FakeNoCl[aa][i], Form("trk_len_%d_2f_nocl_%s", 4 + aa, tt[i])); - fout.WriteTObject(histLength3FakeNoCl[aa][i], Form("trk_len_%d_3f_nocl_%s", 4 + aa, tt[i])); + fout.WriteTObject(histLength[aa][i], Form("trk_len_%d_%s", 4 + aa, name[i])); + fout.WriteTObject(histLength1Fake[aa][i], Form("trk_len_%d_1f_%s", 4 + aa, name[i])); + fout.WriteTObject(histLength2Fake[aa][i], Form("trk_len_%d_2f_%s", 4 + aa, name[i])); + fout.WriteTObject(histLength3Fake[aa][i], Form("trk_len_%d_3f_%s", 4 + aa, name[i])); + fout.WriteTObject(histLengthNoCl[aa][i], Form("trk_len_%d_nocl_%s", 4 + aa, name[i])); + fout.WriteTObject(histLength1FakeNoCl[aa][i], Form("trk_len_%d_1f_nocl_%s", 4 + aa, name[i])); + fout.WriteTObject(histLength2FakeNoCl[aa][i], Form("trk_len_%d_2f_nocl_%s", 4 + aa, name[i])); + fout.WriteTObject(histLength3FakeNoCl[aa][i], Form("trk_len_%d_3f_nocl_%s", 4 + aa, name[i])); } } - setHistoGraph(Histo[0], mDenominatorSecRad, "Decay_Radius_MC", ";Decay Radius ;Entries", kGray, 0.4); - fout.WriteTObject(mDenominatorSecRad.get()); - - setHistoGraph(Histo[3], mDenominatorSecZ, "Zsv_MC", ";z of secondary vertex ;Entries", kGray, 0.4); - fout.WriteTObject(mDenominatorSecZ.get()); - - setHistoGraph(Histo[1], mRadk, "Decay_Radius_MC_k", ";Decay Radius ;Entries", kBlue, 0.2); - fout.WriteTObject(mRadk.get()); - - setHistoGraph(Histo[4], mZk, "Zsv_MC_k", ";Zsv ;Entries", kBlue, 0.2); - fout.WriteTObject(mZk.get()); - - setHistoGraph(Histo[2], mRadLam, "Decay_Radius_MC_Lam", ";Decay Radius ;Entries", kRed, 0.2); - fout.WriteTObject(mRadLam.get()); - - setHistoGraph(Histo[5], mZLam, "Zsv_MC_Lam", ";Zsv ;Entries", kRed, 0.2); - fout.WriteTObject(mZLam.get()); - setHistoGraph(Histo[6], mIperTClusterfake1D, "IperTClusterfake1D", "; of fake cluster ;Entries", kGreen + 2, 1); - fout.WriteTObject(mIperTClusterfake1D.get()); - - setHistoGraph(Histo[7], mLamClusterfake1D, "LamClusterfake1D", "; of fake cluster ;Entries", kRed, 1); - fout.WriteTObject(mLamClusterfake1D.get()); - - setHistoGraph(Histo[8], mKClusterfake1D, "KClusterfake1D", "; of fake cluster ;Entries", kBlue, 1); - fout.WriteTObject(mKClusterfake1D.get()); - for (int y = 6; y < 9; y++) { - for (int i = 1; i <= 14; i++) { - Histo[y].GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); + for (int j = 0; j < 4; j++) { + for (int i = 1; i <= 7; i++) { + mClusterFake[j]->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); + + for (int i = 1; i <= 50; i++) { + mClusterFake[j]->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + if (j == 0) { + processvsZ->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + processvsRad->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + processvsRadOther->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + processvsRadNotTracked->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + processvsEtaNotTracked->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); + } + } + fout.WriteTObject(mClusterFake[j].get()); } } - for (int i = 1; i <= 14; i++) { - mIperTClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); - mLamClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); - mKClusterfake->GetXaxis()->SetBinLabel(i, ParticleName[i - 1]); - } - for (int i = 1; i <= 50; i++) { - mIperTClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); - mLamClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); - mKClusterfake->GetYaxis()->SetBinLabel(i, ProcessName[i - 1]); - } - fout.WriteTObject(mIperTClusterfake.get()); - fout.WriteTObject(mLamClusterfake.get()); - fout.WriteTObject(mKClusterfake.get()); + fout.WriteTObject(processvsZ.get()); + fout.WriteTObject(processvsRad.get()); + fout.WriteTObject(processvsRadOther.get()); + fout.WriteTObject(processvsRadNotTracked.get()); + fout.WriteTObject(processvsEtaNotTracked.get()); // Paint the histograms // todo: delegate to a dedicated helper @@ -1255,13 +989,26 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEffFakePt->Draw("pz same"); mEffClonesPt->Draw("pz same"); mLegendPt = std::make_unique(0.19, 0.8, 0.40, 0.96); - mLegendPt->SetHeader(Form("%zu events PbPb min bias", mKineReader->getNEvents(0)), "C"); + mLegendPt->SetHeader(Form("%zu events PP min bias", mKineReader->getNEvents(0)), "C"); mLegendPt->AddEntry("Good_pt", "good (100% cluster purity)", "lep"); mLegendPt->AddEntry("Fake_pt", "fake", "lep"); mLegendPt->AddEntry("Clone_pt", "clone", "lep"); mLegendPt->Draw(); mCanvasPt->SaveAs("eff_pt.png"); + mCanvasPtSec = std::make_unique("cPtSec", "cPtSec", 1600, 1200); + mCanvasPtSec->cd(); + mCanvasPtSec->SetLogx(); + mCanvasPtSec->SetGrid(); + mEffPtSec->Draw("pz"); + mEffFakePtSec->Draw("pz same"); + mLegendPtSec = std::make_unique(0.19, 0.8, 0.40, 0.96); + mLegendPtSec->SetHeader(Form("%zu events PP min bias", mKineReader->getNEvents(0)), "C"); + mLegendPtSec->AddEntry("Good_ptSec", "good (100% cluster purity)", "lep"); + mLegendPtSec->AddEntry("Fake_tSec", "fake", "lep"); + mLegendPtSec->Draw(); + mCanvasPtSec->SaveAs("eff_ptSec.png"); + mCanvasEta = std::make_unique("cEta", "cEta", 1600, 1200); mCanvasEta->cd(); mCanvasEta->SetGrid(); @@ -1269,86 +1016,90 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) mEffFakeEta->Draw("pz same"); mEffClonesEta->Draw("pz same"); mLegendEta = std::make_unique(0.19, 0.8, 0.40, 0.96); - mLegendEta->SetHeader(Form("%zu events PbPb min bias", mKineReader->getNEvents(0)), "C"); + mLegendEta->SetHeader(Form("%zu events PP min bias", mKineReader->getNEvents(0)), "C"); mLegendEta->AddEntry("Good_eta", "good (100% cluster purity)", "lep"); mLegendEta->AddEntry("Fake_eta", "fake", "lep"); mLegendEta->AddEntry("Clone_eta", "clone", "lep"); mLegendEta->Draw(); mCanvasEta->SaveAs("eff_eta.png"); + mCanvasEtaSec = std::make_unique("cEtaSec", "cEtaSec", 1600, 1200); + mCanvasEtaSec->cd(); + mCanvasEtaSec->SetGrid(); + mEffEtaSec->Draw("pz"); + mEffFakeEtaSec->Draw("pz same"); + mLegendEtaSec = std::make_unique(0.19, 0.8, 0.40, 0.96); + mLegendEtaSec->SetHeader(Form("%zu events PP min bias", mKineReader->getNEvents(0)), "C"); + mLegendEtaSec->AddEntry("Good_etaSec", "good (100% cluster purity)", "lep"); + mLegendEtaSec->AddEntry("Fake_etaSec", "fake", "lep"); + mLegendEtaSec->Draw(); + mCanvasEtaSec->SaveAs("eff_EtaSec.png"); + mCanvasRad = std::make_unique("cRad", "cRad", 1600, 1200); mCanvasRad->cd(); mCanvasRad->SetGrid(); - mEffRad->Draw("pz"); - mEffFakeRad->Draw("pz same"); - Histo[0].Draw("hist same"); + mEffGoodRad[3]->Draw("pz"); + mEffFakeRad[3]->Draw("pz same"); mCanvasRad->SetLogy(); mLegendRad = std::make_unique(0.8, 0.4, 0.95, 0.6); mLegendRad->SetHeader(Form("%zu events PP ", mKineReader->getNEvents(0)), "C"); - mLegendRad->AddEntry("Good_Rad", "good", "lep"); - mLegendRad->AddEntry("Fake_Rad", "fake", "lep"); - mLegendRad->AddEntry("Decay_Radius_MC", "MC", "f"); + mLegendRad->AddEntry(Form("Good_Rad_%s", particleToanalize[3]), "good", "lep"); + mLegendRad->AddEntry(Form("Fake_Rad_%s", particleToanalize[3]), "fake", "lep"); mLegendRad->Draw(); - mCanvasRad->SaveAs("eff_rad_sec_MC.png"); + mCanvasRad->SaveAs("eff_rad_sec.png"); mCanvasZ = std::make_unique("cZ", "cZ", 1600, 1200); mCanvasZ->cd(); mCanvasZ->SetGrid(); mCanvasZ->SetLogy(); - mEffZ->Draw("pz"); - mEffFakeZ->Draw("pz same"); - Histo[3].Draw(" hist same"); - mLegendZ = std::make_unique(0.19, 0.8, 0.40, 0.96); - mLegendZ->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); - mLegendZ->AddEntry("Good_Z", "good", "lep"); - mLegendZ->AddEntry("Fake_Z", "fake", "lep"); - mLegendZ->AddEntry("Zsv_MC", "MC", "f"); - + mEffGoodZ[3]->Draw("pz"); + mEffFakeZ[3]->Draw("pz same"); + mCanvasZ->SetLogy(); + mLegendZ = std::make_unique(0.8, 0.4, 0.95, 0.6); + mLegendZ->SetHeader(Form("%zu events PP ", mKineReader->getNEvents(0)), "C"); + mLegendZ->AddEntry(Form("Good_Z_%s", particleToanalize[3]), "good", "lep"); + mLegendZ->AddEntry(Form("Fake_Z_%s", particleToanalize[3]), "fake", "lep"); mLegendZ->Draw(); - mCanvasZ->SaveAs("eff_Z_sec_MC.png"); + mCanvasZ->SaveAs("eff_Z_sec.png"); + ; mCanvasRadD = std::make_unique("cRadD", "cRadD", 1600, 1200); mCanvasRadD->cd(); mCanvasRadD->SetGrid(); - mEffRadk->Draw("pz"); - mEffFakeRadk->Draw("pz same"); - Histo[1].Draw(" hist same"); - mEffRadLam->Draw("pz same"); - mEffFakeRadLam->Draw("pz same"); - Histo[2].Draw(" hist same"); mCanvasRadD->SetLogy(); mLegendRadD = std::make_unique(0.8, 0.64, 0.95, 0.8); mLegendRadD->SetHeader(Form("%zu events PP ", mKineReader->getNEvents(0)), "C"); - mLegendRadD->AddEntry("Good_Radk", " k^{0}_{s} good", "lep"); - mLegendRadD->AddEntry("Fake_Radk", "k^{0}_{s} fake", "lep"); - mLegendRadD->AddEntry("Decay_Radius_MC_k", "k^{0}_{s} MC", "f"); - mLegendRadD->AddEntry("Good_RadLam", " #Lambda good", "lep"); - mLegendRadD->AddEntry("Fake_RadLam", "#Lambda fake", "lep"); - mLegendRadD->AddEntry("Decay_Radius_MC_Lam", "#Lambda MC", "f"); - + for (int i = 0; i < 3; i++) { + if (i == 0) + mEffGoodRad[i]->Draw("pz"); + else { + mEffGoodRad[i]->Draw("pz same"); + mEffFakeRad[i]->Draw("pz same"); + mLegendRadD->AddEntry(Form("Good_Rad%s", particleToanalize[i]), Form("%s_good", name[i]), "lep"); + mLegendRadD->AddEntry(Form("Fake_Rad%s", particleToanalize[i]), Form("%s_fake", name[i]), "lep"); + } + } mLegendRadD->Draw(); - mCanvasRadD->SaveAs("eff_RadD_sec_MC.png"); + mCanvasRadD->SaveAs("eff_RadD_sec.png"); - mCanvasZD = std::make_unique("cZd", "cZd", 1600, 1200); + mCanvasZD = std::make_unique("cZD", "cZD", 1600, 1200); mCanvasZD->cd(); mCanvasZD->SetGrid(); - mEffZk->Draw("pz"); - mEffFakeZk->Draw("pz same"); - Histo[4].Draw("same hist"); - mEffZLam->Draw("pz same"); - mEffFakeZLam->Draw("pz same"); - Histo[5].Draw("same hist"); - mLegendZD = std::make_unique(0.19, 0.5, 0.30, 0.7); - mLegendZD->SetHeader(Form("%zu events PP", mKineReader->getNEvents(0)), "C"); - mLegendZD->AddEntry("Good_Zk", " k^{0}_{s} good", "lep"); - mLegendZD->AddEntry("Fake_Zk", "k^{0}_{s} fake", "lep"); - mLegendZD->AddEntry("Zsv_MC_k", "k^{0}_{s} MC", "f"); - mLegendZD->AddEntry("Good_ZLam", "#Lambda good", "lep"); - mLegendZD->AddEntry("Fake_ZLam", "#Lambda fake", "lep"); - mLegendZD->AddEntry("Zsv_MC_Lam", "#Lambda MC", "f"); - + mCanvasZD->SetLogy(); + mLegendZD = std::make_unique(0.8, 0.64, 0.95, 0.8); + mLegendZD->SetHeader(Form("%zu events PP ", mKineReader->getNEvents(0)), "C"); + for (int i = 0; i < 3; i++) { + if (i == 0) + mEffGoodZ[i]->Draw("pz"); + else { + mEffGoodZ[i]->Draw("pz same"); + mEffFakeZ[i]->Draw("pz same"); + mLegendZD->AddEntry(Form("Good_Z%s", particleToanalize[i]), Form("%s_good", name[i]), "lep"); + mLegendZD->AddEntry(Form("Fake_Z%s", particleToanalize[i]), Form("%s_fake", name[i]), "lep"); + } + } mLegendZD->Draw(); - mCanvasZD->SaveAs("eff_ZD_sec_MC.png"); + mCanvasZD->SaveAs("eff_ZD_sec.png"); mPtResolution->SetName("#it{p}_{T} resolution"); mPtResolution->SetTitle(";#Delta p_{T}/p_{T_{MC}} ;Entries"); @@ -1446,11 +1197,14 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) for (int iH{0}; iH < 4; ++iH) { canvasPtfake->cd(iH + 1); - mEffFakePtsK[iH]->Draw(); - mEffFakePtsLam[iH]->Draw("same"); - mEffFakePtsIperT[iH]->Draw("same"); - mEffFakePt->Draw("same"); - mEffFakePts[iH]->Draw("same"); + for (int v = 0; v < 4; v++) { + if (v == 0) + canvasPtfake->cd(iH + 1); + if (v == 0) + mEffFakePts[v][iH]->Draw(); + else + mEffFakePts[v][iH]->Draw("same"); + } gPad->BuildLegend(); gPad->SetGrid(); gPad->SetTitle(Form("#it{p}_{T}, Fake Tracks, layer %d", iH)); @@ -1463,88 +1217,98 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) for (int iH{0}; iH < 4; ++iH) { canvasPtGood->cd(iH + 1); - mEffGoodPtsK[iH]->Draw(); - mEffGoodPtsLam[iH]->Draw("same"); - mEffGoodPtsIperT[iH]->Draw("same"); - mEffPt->Draw("same"); - mEffGoodPts[iH]->Draw("same"); + for (int v = 0; v < 4; v++) { + if (v == 0) + canvasPtGood->cd(iH + 1); + if (v == 0) + mEffGoodPts[v][iH]->Draw(); + else + mEffGoodPts[v][iH]->Draw("same"); + } gPad->BuildLegend(); gPad->SetGrid(); gPad->SetTitle(Form("#it{p}_{T}, Good Tracks, layer %d", iH)); gPad->SetName(Form("#it{p}_{T}, Good Tracks, layer %d", iH)); } - canvasPtGood->SaveAs("PtforPartGood.png", "recreate"); auto canvasEtafake = new TCanvas("canvasEtafake", "Fake Eta", 1600, 1000); canvasEtafake->Divide(2, 2); for (int iH{0}; iH < 4; ++iH) { canvasEtafake->cd(iH + 1); - mEffFakeEtasK[iH]->Draw(); - mEffFakeEtasLam[iH]->Draw("same"); - mEffFakeEtasIperT[iH]->Draw("same"); - mEffFakeEta->Draw("same"); - mEffFakeEtas[iH]->Draw("same"); + for (int v = 0; v < 4; v++) { + if (v == 0) + canvasEtafake->cd(iH + 1); + if (v == 0) + mEffFakeEtas[v][iH]->Draw(); + else + mEffFakeEtas[v][iH]->Draw("same"); + } gPad->BuildLegend(); gPad->SetGrid(); - gPad->SetTitle(Form("#it{p}_{T}, Fake Tracks, layer %d", iH)); - gPad->SetName(Form("#it{p}_{T}, Fake Tracks, layer %d", iH)); + gPad->SetTitle(Form("#eta, Fake Tracks, layer %d", iH)); + gPad->SetName(Form("#eta, Fake Tracks, layer %d", iH)); } - canvasEtafake->SaveAs("EtaforPartFake.png", "recreate"); - auto canvasEtaGood = new TCanvas("canvasEtaGood", "Good Eta", 1600, 1000); canvasEtaGood->Divide(2, 2); for (int iH{0}; iH < 4; ++iH) { canvasEtaGood->cd(iH + 1); - mEffGoodEtasK[iH]->Draw(); - mEffGoodEtasLam[iH]->Draw("same"); - mEffGoodEtasIperT[iH]->Draw("same"); - mEffEta->Draw("same"); - mEffGoodEtas[iH]->Draw("same"); + for (int v = 0; v < 4; v++) { + if (v == 0) + canvasEtaGood->cd(iH + 1); + if (v == 0) + mEffGoodEtas[v][iH]->Draw(); + else + mEffGoodEtas[v][iH]->Draw("same"); + } gPad->BuildLegend(); gPad->SetGrid(); gPad->SetTitle(Form("#eta, Good Tracks, layer %d", iH)); gPad->SetName(Form("#eta, Good Tracks, layer %d", iH)); } - canvasEtaGood->SaveAs("EtaforPartGood.png", "recreate"); - - auto canvasClusterFake = new TCanvas("canvasClusterFake", "canvasClusterFake", 1600, 1000); - canvasClusterFake->Divide(3, 1); - canvasClusterFake->cd(1); - Histo[6].SetTitle("Secondary tracks, mother particle:_{#Lambda}^{3}H"); - Histo[6].Draw("hist"); - canvasClusterFake->cd(2); - Histo[7].SetTitle("Secondary tracks, mother particle: #Lambda"); - Histo[7].Draw("hist"); - canvasClusterFake->cd(3); - Histo[8].SetTitle("Secondary tracks, mother particle: k^{0}_{s} "); - Histo[8].Draw("hist"); - canvasClusterFake->SaveAs("CluFake.png", "recreate"); auto canvasI = new TCanvas("canvasI", "canvasI", 1600, 1000); canvasI->cd(); - mIperTClusterfake->Draw("COLZ"); + mClusterFake[0]->Draw("COLZ"); canvasI->SaveAs("Iper2D.png", "recreate"); auto canvasL = new TCanvas("canvasL", "canvasL", 1600, 1000); canvasL->cd(); - mLamClusterfake->Draw("COLZ"); + mClusterFake[1]->Draw("COLZ"); canvasL->SaveAs("Lam2D.png", "recreate"); auto canvasK = new TCanvas("canvasK", "canvasK", 1600, 1000); canvasK->cd(); - mKClusterfake->Draw("COLZ"); + mClusterFake[2]->Draw("COLZ"); canvasK->SaveAs("K2D.png", "recreate"); - auto canvaspdg = new TCanvas("canvaspdg", "canvaspdg", 1600, 1000); - canvaspdg->cd(); - Histo[9].Draw(); - canvaspdg->SaveAs("pdg.png", "recreate"); + auto canvasZProd = new TCanvas("canvasZProd", "canvasZProd", 1600, 1000); + canvasZProd->cd(); + processvsZ->Draw("COLZ"); + canvasZProd->SaveAs("prodvsZ.png", "recreate"); + auto canvasRadProd = new TCanvas("canvasRadProd", "canvasRadProd", 1600, 1000); + canvasRadProd->cd(); + processvsRad->Draw("COLZ"); + canvasRadProd->SaveAs("prodvsRad.png", "recreate"); + auto canvasRadProdO = new TCanvas("canvasRadProdO", "canvasRadProdO", 1600, 1000); + canvasRadProdO->cd(); + processvsRadOther->Draw("COLZ"); + canvasRadProdO->SaveAs("prodvsRadO.png", "recreate"); + auto canvasRadProNOTr = new TCanvas("canvasRadProNOTr", "canvasRadProNOTr", 1600, 1000); + canvasRadProNOTr->cd(); + processvsRadNotTracked->Draw("COLZ"); + canvasRadProNOTr->SaveAs("prodvsRadNoTr.png", "recreate"); + auto canvasEtaProNOTr = new TCanvas("canvasEtaProNOTr", "canvasEtaProNOTr", 1600, 1000); + canvasEtaProNOTr->cd(); + processvsEtaNotTracked->Draw("COLZ"); + canvasEtaProNOTr->SaveAs("prodvsEtaNoTr.png", "recreate"); fout.cd(); mCanvasPt->Write(); mCanvasEta->Write(); + mCanvasPtSec->Write(); + mCanvasEtaSec->Write(); mCanvasPtRes->Write(); mCanvasPtRes2->Write(); mCanvasPtRes3->Write(); @@ -1559,7 +1323,6 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) canvasI->Write(); canvasL->Write(); canvasK->Write(); - canvaspdg->Write(); fout.Close(); } From d1c416f510585552a86aa4b9225823cc68b0692c Mon Sep 17 00:00:00 2001 From: Roberta-Ferioli Date: Mon, 11 Sep 2023 22:48:47 +0200 Subject: [PATCH 12/19] ITS-Study: completed secondary tracks efficiency study, started studies on fake clusters and Pt resolution --- .../ITS/postprocessing/studies/src/TrackCheck.cxx | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 89310faa53102..962d9513ea113 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -152,7 +152,7 @@ class TrackCheckStudy : public Task std::unique_ptr mEffFakePtSec; std::unique_ptr mEffEtaSec; // Eff vs Eta secondary std::unique_ptr mEffFakeEtaSec; - + std::unique_ptr mPtResolution; // Pt resolution for both primary and secondary std::unique_ptr mPtResolution2D; std::unique_ptr mPtResolutionSec; @@ -254,7 +254,7 @@ void TrackCheckStudy::init(InitContext& ic) mDenominatorEta = std::make_unique("denominatorEta", ";#eta;Number of tracks", 60, -3, 3); mDenominatorPtSec = std::make_unique("denominatorPtSec", ";#it{p}_{T} (GeV/#it{c});Den", pars.effHistBins, xbins.data()); mDenominatorEtaSec = std::make_unique("denominatorEtaSec", ";#eta;Number of tracks", 60, -3, 3); - + processvsZ = std::make_unique("Process", ";z_{SV} [cm]; production process", 100, -50, 50., 50, 0, 50); processvsRad = std::make_unique("ProcessR", ";decay radius [cm]; production process", 100, 0, 25., 50, 0, 50); processvsRadOther = std::make_unique("ProcessRO", ";decay radius [cm]; production process", 200, 0, 25., 50, 0, 50); @@ -282,7 +282,6 @@ void TrackCheckStudy::init(InitContext& ic) mFakeEtas[i].resize(4); mTotEtas[i].resize(4); } - for (int ii = 0; ii < 4; ii++) { mGoodRad[ii] = std::make_unique(Form("goodRad_%s", particleToanalize[ii]), ";z_{SV} [cm];Number of tracks", 100, 0., 20.); @@ -367,9 +366,9 @@ void TrackCheckStudy::init(InitContext& ic) legends2Fake.resize(4); legends3Fake.resize(4); - for (int iH{4}; iH < 8; ++iH) { - // check distributions on layers of fake clusters for tracks of different lengths. - // Different histograms if the correct cluster exist or not + for (int iH{4}; iH < 8; ++iH) { + // check distributions on layers of fake clusters for tracks of different lengths. + // Different histograms if the correct cluster exist or not for (int jj = 0; jj < 3; jj++) { histLength[iH - 4][jj] = new TH1I(Form("trk_len_%d_%s", iH, name[jj]), Form("#exists cluster %s", name), 7, -.5, 6.5); histLength[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); @@ -653,7 +652,7 @@ void TrackCheckStudy::process() mFakeEtas[idxPart][nlayer]->Fill(part.eta); } } - + if (pdgcode != 1010010030 && pdgcode != 3122 && pdgcode != 310 && pdgcode != -1010010030 && pdgcode != -310 && pdgcode != -3122) { idxPart = 3; processvsRadOther->Fill(rad, part.prodProcess); @@ -719,7 +718,7 @@ void TrackCheckStudy::process() const_cast(lab).get(TrackID, EvID, SrcID, fakec); double intHisto = 0; for (int hg = 0; hg < 7; hg++) { - if (mParticleInfo[SrcID][EvID][TrackID].pdg == PdgcodeClusterFake[hg] || mParticleInfo[SrcID][EvID][TrackID].pdg == -1*(PdgcodeClusterFake[hg])) + if (mParticleInfo[SrcID][EvID][TrackID].pdg == PdgcodeClusterFake[hg] || mParticleInfo[SrcID][EvID][TrackID].pdg == -1 * (PdgcodeClusterFake[hg])) intHisto = hg + 0.5; } if (idxPart < 3) From 88119c44159717295abfb9d6c695ac4debd392c4 Mon Sep 17 00:00:00 2001 From: Matteo Concas Date: Fri, 13 Oct 2023 14:02:33 +0200 Subject: [PATCH 13/19] Update Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx --- Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 962d9513ea113..5c3ebd46bfb0c 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -370,7 +370,7 @@ void TrackCheckStudy::init(InitContext& ic) // check distributions on layers of fake clusters for tracks of different lengths. // Different histograms if the correct cluster exist or not for (int jj = 0; jj < 3; jj++) { - histLength[iH - 4][jj] = new TH1I(Form("trk_len_%d_%s", iH, name[jj]), Form("#exists cluster %s", name), 7, -.5, 6.5); + histLength[iH - 4][jj] = new TH1I(Form("trk_len_%d_%s", iH, name[jj]), Form("#exists cluster %s", name[jj]), 7, -.5, 6.5); histLength[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); histLength[iH - 4][jj]->SetLineColor(colorArr[jj] - 9); histLengthNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_nocl_%s", iH, name[jj]), Form("#slash{#exists} cluster %s", name), 7, -.5, 6.5); From 77360ea9f01f530b83bdca5beeaee8cd58c7b889 Mon Sep 17 00:00:00 2001 From: Matteo Concas Date: Fri, 13 Oct 2023 14:02:39 +0200 Subject: [PATCH 14/19] Update Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx --- Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 5c3ebd46bfb0c..91ecb77dad44d 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -373,7 +373,7 @@ void TrackCheckStudy::init(InitContext& ic) histLength[iH - 4][jj] = new TH1I(Form("trk_len_%d_%s", iH, name[jj]), Form("#exists cluster %s", name[jj]), 7, -.5, 6.5); histLength[iH - 4][jj]->SetFillColor(colorArr[jj] - 9); histLength[iH - 4][jj]->SetLineColor(colorArr[jj] - 9); - histLengthNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_nocl_%s", iH, name[jj]), Form("#slash{#exists} cluster %s", name), 7, -.5, 6.5); + histLengthNoCl[iH - 4][jj] = new TH1I(Form("trk_len_%d_nocl_%s", iH, name[jj]), Form("#slash{#exists} cluster %s", name[jj]), 7, -.5, 6.5); histLengthNoCl[iH - 4][jj]->SetFillColor(colorArr[jj] + 1); histLengthNoCl[iH - 4][jj]->SetLineColor(colorArr[jj] + 1); if (jj == 0) From 138db07b121650e1d31be2df47040e6341a48be3 Mon Sep 17 00:00:00 2001 From: Matteo Concas Date: Fri, 13 Oct 2023 14:14:58 +0200 Subject: [PATCH 15/19] Update Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx --- Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 91ecb77dad44d..11ed96d87de39 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -910,7 +910,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) for (int bb = 0; bb < 4; bb++) { setEfficiencyGraph(mEffGoodPts[aa][bb], Form("EffPtGood_%sl%d", particleToanalize[aa], bb), Form("Good Sec Tracks_%s, L%d" ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", - bb, particleToanalize[aa]), + particleToanalize[aa], bb), colorArr[aa]); setEfficiencyGraph(mEffFakePts[aa][bb], Form("EffPtFake_%sl%d", particleToanalize[aa], bb), Form("Fake Sec Tracks_%s, L%d" ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", From a5b333669a584eafbdecfb19015f200f858bf73f Mon Sep 17 00:00:00 2001 From: Matteo Concas Date: Fri, 13 Oct 2023 14:15:04 +0200 Subject: [PATCH 16/19] Update Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx --- Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index 11ed96d87de39..d5849da57f33a 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -914,7 +914,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) colorArr[aa]); setEfficiencyGraph(mEffFakePts[aa][bb], Form("EffPtFake_%sl%d", particleToanalize[aa], bb), Form("Fake Sec Tracks_%s, L%d" ";#it{p}_{T} (GeV/#it{c});efficiency secondary particle ", - bb, particleToanalize[aa]), + particleToanalize[aa], bb), colorArr[aa]); setEfficiencyGraph(mEffGoodEtas[aa][bb], Form("EffEtaGood_%sl%d", particleToanalize[aa], bb), Form("Good Sec Tracks_%s, L%d" ";#eta ;efficiency secondary particle ", From 89964f1b81884dfe76179fcf9b0103b2a0ed26d3 Mon Sep 17 00:00:00 2001 From: Matteo Concas Date: Fri, 13 Oct 2023 14:15:09 +0200 Subject: [PATCH 17/19] Update Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx --- Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index d5849da57f33a..c665792413df1 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -922,7 +922,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) colorArr[aa]); setEfficiencyGraph(mEffFakeEtas[aa][bb], Form("EffEtaFake_%sl%d", particleToanalize[aa], bb), Form("Fake Sec Tracks_%s, L%d" ";#eta ;efficiency secondary particle ", - bb, particleToanalize[aa]), + particleToanalize[aa], bb), colorArr[aa]); fout.WriteTObject(mEffGoodPts[aa][bb].get()); From 42323210a7aa7d28e490c411df0535b422b70b3b Mon Sep 17 00:00:00 2001 From: Matteo Concas Date: Fri, 13 Oct 2023 14:15:15 +0200 Subject: [PATCH 18/19] Update Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx --- Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index c665792413df1..a7be32aafdd1d 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -918,7 +918,7 @@ void TrackCheckStudy::endOfStream(EndOfStreamContext& ec) colorArr[aa]); setEfficiencyGraph(mEffGoodEtas[aa][bb], Form("EffEtaGood_%sl%d", particleToanalize[aa], bb), Form("Good Sec Tracks_%s, L%d" ";#eta ;efficiency secondary particle ", - bb, particleToanalize[aa]), + particleToanalize[aa], bb), colorArr[aa]); setEfficiencyGraph(mEffFakeEtas[aa][bb], Form("EffEtaFake_%sl%d", particleToanalize[aa], bb), Form("Fake Sec Tracks_%s, L%d" ";#eta ;efficiency secondary particle ", From c3b6b626f8dce123837de284995088790277b70b Mon Sep 17 00:00:00 2001 From: Matteo Concas Date: Fri, 13 Oct 2023 17:08:25 +0200 Subject: [PATCH 19/19] Update Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx --- Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx index a7be32aafdd1d..194b6bbaec363 100644 --- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx +++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/TrackCheck.cxx @@ -542,7 +542,7 @@ void TrackCheckStudy::process() trackID = 0; for (auto& part : evInfo) { - if (ProcessName[part.prodProcess] == " ") + if (strcmp(ProcessName[part.prodProcess], " ")) ProcessName[part.prodProcess] = part.prodProcessName; if ((part.clusters & 0x7f) == mMask) { // part.clusters != 0x3f && part.clusters != 0x3f << 1 &&