diff --git a/DPG/Tasks/AOTTrack/PID/HMPID/CMakeLists.txt b/DPG/Tasks/AOTTrack/PID/HMPID/CMakeLists.txt index 763c9105528..96bb9ab18c4 100644 --- a/DPG/Tasks/AOTTrack/PID/HMPID/CMakeLists.txt +++ b/DPG/Tasks/AOTTrack/PID/HMPID/CMakeLists.txt @@ -10,12 +10,17 @@ # or submit itself to any jurisdiction. # HMPID -o2physics_add_dpl_workflow(pid-hmpid-qa - SOURCES qaHMPID.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore +o2physics_add_dpl_workflow(hmpid-qa + SOURCES hmpidQa.cxx + PUBLIC_LINK_LIBRARIES O2::HMPIDBase O2Physics::AnalysisCore COMPONENT_NAME Analysis) -o2physics_add_dpl_workflow(pid-hmpid - SOURCES analysisHMPID.cxx +o2physics_add_dpl_workflow(hmpid-table-producer + SOURCES hmpidTableProducer.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(hmpid-deuteron + SOURCES hmpidDeuteron.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::ReconstructionDataFormats O2Physics::AnalysisCore + COMPONENT_NAME Analysis) diff --git a/DPG/Tasks/AOTTrack/PID/HMPID/analysisHMPID.cxx b/DPG/Tasks/AOTTrack/PID/HMPID/analysisHMPID.cxx deleted file mode 100644 index c5a6b9d0597..00000000000 --- a/DPG/Tasks/AOTTrack/PID/HMPID/analysisHMPID.cxx +++ /dev/null @@ -1,137 +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. - -// O2 includes -#include "ReconstructionDataFormats/Track.h" -#include "Framework/runDataProcessing.h" -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/HistogramRegistry.h" -#include "Framework/RunningWorkflowInfo.h" -#include "ReconstructionDataFormats/TrackParametrization.h" -#include "Common/DataModel/PIDResponse.h" -#include "Common/Core/PID/PIDTOF.h" -#include "Common/TableProducer/PID/pidTOFBase.h" -#include "ReconstructionDataFormats/PID.h" -#include "Common/Core/trackUtilities.h" -#include "ReconstructionDataFormats/DCA.h" -#include "Framework/ASoAHelpers.h" -#include "Framework/ASoA.h" -#include "Common/DataModel/EventSelection.h" -#include "Common/DataModel/TrackSelectionTables.h" - -#include - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -namespace o2::aod -{ - -namespace variables_table // declaration of columns to create -{ -DECLARE_SOA_COLUMN(ChAngle, chAngle, float); -DECLARE_SOA_COLUMN(Phi, phi, float); -DECLARE_SOA_COLUMN(Eta, eta, float); -DECLARE_SOA_COLUMN(MomentumHMPID, momentumHMPID, float); -DECLARE_SOA_COLUMN(MomentumTrack, momentumTrack, float); -DECLARE_SOA_COLUMN(Xtrack, xtrack, float); -DECLARE_SOA_COLUMN(Ytrack, ytrack, float); -DECLARE_SOA_COLUMN(Xmip, xmip, float); -DECLARE_SOA_COLUMN(Ymip, ymip, float); -DECLARE_SOA_COLUMN(Nphotons, nphotons, float); -DECLARE_SOA_COLUMN(ChargeMIP, chargeMIP, float); -DECLARE_SOA_COLUMN(ClusterSize, clustersize, float); -DECLARE_SOA_COLUMN(Chamber, chamber, float); -DECLARE_SOA_COLUMN(Photons_charge, photons_charge, float[10]); - -DECLARE_SOA_COLUMN(EtaTrack, etatrack, float); -DECLARE_SOA_COLUMN(PhiTrack, phitrack, float); - -DECLARE_SOA_COLUMN(ITSNcluster, itsNcluster, float); -DECLARE_SOA_COLUMN(TPCNcluster, tpcNcluster, float); -DECLARE_SOA_COLUMN(TPCNClsCrossedRows, tpcNClsCrossedRows, float); -DECLARE_SOA_COLUMN(TPCchi2, tpcChi2, float); -DECLARE_SOA_COLUMN(ITSchi2, itsChi2, float); - -DECLARE_SOA_COLUMN(DCAxy, dcaxy, float); -DECLARE_SOA_COLUMN(DCAz, dcaz, float); - -DECLARE_SOA_COLUMN(TPCNSigmaPi, tpcNsigmaPi, float); -DECLARE_SOA_COLUMN(TOFNSigmaPi, tofNsigmaPi, float); -DECLARE_SOA_COLUMN(TPCNSigmaKa, tpcNsigmaKa, float); -DECLARE_SOA_COLUMN(TOFNSigmaKa, tofNsigmaKa, float); -DECLARE_SOA_COLUMN(TPCNSigmaPr, tpcNsigmaPr, float); -DECLARE_SOA_COLUMN(TOFNSigmaPr, tofNsigmaPr, float); -DECLARE_SOA_COLUMN(TPCNSigmaDe, tpcNsigmaDe, float); -DECLARE_SOA_COLUMN(TOFNSigmaDe, tofNsigmaDe, float); - -} // namespace variables_table - -DECLARE_SOA_TABLE(HMPID_analysis, "AOD", "HMPIDANALYSIS", - variables_table::ChAngle, variables_table::Phi, variables_table::Eta, variables_table::MomentumHMPID, - variables_table::MomentumTrack, variables_table::Xtrack, variables_table::Ytrack, variables_table::Xmip, - variables_table::Ymip, variables_table::Nphotons, variables_table::ChargeMIP, variables_table::ClusterSize, - variables_table::Chamber, variables_table::Photons_charge, variables_table::EtaTrack, variables_table::PhiTrack, - variables_table::ITSNcluster, variables_table::TPCNcluster, variables_table::TPCNClsCrossedRows, - variables_table::TPCchi2, variables_table::ITSchi2, variables_table::DCAxy, variables_table::DCAz, - variables_table::TPCNSigmaPi, variables_table::TOFNSigmaPi, variables_table::TPCNSigmaKa, variables_table::TOFNSigmaKa, - variables_table::TPCNSigmaPr, variables_table::TOFNSigmaPr, variables_table::TPCNSigmaDe, variables_table::TOFNSigmaDe); -} // namespace o2::aod - -struct pidHmpidAnalysis { - - Produces HMPID_analysis; - - // using TrackCandidates = soa::Join; - - using CollisionCandidates = o2::soa::Join; - - using TrackCandidates = soa::Join; - - void process(const aod::HMPIDs& hmpids, - TrackCandidates const&, - CollisionCandidates const&) - { - - for (const auto& t : hmpids) { - if (t.track_as().isGlobalTrack() != (uint8_t) true) { - continue; - } - - const auto& track = t.track_as(); - - if (!track.hasITS() || !track.hasTPC() || !track.hasTOF()) { - continue; - } - - float hmpidPhotsCharge2[10]; - - for (int i = 0; i < 10; i++) { - hmpidPhotsCharge2[i] = t.hmpidPhotsCharge()[i]; - } - - /////FILL TABLE - HMPID_analysis(t.hmpidSignal(), t.track_as().phi(), t.track_as().eta(), t.hmpidMom(), - track.p(), t.hmpidXTrack(), t.hmpidYTrack(), t.hmpidXMip(), - t.hmpidYMip(), t.hmpidNPhotons(), t.hmpidQMip(), (t.hmpidClusSize() % 1000000) / 1000, t.hmpidClusSize() / 1000000, - hmpidPhotsCharge2, track.eta(), track.phi(), track.itsNCls(), track.tpcNClsFound(), track.tpcNClsCrossedRows(), - track.tpcChi2NCl(), track.itsChi2NCl(), track.dcaXY(), track.dcaZ(), - track.tpcNSigmaPi(), track.tofNSigmaPi(), track.tpcNSigmaKa(), track.tofNSigmaKa(), - track.tpcNSigmaPr(), track.tofNSigmaPr(), track.tpcNSigmaDe(), track.tofNSigmaDe()); - } - } -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfg) { return WorkflowSpec{adaptAnalysisTask(cfg)}; } diff --git a/DPG/Tasks/AOTTrack/PID/HMPID/hmpidDeuteron.cxx b/DPG/Tasks/AOTTrack/PID/HMPID/hmpidDeuteron.cxx new file mode 100644 index 00000000000..98ea08f7add --- /dev/null +++ b/DPG/Tasks/AOTTrack/PID/HMPID/hmpidDeuteron.cxx @@ -0,0 +1,189 @@ +// 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. + +#include "tableHMPID.h" + +#include +#include + +#include +#include + +using namespace o2; +using namespace o2::framework; + +struct HmpidDeuteron { + HistogramRegistry registryDA{"registryDA", {}, OutputObjHandlingPolicy::AnalysisObject}; + + Configurable nsigmaTPCMin{"nsigmaTPCMin", -3.0, "nsigmaTPCMin"}; + Configurable nsigmaTPCMax{"nsigmaTPCMax", +3.0, "nsigmaTPCMax"}; + Configurable nsigmaTOFMin{"nsigmaTOFMin", -3.0, "nsigmaTOFMin"}; + Configurable nsigmaTOFMax{"nsigmaTOFMax", +3.5, "nsigmaTOFMax"}; + Configurable minReqClusterITS{"minReqClusterITS", 4.0, "min number of clusters required in ITS"}; + Configurable minTPCnClsFound{"minTPCnClsFound", 50.0f, "minTPCnClsFound"}; + Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; + Configurable maxChi2ITS{"maxChi2ITS", 36.0f, "max chi2 per cluster ITS"}; + Configurable maxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; + Configurable maxDCAxy{"maxDCAxy", 0.5f, "maxDCAxy"}; + Configurable maxDCAz{"maxDCAz", 0.5f, "maxDCAz"}; + + void init(InitContext const&) + { + // Deuteron Pos + registryDA.add("incomingDe_Pos_8cm", "incomingDe_Pos_8cm", HistType::kTH1F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}}); + registryDA.add("incomingDe_Pos_4cm", "incomingDe_Pos_4cm", HistType::kTH1F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}}); + + registryDA.add("De_Pos_deltaR_8cm", "De_Pos_deltaR_8cm", HistType::kTH1F, {{300, 0.0, 30.0, "#Delta R (cm)"}}); + registryDA.add("De_Pos_deltaR_4cm", "De_Pos_deltaR_4cm", HistType::kTH1F, {{300, 0.0, 30.0, "#Delta R (cm)"}}); + + registryDA.add("survivingDe_Pos_8cm", "survivingDe_Pos_8cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {300, 0.0, 30.0, "#Delta R (cm)"}}); + registryDA.add("survivingDe_Pos_4cm", "survivingDe_Pos_4cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {300, 0.0, 30.0, "#Delta R (cm)"}}); + registryDA.add("De_Pos_Q_8cm", "De_Pos_Q_8cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {200, 0.0, 2000.0, "Q (ADC)"}}); + registryDA.add("De_Pos_Q_4cm", "De_Pos_Q_4cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {200, 0.0, 2000.0, "Q (ADC)"}}); + registryDA.add("De_Pos_ClsSize_8cm", "De_Pos_ClsSize_8cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, 0.0, 20., "Cls size"}}); + registryDA.add("De_Pos_ClsSize_4cm", "De_Pos_ClsSize_4cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, 0.0, 20.0, "Cls size"}}); + registryDA.add("De_Pos_momentum", "De_Pos_momentum", HistType::kTH2F, {{100, 0.0, 5.0, "#it{p}_{vtx} (GeV/#it{c})"}, {100, 0.0, 5.0, "#it{p}_{hmpid} (GeV/#it{c})"}}); + + registryDA.add("nSigmaTPC_vs_momHMPID_noCut_DePos", "nSigmaTPC_vs_momHMPID_noCut_DePos", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, -5., 5.0, "n#sigma_TPC"}}); + registryDA.add("nSigmaTOF_vs_momHMPID_noCut_DePos", "nSigmaTOF_vs_momHMPID_noCut_DePos", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, -5., 5.0, "n#sigma_TOF"}}); + registryDA.add("nSigmaTPC_vs_momHMPID_Cut_DePos", "nSigmaTPC_vs_momHMPID_Cut_DePos", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, -5., 5.0, "n#sigma_TPC"}}); + registryDA.add("nSigmaTOF_vs_momHMPID_Cut_DePos", "nSigmaTOF_vs_momHMPID_Cut_DePos", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, -5., 5.0, "n#sigma_TOF"}}); + + // Deuteron Neg + registryDA.add("incomingDe_Neg_8cm", "incomingDe_Neg_8cm", HistType::kTH1F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}}); + registryDA.add("incomingDe_Neg_4cm", "incomingDe_Neg_4cm", HistType::kTH1F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}}); + + // plot aggiunti + registryDA.add("De_Neg_deltaR_8cm", "De_Neg_deltaR_8cm", HistType::kTH1F, {{300, 0.0, 30.0, "#Delta R (cm)"}}); + registryDA.add("De_Neg_deltaR_4cm", "De_Neg_deltaR_4cm", HistType::kTH1F, {{300, 0.0, 30.0, "#Delta R (cm)"}}); + + registryDA.add("survivingDe_Neg_8cm", "survivingDe_Neg_8cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {300, 0.0, 30.0, "#Delta R (cm)"}}); + registryDA.add("survivingDe_Neg_4cm", "survivingDe_Neg_4cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {300, 0.0, 30.0, "#Delta R (cm)"}}); + registryDA.add("De_Neg_Q_8cm", "De_Neg_Q_8cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {200, 0.0, 2000.0, "Q (ADC)"}}); + registryDA.add("De_Neg_Q_4cm", "De_Neg_Q_4cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {200, 0.0, 2000.0, "Q (ADC)"}}); + registryDA.add("De_Neg_ClsSize_8cm", "De_Neg_ClsSize_8cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, 0.0, 20.0, "Cls size"}}); + registryDA.add("De_Neg_ClsSize_4cm", "De_Neg_ClsSize_4cm", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, 0.0, 20.0, "Cls size"}}); + registryDA.add("De_Neg_momentum", "De_Neg_momentum", HistType::kTH2F, {{100, 0.0, 5.0, "#it{p}_{vtx} (GeV/#it{c})"}, {100, 0.0, 5.0, "#it{p}_{hmpid} (GeV/#it{c})"}}); + + registryDA.add("nSigmaTPC_vs_momHMPID_noCut_DeNeg", "nSigmaTPC_vs_momHMPID_noCut_DeNeg", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, -5.0, 5.0, "n#sigma_TPC"}}); + registryDA.add("nSigmaTOF_vs_momHMPID_noCut_DeNeg", "nSigmaTOF_vs_momHMPID_noCut_DeNeg", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, -5., 5.0, "n#sigma_TOF"}}); + registryDA.add("nSigmaTPC_vs_momHMPID_Cut_DeNeg", "nSigmaTPC_vs_momHMPID_Cut_DeNeg", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, -5., 5.0, "n#sigma_TPC"}}); + registryDA.add("nSigmaTOF_vs_momHMPID_Cut_DeNeg", "nSigmaTOF_vs_momHMPID_Cut_DeNeg", HistType::kTH2F, {{490, 0.1, 5.0, "#it{p} (GeV/#it{c})"}, {20, -5., 5.0, "n#sigma_TOF"}}); + + registryDA.add("hmpidCkovvsMom", "hmpidCkovvsMom", kTH2F, {{500, 0, 10., "#it{p} (GeV/#it{c})"}, {800, 0., 0.8, "#theta_{Ch} (rad)"}}); + } + + void process(aod::HmpidAnalysis const& hmpidTable) + { + for (const auto& hmpid : hmpidTable) { + + // filters on primary tracks + if (hmpid.itsNCluster() < minReqClusterITS) + continue; + if (hmpid.tpcNCluster() < minTPCnClsFound) + continue; + if (hmpid.tpcNClsCrossedRows() < minNCrossedRowsTPC) + continue; + if (hmpid.tpcChi2() > maxChi2TPC) + continue; + if (hmpid.itsChi2() > maxChi2ITS) + continue; + if (TMath::Abs(hmpid.dcaXY()) > maxDCAxy) + continue; + if (TMath::Abs(hmpid.dcaZ()) > maxDCAz) + continue; + + // plots nsigma before cuts + if (hmpid.momentumHmpid() > 0) { + registryDA.fill(HIST("nSigmaTPC_vs_momHMPID_noCut_DePos"), std::fabs(hmpid.momentumHmpid()), hmpid.tpcNSigmaDe()); + registryDA.fill(HIST("nSigmaTOF_vs_momHMPID_noCut_DePos"), std::fabs(hmpid.momentumHmpid()), hmpid.tofNSigmaDe()); + } + + if (hmpid.momentumHmpid() < 0) { + registryDA.fill(HIST("nSigmaTPC_vs_momHMPID_noCut_DeNeg"), std::fabs(hmpid.momentumHmpid()), hmpid.tpcNSigmaDe()); + registryDA.fill(HIST("nSigmaTOF_vs_momHMPID_noCut_DeNeg"), std::fabs(hmpid.momentumHmpid()), hmpid.tofNSigmaDe()); + } + + // deuteron candidate cuts + if (hmpid.tpcNSigmaDe() < nsigmaTPCMin || hmpid.tpcNSigmaDe() > nsigmaTPCMax) + continue; + + if (hmpid.momentumHmpid() > 0) + registryDA.fill(HIST("nSigmaTPC_vs_momHMPID_Cut_DePos"), std::fabs(hmpid.momentumHmpid()), hmpid.tpcNSigmaDe()); + else + registryDA.fill(HIST("nSigmaTPC_vs_momHMPID_Cut_DeNeg"), std::fabs(hmpid.momentumHmpid()), hmpid.tpcNSigmaDe()); + + if (hmpid.tofNSigmaDe() < nsigmaTOFMin || hmpid.tofNSigmaDe() > nsigmaTOFMax) + continue; + + if (hmpid.momentumHmpid() > 0) + registryDA.fill(HIST("nSigmaTOF_vs_momHMPID_Cut_DePos"), std::fabs(hmpid.momentumHmpid()), hmpid.tofNSigmaDe()); + else + registryDA.fill(HIST("nSigmaTOF_vs_momHMPID_Cut_DeNeg"), std::fabs(hmpid.momentumHmpid()), hmpid.tofNSigmaDe()); + + // plot changle vs p + registryDA.fill(HIST("hmpidCkovvsMom"), hmpid.momentumHmpid(), hmpid.chAngle()); + + // absorbers + const float dx = hmpid.xTrack() - hmpid.xMip(); + const float dy = hmpid.yTrack() - hmpid.yMip(); + const float dr = TMath::Sqrt(dx * dx + dy * dy); + + int abs4cm = 2, abs8cm = 4; + bool hmpidAbs8cm = true, hmpidAbs4cm = true; + + if (hmpid.momentumHmpid() > 0) { + registryDA.fill(HIST("De_Pos_momentum"), hmpid.momentumTrack(), std::fabs(hmpid.momentumHmpid())); + + if (hmpidAbs8cm && hmpid.chamber() == abs8cm) { + registryDA.fill(HIST("incomingDe_Pos_8cm"), std::fabs(hmpid.momentumHmpid())); + registryDA.fill(HIST("survivingDe_Pos_8cm"), std::fabs(hmpid.momentumHmpid()), dr); + registryDA.fill(HIST("De_Pos_Q_8cm"), std::fabs(hmpid.momentumHmpid()), hmpid.chargeMip()); + registryDA.fill(HIST("De_Pos_ClsSize_8cm"), std::fabs(hmpid.momentumHmpid()), hmpid.clusterSize()); + registryDA.fill(HIST("De_Pos_deltaR_8cm"), dr); + } + if (hmpidAbs4cm && hmpid.chamber() == abs4cm) { + registryDA.fill(HIST("incomingDe_Pos_4cm"), std::fabs(hmpid.momentumHmpid())); + registryDA.fill(HIST("survivingDe_Pos_4cm"), std::fabs(hmpid.momentumHmpid()), dr); + registryDA.fill(HIST("De_Pos_Q_4cm"), std::fabs(hmpid.momentumHmpid()), hmpid.chargeMip()); + registryDA.fill(HIST("De_Pos_ClsSize_4cm"), std::fabs(hmpid.momentumHmpid()), hmpid.clusterSize()); + registryDA.fill(HIST("De_Pos_deltaR_4cm"), dr); + } + } + + if (hmpid.momentumHmpid() < 0) { + registryDA.fill(HIST("De_Neg_momentum"), hmpid.momentumTrack(), std::fabs(hmpid.momentumHmpid())); + + if (hmpidAbs8cm && hmpid.chamber() == abs8cm) { + registryDA.fill(HIST("incomingDe_Neg_8cm"), std::fabs(hmpid.momentumHmpid())); + registryDA.fill(HIST("survivingDe_Neg_8cm"), std::fabs(hmpid.momentumHmpid()), dr); + registryDA.fill(HIST("De_Neg_Q_8cm"), std::fabs(hmpid.momentumHmpid()), hmpid.chargeMip()); + registryDA.fill(HIST("De_Neg_ClsSize_8cm"), std::fabs(hmpid.momentumHmpid()), hmpid.clusterSize()); + registryDA.fill(HIST("De_Neg_deltaR_8cm"), dr); + } + if (hmpidAbs4cm && hmpid.chamber() == abs4cm) { + registryDA.fill(HIST("incomingDe_Neg_4cm"), std::fabs(hmpid.momentumHmpid())); + registryDA.fill(HIST("survivingDe_Neg_4cm"), std::fabs(hmpid.momentumHmpid()), dr); + registryDA.fill(HIST("De_Neg_Q_4cm"), std::fabs(hmpid.momentumHmpid()), hmpid.chargeMip()); + registryDA.fill(HIST("De_Neg_ClsSize_4cm"), std::fabs(hmpid.momentumHmpid()), hmpid.clusterSize()); + registryDA.fill(HIST("De_Neg_deltaR_4cm"), dr); + } + } + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc), + }; +} diff --git a/DPG/Tasks/AOTTrack/PID/HMPID/hmpidQa.cxx b/DPG/Tasks/AOTTrack/PID/HMPID/hmpidQa.cxx new file mode 100644 index 00000000000..346fd643233 --- /dev/null +++ b/DPG/Tasks/AOTTrack/PID/HMPID/hmpidQa.cxx @@ -0,0 +1,1514 @@ +// 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. + +#include "tableHMPID.h" + +#include "Common/Core/PID/PIDTOF.h" +#include "Common/Core/trackUtilities.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/PIDResponse.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/TableProducer/PID/pidTOFBase.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::constants::physics; + +double expectedSignal(double mass, float mom) +{ + // expected theoretical values + + double chAngleTh = -999.; + + const double nMean = 1.288; // radiator mean refraction index + + double cosChAngleTh = (TMath::Sqrt(mass * mass + mom * mom)) / (nMean * mom); + if (cosChAngleTh > 1) + return chAngleTh; + + chAngleTh = TMath::ACos(cosChAngleTh); + + return chAngleTh; +} + +double expectedSigma(int iPart, float mom) +{ + double sigmaRing = 0; + const int nMaxSigmas = 6; + + // fit parameters from sigma extrapolation + double fitSigmaExtraPions[nMaxSigmas] = {42.8961, -49.8723, 26.2311, -6.59093, 0.754578, -0.0286546}; + double fitSigmaExtraKaons[nMaxSigmas] = {76.9786, -103.655, 61.7533, -18.7436, 2.87855, -0.178318}; + double fitSigmaExtraProtons[nMaxSigmas] = {299.466, -383.277, 201.127, -52.2554, 6.67285, -0.334106}; + + // create sigma vs p functions + TF1* sigmaVsMomPions = new TF1("sigmaVsMomPions", "pol5", 0., 6.); + TF1* sigmaVsMomKaons = new TF1("sigmaVsMomKaons", "pol5", 0., 6.); + TF1* sigmaVsMomProtons = new TF1("sigmaVsMomProtons", "pol5", 0., 6.); + + for (int i = 0; i < nMaxSigmas; i++) { + sigmaVsMomPions->SetParameter(i, fitSigmaExtraPions[i]); + sigmaVsMomKaons->SetParameter(i, fitSigmaExtraKaons[i]); + sigmaVsMomProtons->SetParameter(i, fitSigmaExtraProtons[i]); + } + + const int idPions = 0, idKaons = 1, idProtons = 2; + + if (iPart == idPions) { + sigmaRing = gRandom->Gaus(sigmaVsMomPions->Eval(mom) / 1000., 0.1 * sigmaVsMomPions->Eval(mom) / 1000.); + } + if (iPart == idKaons) { + sigmaRing = 0.8 * gRandom->Gaus(sigmaVsMomKaons->Eval(mom) / 1000., 0.15 * sigmaVsMomKaons->Eval(mom) / 1000.); + } + if (iPart == idProtons) { + sigmaRing = 0.6 * gRandom->Gaus(sigmaVsMomProtons->Eval(mom) / 1000., 0.1 * sigmaVsMomProtons->Eval(mom) / 1000.); + } + + delete sigmaVsMomPions; + delete sigmaVsMomKaons; + delete sigmaVsMomProtons; + + return sigmaRing; +} + +void getProbability(float hmpidSignal, float hmpidMomentum, double* probs) +{ + // Calculates probability to be a pion-kaon-proton with the "amplitude" method + // from the given Cerenkov angle and momentum assuming no initial particle composition (class taken by AliROOT) + + int nSpecies = 3; + float angleZeroHeight = 900.; + + if (hmpidSignal <= 0) { + // HMPID does not find anything reasonable for this track, assign 0.33 for all species + for (int iPart = 0; iPart < nSpecies; iPart++) + probs[iPart] = 1.0 / nSpecies; + return; + } + + // assign mass in GeV/c^2 + double mass[] = {o2::constants::physics::MassPionCharged, o2::constants::physics::MassKaonCharged, o2::constants::physics::MassProton}; + + double hTot = 0; // Initialize the total height of the amplitude method + double* h = new double[nSpecies]; // number of charged particles to be considered + + bool desert = kTRUE; // Flag to evaluate if ThetaC is far ("desert") from the given Gaussians + + for (int iPart = 0; iPart < nSpecies; iPart++) { // for each particle + + h[iPart] = 0; // reset the height + double thetaCerTh = expectedSignal(mass[iPart], hmpidMomentum); // theoretical Theta Cherenkov + if (thetaCerTh > angleZeroHeight) + continue; // no light emitted, zero height + double sigmaRing = expectedSigma(iPart, hmpidMomentum); + float maxSigmaRing = 4 * sigmaRing; + + if (sigmaRing == 0) + continue; + + if (TMath::Abs(hmpidSignal - thetaCerTh) < maxSigmaRing) + desert = kFALSE; + h[iPart] = TMath::Gaus(thetaCerTh, hmpidSignal, sigmaRing, kTRUE); + hTot += h[iPart]; // total height of all theoretical heights for normalization + + } // species loop + + for (int iPart = 0; iPart < nSpecies; iPart++) { // species loop to assign probabilities + + if (!desert) + probs[iPart] = h[iPart] / hTot; + else + probs[iPart] = 1.0 / nSpecies; // all theoretical values are far away from experemental one + } + + delete[] h; +} + +struct HmpidQa { + HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + Configurable nBinsP{"nBinsP", 1200, "Number of momentum bins"}; + Configurable minP{"minP", -20.f, "Minimum momentum plotted (GeV/c)"}; + Configurable maxP{"maxP", 20.f, "Maximum momentum plotted (GeV/c)"}; + + Configurable nBinsCh{"nBinsCh", 800, "Number of ch angle bins"}; + Configurable minCh{"minCh", 0.f, "Minimum ch angle plotted (rad)"}; + Configurable maxCh{"maxCh", 0.8f, "Maximum ch angle plotted (rad)"}; + + /// filters configurables for primary tracks + Configurable nSigmaTpcMin{"nSigmaTpcMin", -3.0, "nSigmaTpcMin"}; + Configurable nSigmaTpcMax{"nSigmaTpcMax", +3.0, "nSigmaTpcMax"}; + Configurable nSigmaTofMin{"nSigmaTofMin", -3.0, "nSigmaTofMin"}; + Configurable nSigmaTofMax{"nSigmaTofMax", +3.5, "nSigmaTofMax"}; + Configurable minReqClusterIts{"minReqClusterIts", 4.0, "min number of clusters required in ITS"}; + Configurable minTpcNClsFound{"minTpcNClsFound", 50.0f, "minTpcNClsFound"}; + Configurable minNCrossedRowsTpc{"minNCrossedRowsTpc", 70.0f, "min number of crossed rows TPC"}; + Configurable maxChi2Its{"maxChi2Its", 36.0f, "max chi2 per cluster ITS"}; + Configurable maxChi2Tpc{"maxChi2Tpc", 4.0f, "max chi2 per cluster TPC"}; + Configurable maxDCAXY{"maxDCAXY", 0.5f, "maxDCAXY"}; + Configurable maxDCAZ{"maxDCAZ", 0.5f, "maxDCAZ"}; + + // QA filters + Configurable cutDistanceMipTrack{"cutDistanceMipTrack", 3.0f, "cut distance between MIP and track"}; + Configurable cutQmip{"cutQmip", 120.0f, "cut on Q MIP"}; + Configurable cutMinMomGlobalTrack{"cutMinMomGlobalTrack", 1.5f, "minimum momentum of global track"}; + Configurable minProbParticle{"minProbParticle", 0.7f, "minimum particle probability"}; + Configurable maxDistanceForProb{"maxDistanceForProb", 1.5f, "maximum distance for probability calculation"}; + Configurable maxBoxHit{"maxBoxHit", 100.0f, "maximum box hit position"}; + Configurable minBoxHit{"minBoxHit", 40.0f, "minimum box hit position"}; + + // variables for chamber_number and HVs/PCs + const int rich0 = 0, rich1 = 1, rich2 = 2, rich3 = 3, rich4 = 4, rich5 = 5, rich6 = 6; + const int hv0 = 0, hv1 = 1, hv2 = 2, hv3 = 3, hv4 = 4, hv5 = 5; + // total number of chambers and HVs/PCs + static const int nCh = 7, nSec = 6, nPc = 6; + + //////////////////////////////////// + //////////////////////////////////// + // load geometry + o2::hmpid::Param* fParam = o2::hmpid::Param::instanceNoGeo(); + + void init(InitContext const&) + { + AxisSpec momAxis{nBinsP, minP, maxP, "#it{p} (GeV/#it{c})"}; + AxisSpec cherenkAxis{nBinsCh, minCh, maxCh, "#theta_{Ch} (rad)"}; + + histos.add("nPhotons_vs_sin2Ch", "nPhotons_vs_sin2Ch", kTProfile, {{40, 0.0, 0.5}}); + + histos.add("ChAngle_LowPt", "ChAngle_LowPt", kTH1F, {cherenkAxis}); + histos.add("ChAngle_HighPt", "ChAngle_HighPt", kTH1F, {cherenkAxis}); + + histos.add("hmpidSignal", "hmpidSignal", kTH1F, {cherenkAxis}); + + // th2f for spectra + histos.add("pTvsChAngle", "pTvsChAngle", kTH2F, {{500, 0, 10., "#it{p}_{T} (GeV/#it{c})"}, {cherenkAxis}}); + + // charge identification + histos.add("pTvsChAnglePos", "pTvsChAnglePos", kTH2F, {{500, 0, 10., "#it{p}_{T} (GeV/#it{c})"}, {cherenkAxis}}); + histos.add("pTvsChAngleNeg", "pTvsChAngleNeg", kTH2F, {{500, 0, 10., "#it{p}_{T} (GeV/#it{c})"}, {cherenkAxis}}); + + histos.add("hmpidMomvsTrackMom", "hmpidMomvsTrackMom", kTH2F, {{1200, 0, 30, "Track #it{p} (GeV/#it{c})"}, {1200, 0, 30, "HMPID #it{p} (GeV/#it{c})"}}); + histos.add("hmpidCkovvsMom", "hmpidCkovvsMom", kTH2F, {{1000, 0, 10, "#it{p} (GeV/#it{c})"}, cherenkAxis}); + histos.add("TrackMom", "TrackMom", kTH1F, {momAxis}); + histos.add("hmpidMom", "hmpidMom", kTH1F, {momAxis}); + + histos.add("hmpidNPhotons", "hmpidNPhotons", kTH1F, {{50, 2, 50, "Number of photons"}}); + + histos.add("hmpidCkovvsMom_nocut", "hmpidCkovvsMom_nocut", kTH2F, {{1000, 0, 10, "#it{p} (GeV/#it{c})"}, cherenkAxis}); + + histos.add("hmpidPhotsCharge", "hmpidPhotsCharge", kTH1F, {{180, 4, 210}}); + histos.add("hmpidQMip", "hmpidQMip", kTH1F, {{1000, 200, 2200, "Charge (ADC)"}}); + + // information on particle position + histos.add("hmpidXTrack", "hmpidXTrack", kTH1F, {{270, 0, 135, "X track (cm)"}}); + histos.add("hmpidYTrack", "hmpidYTrack", kTH1F, {{270, 0, 135, "Y track (cm)"}}); + histos.add("hmpidXMip", "hmpidXMip", kTH1F, {{270, 0, 135, "X mip (cm)"}}); + histos.add("hmpidYMip", "hmpidYMip", kTH1F, {{270, 0, 135, "X mip (cm)"}}); + histos.add("hmpidXResiduals", "hmpidXResiduals", kTH1F, {{400, -20, 20, "X Residuals (cm)"}}); + histos.add("hmpidYResiduals", "hmpidYResiduals", kTH1F, {{400, -20, 20, "Y Residuals (cm)"}}); + // 2D map for the mip and the track + histos.add("hmpidXYTrack", "hmpidXYTrack", kTH2F, {{270, 0, 135, "X track (cm)"}, {270, 0, 135, "Y track (cm)"}}); + histos.add("hmpidXYMip", "hmpidXYMip", kTH2F, {{270, 0, 135, "X mip (cm)"}, {270, 0, 135, "Y mip (cm)"}}); + + // histos per chamber + for (int iCh = 0; iCh < nCh; iCh++) { + histos.add(Form("hmpidXTrack%i", iCh), Form("hmpidXTrack%i", iCh), kTH1F, {{270, 0, 135, "X track (cm)"}}); + histos.add(Form("hmpidYTrack%i", iCh), Form("hmpidYTrack%i", iCh), kTH1F, {{270, 0, 135, "Y track (cm)"}}); + histos.add(Form("hmpidXMip%i", iCh), Form("hmpidXMip%i", iCh), kTH1F, {{270, 0, 135, "X mip (cm)"}}); + histos.add(Form("hmpidYMip%i", iCh), Form("hmpidYMip%i", iCh), kTH1F, {{270, 0, 135, "X mip (cm)"}}); + histos.add(Form("hmpidXResiduals%i", iCh), Form("hmpidXResiduals%i", iCh), kTH1F, {{400, -20, 20, "X Residuals (cm)"}}); + histos.add(Form("hmpidYResiduals%i", iCh), Form("hmpidYResiduals%i", iCh), kTH1F, {{400, -20, 20, "Y Residuals (cm)"}}); + + // residuals discriminated for charge sign + histos.add(Form("hmpidXResidualsPos%i", iCh), Form("hmpidXResidualsPos%i", iCh), kTH1F, {{400, -20, 20, "X Residuals (cm)"}}); + histos.add(Form("hmpidYResidualsPos%i", iCh), Form("hmpidYResidualsPos%i", iCh), kTH1F, {{400, -20, 20, "Y Residuals (cm)"}}); + + histos.add(Form("hmpidXResidualsNeg%i", iCh), Form("hmpidXResidualsNeg%i", iCh), kTH1F, {{400, -20, 20, "X Residuals (cm)"}}); + histos.add(Form("hmpidYResidualsNeg%i", iCh), Form("hmpidYResidualsNeg%i", iCh), kTH1F, {{400, -20, 20, "Y Residuals (cm)"}}); + + histos.add(Form("hmpidNPhotons%i", iCh), Form("hmpidNPhotons%i", iCh), kTH1F, {{50, 2, 50, "Number of photons"}}); + + histos.add(Form("hmpidQMip%i", iCh), Form("hmpidQMip%i", iCh), kTH1F, {{1000, 200, 2200, "Charge (ADC)"}}); + histos.add(Form("hmpidClusSize%i", iCh), Form("hmpidClusSize%i", iCh), kTH1F, {{15, 0, 15, "MIP Cluster size"}}); + + histos.add(Form("TrackMom%i", iCh), Form("TrackMom%i", iCh), kTH1F, {momAxis}); + histos.add(Form("hmpidMom%i", iCh), Form("hmpidMom%i", iCh), kTH1F, {momAxis}); + + histos.add(Form("hmpidPhotsCharge%i", iCh), Form("hmpidPhotsCharge%i", iCh), kTH1F, {{180, 4, 210}}); + histos.add(Form("hmpidXYMip%i", iCh), Form("hmpidXYMip%i", iCh), kTH2F, {{270, 0, 135, "X mip (cm)"}, {270, 0, 135, "Y mip (cm)"}}); + + histos.add(Form("nPhotons_vs_sin2Ch%i", iCh), Form("N. of Photons vs sin^{2}(#theta_{Ch}) - chamber%i", iCh), kTProfile, {{40, 0.0, 0.5}}); + + // histos per HV sector + for (int iSec = 0; iSec < nSec; iSec++) { + histos.add(Form("hmpidQMip_RICH%i_HV%i", iCh, iSec), Form("hmpidQMip_RICH%i_HV%i", iCh, iSec), kTH1F, {{2000, 200, 2200, "Charge (ADC)"}}); + histos.add(Form("hmpidNPhotons_RICH%i_HV%i", iCh, iSec), Form("hmpidNPhotons_RICH%i_HV%i", iCh, iSec), kTH1F, {{50, 2, 50, "Number of photons"}}); + histos.add(Form("hmpidPhotsCharge_RICH%i_HV%i", iCh, iSec), Form("hmpidPhotsCharge_RICH%i_HV%i", iCh, iSec), kTH1F, {{180, 4, 210}}); + } + + // plot n_ph vs sin2Ch per PC + for (int iPc = 0; iPc < nPc; iPc++) { + histos.add(Form("nPhotons_vs_sin2Ch_RICH%i_PC%i", iCh, iPc), Form("N. of Photons vs sin^{2}(#theta_{Ch}) - chamber%i, photocathode%i", iCh, iPc), kTProfile, {{20, 0.0, 0.4}}); + } + } + } + + void process(aod::HmpidAnalysis const& hmpidtable) + { + // photocathods limits + static float xMinPc[nPc]; + static float yMinPc[nPc]; + static float xMaxPc[nPc]; + static float yMaxPc[nPc]; + + for (int iPc = 0; iPc < nPc; iPc++) { + xMaxPc[iPc] = (fParam->maxPcX(iPc)) - 10.; + yMaxPc[iPc] = (fParam->maxPcY(iPc)) - 10.; + xMinPc[iPc] = (fParam->minPcX(iPc)) + 10.; + yMinPc[iPc] = (fParam->minPcY(iPc)) + 10.; + } + + for (const auto& hmpid : hmpidtable) // loop on tracks contained in the table + { + + // filters on primary tracks + if (hmpid.itsNCluster() < minReqClusterIts) + continue; + if (hmpid.tpcNCluster() < minTpcNClsFound) + continue; + if (hmpid.tpcNClsCrossedRows() < minNCrossedRowsTpc) + continue; + if (hmpid.tpcChi2() > maxChi2Tpc) + continue; + if (hmpid.itsChi2() > maxChi2Its) + continue; + if (TMath::Abs(hmpid.dcaXY()) > maxDCAXY) + continue; + if (TMath::Abs(hmpid.dcaZ()) > maxDCAZ) + continue; + + // evaluate distance mip-track + const float distanceMipToTrack = std::hypot(hmpid.xTrack() - hmpid.xMip(), hmpid.yTrack() - hmpid.yMip()); + + // quality conditions to check + const bool physicalChAngle = (hmpid.chAngle() > 0); + const bool mipChargeCondition = (hmpid.chargeMip() > cutQmip); + const bool distanceCondition = (distanceMipToTrack < cutDistanceMipTrack); + + // fill histograms + histos.fill(HIST("hmpidMomvsTrackMom"), std::fabs(hmpid.momentumTrack()), std::fabs(hmpid.momentumHmpid())); + histos.fill(HIST("TrackMom"), std::fabs(hmpid.momentumTrack())); + histos.fill(HIST("hmpidMom"), std::fabs(hmpid.momentumHmpid())); + + histos.fill(HIST("hmpidSignal"), hmpid.chAngle()); + + if (physicalChAngle && distanceCondition && mipChargeCondition) { + double pT = static_cast(hmpid.momentumTrack() / TMath::CosH(hmpid.etaTrack())); + histos.fill(HIST("pTvsChAngle"), pT, hmpid.chAngle()); + if (hmpid.momentumHmpid() > 0) { + histos.fill(HIST("pTvsChAnglePos"), pT, hmpid.chAngle()); + } + if (hmpid.momentumHmpid() < 0) { + histos.fill(HIST("pTvsChAngleNeg"), pT, hmpid.chAngle()); + } + } + + float sin2changle = 0.; + + if (distanceCondition && mipChargeCondition) { + + histos.fill(HIST("hmpidNPhotons"), hmpid.nPhotons()); + + sin2changle = static_cast(TMath::Power(TMath::Sin(hmpid.chAngle()), 2)); + if (hmpid.xMip() <= maxBoxHit && hmpid.xMip() >= minBoxHit && hmpid.yMip() <= maxBoxHit && hmpid.yMip() >= minBoxHit) { + histos.fill(HIST("nPhotons_vs_sin2Ch"), sin2changle, hmpid.nPhotons()); + } + + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) + histos.fill(HIST("hmpidPhotsCharge"), hmpid.photonsCharge()[i]); + } + } + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip"), hmpid.chargeMip()); + } + + histos.fill(HIST("hmpidXTrack"), hmpid.xTrack()); + histos.fill(HIST("hmpidYTrack"), hmpid.yTrack()); + histos.fill(HIST("hmpidXMip"), hmpid.xMip()); + histos.fill(HIST("hmpidYMip"), hmpid.yMip()); + if (hmpid.momentumTrack() > cutMinMomGlobalTrack) { + histos.fill(HIST("hmpidXResiduals"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResiduals"), hmpid.yMip() - hmpid.yTrack()); + } + histos.fill(HIST("hmpidXYTrack"), hmpid.xTrack(), hmpid.yTrack()); + histos.fill(HIST("hmpidXYMip"), hmpid.xMip(), hmpid.yMip()); + + ///////////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////////////// + ///////////////////////////////////////////////////////////////////////////////// + // fill histograms per chamber + if (hmpid.chamber() == rich0) { + histos.fill(HIST("hmpidXTrack0"), hmpid.xTrack()); + histos.fill(HIST("hmpidYTrack0"), hmpid.yTrack()); + histos.fill(HIST("hmpidXMip0"), hmpid.xMip()); + histos.fill(HIST("hmpidYMip0"), hmpid.yMip()); + histos.fill(HIST("hmpidXResiduals0"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResiduals0"), hmpid.yMip() - hmpid.yTrack()); + + if (hmpid.momentumTrack() > cutMinMomGlobalTrack) { + if (hmpid.momentumHmpid() > 0) { + // fill residual histos for positive charges + histos.fill(HIST("hmpidXResidualsPos0"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsPos0"), hmpid.yMip() - hmpid.yTrack()); + } + + if (hmpid.momentumHmpid() < 0) { + // fill residual histos for negative charges + histos.fill(HIST("hmpidXResidualsNeg0"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsNeg0"), hmpid.yMip() - hmpid.yTrack()); + } + } + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip0"), hmpid.chargeMip()); + } + histos.fill(HIST("hmpidClusSize0"), hmpid.clusterSize()); + histos.fill(HIST("TrackMom0"), hmpid.momentumTrack()); + histos.fill(HIST("hmpidMom0"), std::fabs(hmpid.momentumHmpid())); + histos.fill(HIST("hmpidXYMip0"), hmpid.xMip(), hmpid.yMip()); + + if (distanceCondition && mipChargeCondition) { + histos.fill(HIST("hmpidNPhotons0"), hmpid.nPhotons()); + sin2changle = static_cast(TMath::Power(TMath::Sin(hmpid.chAngle()), 2)); + if (hmpid.xMip() <= maxBoxHit && hmpid.xMip() >= minBoxHit && hmpid.yMip() <= maxBoxHit && hmpid.yMip() >= minBoxHit) { + histos.fill(HIST("nPhotons_vs_sin2Ch0"), sin2changle, hmpid.nPhotons()); + } + + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) + histos.fill(HIST("hmpidPhotsCharge0"), hmpid.photonsCharge()[i]); + } + } + + ////////////////////////////////////////////////////////////////// + // plot per HV sector + if (fParam->inHVSector(hmpid.yMip()) == hv0) { + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH0_HV0"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH0_HV0"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH0_HV0"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv1) { + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH0_HV1"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH0_HV1"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH0_HV1"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv2) { + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH0_HV2"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH0_HV2"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH0_HV2"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv3) { + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH0_HV3"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH0_HV3"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH0_HV3"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv4) { + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH0_HV4"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH0_HV4"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH0_HV4"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv5) { + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH0_HV5"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH0_HV5"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH0_HV5"), hmpid.nPhotons()); + } + } + + ////////////////////////////////////////////////////////////////// + // fill plot photocathode + if (distanceCondition && mipChargeCondition && physicalChAngle) // condizione da verificare a priori + { + if (hmpid.xMip() >= xMinPc[0] && hmpid.xMip() <= xMaxPc[0] && hmpid.yMip() >= yMinPc[0] && hmpid.yMip() <= yMaxPc[0]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH0_PC0"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[1] && hmpid.xMip() <= xMaxPc[1] && hmpid.yMip() >= yMinPc[1] && hmpid.yMip() <= yMaxPc[1]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH0_PC1"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[2] && hmpid.xMip() <= xMaxPc[2] && hmpid.yMip() >= yMinPc[2] && hmpid.yMip() <= yMaxPc[2]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH0_PC2"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[3] && hmpid.xMip() <= xMaxPc[3] && hmpid.yMip() >= yMinPc[3] && hmpid.yMip() <= yMaxPc[3]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH0_PC3"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[4] && hmpid.xMip() <= xMaxPc[4] && hmpid.yMip() >= yMinPc[4] && hmpid.yMip() <= yMaxPc[4]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH0_PC4"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[5] && hmpid.xMip() <= xMaxPc[5] && hmpid.yMip() >= yMinPc[5] && hmpid.yMip() <= yMaxPc[5]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH0_PC5"), sin2changle, hmpid.nPhotons()); + } + } + } + + if (hmpid.chamber() == rich1) { + histos.fill(HIST("hmpidXTrack1"), hmpid.xTrack()); + histos.fill(HIST("hmpidYTrack1"), hmpid.yTrack()); + histos.fill(HIST("hmpidXMip1"), hmpid.xMip()); + histos.fill(HIST("hmpidYMip1"), hmpid.yMip()); + histos.fill(HIST("hmpidXResiduals1"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResiduals1"), hmpid.yMip() - hmpid.yTrack()); + + if (hmpid.momentumTrack() > cutMinMomGlobalTrack) { + if (hmpid.momentumHmpid() > 0) { + // fill residual histos for positive charges + histos.fill(HIST("hmpidXResidualsPos1"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsPos1"), hmpid.yMip() - hmpid.yTrack()); + } + + if (hmpid.momentumHmpid() < 0) { + // fill residual histos for negative charges + histos.fill(HIST("hmpidXResidualsNeg1"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsNeg1"), hmpid.yMip() - hmpid.yTrack()); + } + } + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip1"), hmpid.chargeMip()); + } + histos.fill(HIST("hmpidClusSize1"), hmpid.clusterSize()); + histos.fill(HIST("TrackMom1"), hmpid.momentumTrack()); + histos.fill(HIST("hmpidMom1"), std::fabs(hmpid.momentumHmpid())); + histos.fill(HIST("hmpidXYMip1"), hmpid.xMip(), hmpid.yMip()); + + if (distanceCondition && mipChargeCondition) { + histos.fill(HIST("hmpidNPhotons1"), hmpid.nPhotons()); + sin2changle = static_cast(TMath::Power(TMath::Sin(hmpid.chAngle()), 2)); + if (hmpid.xMip() <= maxBoxHit && hmpid.xMip() >= minBoxHit && hmpid.yMip() <= maxBoxHit && hmpid.yMip() >= minBoxHit) { + histos.fill(HIST("nPhotons_vs_sin2Ch1"), sin2changle, hmpid.nPhotons()); + } + + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) + histos.fill(HIST("hmpidPhotsCharge1"), hmpid.photonsCharge()[i]); + } + } + + // plot per HV sector + if (fParam->inHVSector(hmpid.yMip()) == hv0) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH1_HV0"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH1_HV0"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH1_HV0"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv1) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH1_HV1"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH1_HV1"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH1_HV1"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv2) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH1_HV2"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH1_HV2"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH1_HV2"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv3) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH1_HV3"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH1_HV3"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH1_HV3"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv4) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH1_HV4"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH1_HV4"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH1_HV4"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv5) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH1_HV5"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH1_HV5"), hmpid.photonsCharge()[i]); + } // hmpidPhotsCharge_RICH%i_HV%i + } + histos.fill(HIST("hmpidNPhotons_RICH1_HV5"), hmpid.nPhotons()); + } + } + + ////////////////////////////////////////////////////////////////// + // fill plot photocathode + if (distanceCondition && mipChargeCondition && physicalChAngle) // condizione da verificare a priori + { + if (hmpid.xMip() >= xMinPc[0] && hmpid.xMip() <= xMaxPc[0] && hmpid.yMip() >= yMinPc[0] && hmpid.yMip() <= yMaxPc[0]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH1_PC0"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[1] && hmpid.xMip() <= xMaxPc[1] && hmpid.yMip() >= yMinPc[1] && hmpid.yMip() <= yMaxPc[1]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH1_PC1"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[2] && hmpid.xMip() <= xMaxPc[2] && hmpid.yMip() >= yMinPc[2] && hmpid.yMip() <= yMaxPc[2]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH1_PC2"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[3] && hmpid.xMip() <= xMaxPc[3] && hmpid.yMip() >= yMinPc[3] && hmpid.yMip() <= yMaxPc[3]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH1_PC3"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[4] && hmpid.xMip() <= xMaxPc[4] && hmpid.yMip() >= yMinPc[4] && hmpid.yMip() <= yMaxPc[4]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH1_PC4"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[5] && hmpid.xMip() <= xMaxPc[5] && hmpid.yMip() >= yMinPc[5] && hmpid.yMip() <= yMaxPc[5]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH1_PC5"), sin2changle, hmpid.nPhotons()); + } + } + } + + if (hmpid.chamber() == rich2) { + histos.fill(HIST("hmpidXTrack2"), hmpid.xTrack()); + histos.fill(HIST("hmpidYTrack2"), hmpid.yTrack()); + histos.fill(HIST("hmpidXMip2"), hmpid.xMip()); + histos.fill(HIST("hmpidYMip2"), hmpid.yMip()); + histos.fill(HIST("hmpidXResiduals2"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResiduals2"), hmpid.yMip() - hmpid.yTrack()); + + if (hmpid.momentumTrack() > cutMinMomGlobalTrack) { + if (hmpid.momentumHmpid() > 0) { + // fill residual histos for positive charges + histos.fill(HIST("hmpidXResidualsPos2"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsPos2"), hmpid.yMip() - hmpid.yTrack()); + } + + if (hmpid.momentumHmpid() < 0) { + // fill residual histos for negative charges + histos.fill(HIST("hmpidXResidualsNeg2"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsNeg2"), hmpid.yMip() - hmpid.yTrack()); + } + } + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip2"), hmpid.chargeMip()); + } + histos.fill(HIST("hmpidClusSize2"), hmpid.clusterSize()); + histos.fill(HIST("TrackMom2"), hmpid.momentumTrack()); + histos.fill(HIST("hmpidMom2"), std::fabs(hmpid.momentumHmpid())); + histos.fill(HIST("hmpidXYMip2"), hmpid.xMip(), hmpid.yMip()); + + if (distanceCondition && mipChargeCondition) { + histos.fill(HIST("hmpidNPhotons2"), hmpid.nPhotons()); + sin2changle = static_cast(TMath::Power(TMath::Sin(hmpid.chAngle()), 2)); + if (hmpid.xMip() <= maxBoxHit && hmpid.xMip() >= minBoxHit && hmpid.yMip() <= maxBoxHit && hmpid.yMip() >= minBoxHit) { + histos.fill(HIST("nPhotons_vs_sin2Ch2"), sin2changle, hmpid.nPhotons()); + } + + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) + histos.fill(HIST("hmpidPhotsCharge2"), hmpid.photonsCharge()[i]); + } + } + + // plot per HV sector + if (fParam->inHVSector(hmpid.yMip()) == hv0) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH2_HV0"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH2_HV0"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH2_HV0"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv1) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH2_HV1"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH2_HV1"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH2_HV1"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv2) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH2_HV2"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH2_HV2"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH2_HV2"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv3) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH2_HV3"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH2_HV3"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH2_HV3"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv4) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH2_HV4"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH2_HV4"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH2_HV4"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv5) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH2_HV5"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH2_HV5"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH2_HV5"), hmpid.nPhotons()); + } + } + + ////////////////////////////////////////////////////////////////// + // fill plot photocathode + if (distanceCondition && mipChargeCondition && physicalChAngle) // condizione da verificare a priori + { + if (hmpid.xMip() >= xMinPc[0] && hmpid.xMip() <= xMaxPc[0] && hmpid.yMip() >= yMinPc[0] && hmpid.yMip() <= yMaxPc[0]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH2_PC0"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[1] && hmpid.xMip() <= xMaxPc[1] && hmpid.yMip() >= yMinPc[1] && hmpid.yMip() <= yMaxPc[1]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH2_PC1"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[2] && hmpid.xMip() <= xMaxPc[2] && hmpid.yMip() >= yMinPc[2] && hmpid.yMip() <= yMaxPc[2]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH2_PC2"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[3] && hmpid.xMip() <= xMaxPc[3] && hmpid.yMip() >= yMinPc[3] && hmpid.yMip() <= yMaxPc[3]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH2_PC3"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[4] && hmpid.xMip() <= xMaxPc[4] && hmpid.yMip() >= yMinPc[4] && hmpid.yMip() <= yMaxPc[4]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH2_PC4"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[5] && hmpid.xMip() <= xMaxPc[5] && hmpid.yMip() >= yMinPc[5] && hmpid.yMip() <= yMaxPc[5]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH2_PC5"), sin2changle, hmpid.nPhotons()); + } + } + } + + if (hmpid.chamber() == rich3) { + histos.fill(HIST("hmpidXTrack3"), hmpid.xTrack()); + histos.fill(HIST("hmpidYTrack3"), hmpid.yTrack()); + histos.fill(HIST("hmpidXMip3"), hmpid.xMip()); + histos.fill(HIST("hmpidYMip3"), hmpid.yMip()); + histos.fill(HIST("hmpidXResiduals3"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResiduals3"), hmpid.yMip() - hmpid.yTrack()); + + if (hmpid.momentumTrack() > cutMinMomGlobalTrack) { + if (hmpid.momentumHmpid() > 0) { + // fill residual histos for positive charges + histos.fill(HIST("hmpidXResidualsPos3"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsPos3"), hmpid.yMip() - hmpid.yTrack()); + } + + if (hmpid.momentumHmpid() < 0) { + // fill residual histos for negative charges + histos.fill(HIST("hmpidXResidualsNeg3"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsNeg3"), hmpid.yMip() - hmpid.yTrack()); + } + } + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip3"), hmpid.chargeMip()); + } + histos.fill(HIST("hmpidClusSize3"), hmpid.clusterSize()); + histos.fill(HIST("TrackMom3"), hmpid.momentumTrack()); + histos.fill(HIST("hmpidMom3"), std::fabs(hmpid.momentumHmpid())); + histos.fill(HIST("hmpidXYMip3"), hmpid.xMip(), hmpid.yMip()); + + if (distanceCondition && mipChargeCondition) { + histos.fill(HIST("hmpidNPhotons3"), hmpid.nPhotons()); + sin2changle = static_cast(TMath::Power(TMath::Sin(hmpid.chAngle()), 2)); + if (hmpid.xMip() <= maxBoxHit && hmpid.xMip() >= minBoxHit && hmpid.yMip() <= maxBoxHit && hmpid.yMip() >= minBoxHit) { + histos.fill(HIST("nPhotons_vs_sin2Ch3"), sin2changle, hmpid.nPhotons()); + } + + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge3"), hmpid.photonsCharge()[i]); + } + } + } + + // plot per HV sector + if (fParam->inHVSector(hmpid.yMip()) == hv0) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH3_HV0"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH3_HV0"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH3_HV0"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv1) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH3_HV1"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH3_HV1"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH3_HV1"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv2) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH3_HV2"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH3_HV2"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH3_HV2"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv3) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH3_HV3"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH3_HV3"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH3_HV3"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv4) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH3_HV4"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH3_HV4"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH3_HV4"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv5) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH3_HV5"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH3_HV5"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH3_HV5"), hmpid.nPhotons()); + } + } + + ////////////////////////////////////////////////////////////////// + // fill plot photocathode + if (distanceCondition && mipChargeCondition && physicalChAngle) // condizione da verificare a priori + { + if (hmpid.xMip() >= xMinPc[0] && hmpid.xMip() <= xMaxPc[0] && hmpid.yMip() >= yMinPc[0] && hmpid.yMip() <= yMaxPc[0]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH3_PC0"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[1] && hmpid.xMip() <= xMaxPc[1] && hmpid.yMip() >= yMinPc[1] && hmpid.yMip() <= yMaxPc[1]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH3_PC1"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[2] && hmpid.xMip() <= xMaxPc[2] && hmpid.yMip() >= yMinPc[2] && hmpid.yMip() <= yMaxPc[2]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH3_PC2"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[3] && hmpid.xMip() <= xMaxPc[3] && hmpid.yMip() >= yMinPc[3] && hmpid.yMip() <= yMaxPc[3]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH3_PC3"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[4] && hmpid.xMip() <= xMaxPc[4] && hmpid.yMip() >= yMinPc[4] && hmpid.yMip() <= yMaxPc[4]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH3_PC4"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[5] && hmpid.xMip() <= xMaxPc[5] && hmpid.yMip() >= yMinPc[5] && hmpid.yMip() <= yMaxPc[5]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH3_PC5"), sin2changle, hmpid.nPhotons()); + } + } + } + + if (hmpid.chamber() == rich4) { + histos.fill(HIST("hmpidXTrack4"), hmpid.xTrack()); + histos.fill(HIST("hmpidYTrack4"), hmpid.yTrack()); + histos.fill(HIST("hmpidXMip4"), hmpid.xMip()); + histos.fill(HIST("hmpidYMip4"), hmpid.yMip()); + histos.fill(HIST("hmpidXResiduals4"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResiduals4"), hmpid.yMip() - hmpid.yTrack()); + + if (hmpid.momentumTrack() > cutMinMomGlobalTrack) { + if (hmpid.momentumHmpid() > 0) { + // fill residual histos for positive charges + histos.fill(HIST("hmpidXResidualsPos4"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsPos4"), hmpid.yMip() - hmpid.yTrack()); + } + + if (hmpid.momentumHmpid() < 0) { + // fill residual histos for negative charges + histos.fill(HIST("hmpidXResidualsNeg4"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsNeg4"), hmpid.yMip() - hmpid.yTrack()); + } + } + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip4"), hmpid.chargeMip()); + } + histos.fill(HIST("hmpidClusSize4"), hmpid.clusterSize()); + histos.fill(HIST("TrackMom4"), hmpid.momentumTrack()); + histos.fill(HIST("hmpidMom4"), std::fabs(hmpid.momentumHmpid())); + histos.fill(HIST("hmpidXYMip4"), hmpid.xMip(), hmpid.yMip()); + + if (distanceCondition && mipChargeCondition) { + histos.fill(HIST("hmpidNPhotons4"), hmpid.nPhotons()); + sin2changle = static_cast(TMath::Power(TMath::Sin(hmpid.chAngle()), 2)); + if (hmpid.xMip() <= maxBoxHit && hmpid.xMip() >= minBoxHit && hmpid.yMip() <= maxBoxHit && hmpid.yMip() >= minBoxHit) { + histos.fill(HIST("nPhotons_vs_sin2Ch4"), sin2changle, hmpid.nPhotons()); + } + + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) + histos.fill(HIST("hmpidPhotsCharge4"), hmpid.photonsCharge()[i]); + } + } + + // plot per HV sector + if (fParam->inHVSector(hmpid.yMip()) == hv0) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH4_HV0"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH4_HV0"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH4_HV0"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv1) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH4_HV1"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH4_HV1"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH4_HV1"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv2) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH4_HV2"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH4_HV2"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH4_HV2"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv3) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH4_HV3"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH4_HV3"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH4_HV3"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv4) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH4_HV4"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH4_HV4"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH4_HV4"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv5) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH4_HV5"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH4_HV5"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH4_HV5"), hmpid.nPhotons()); + } + } + + ////////////////////////////////////////////////////////////////// + // fill plot photocathode + if (distanceCondition && mipChargeCondition && physicalChAngle) // condizione da verificare a priori + { + if (hmpid.xMip() >= xMinPc[0] && hmpid.xMip() <= xMaxPc[0] && hmpid.yMip() >= yMinPc[0] && hmpid.yMip() <= yMaxPc[0]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH4_PC0"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[1] && hmpid.xMip() <= xMaxPc[1] && hmpid.yMip() >= yMinPc[1] && hmpid.yMip() <= yMaxPc[1]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH4_PC1"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[2] && hmpid.xMip() <= xMaxPc[2] && hmpid.yMip() >= yMinPc[2] && hmpid.yMip() <= yMaxPc[2]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH4_PC2"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[3] && hmpid.xMip() <= xMaxPc[3] && hmpid.yMip() >= yMinPc[3] && hmpid.yMip() <= yMaxPc[3]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH4_PC3"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[4] && hmpid.xMip() <= xMaxPc[4] && hmpid.yMip() >= yMinPc[4] && hmpid.yMip() <= yMaxPc[4]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH4_PC4"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[5] && hmpid.xMip() <= xMaxPc[5] && hmpid.yMip() >= yMinPc[5] && hmpid.yMip() <= yMaxPc[5]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH4_PC5"), sin2changle, hmpid.nPhotons()); + } + } + } + + if (hmpid.chamber() == rich5) { + histos.fill(HIST("hmpidXTrack5"), hmpid.xTrack()); + histos.fill(HIST("hmpidYTrack5"), hmpid.yTrack()); + histos.fill(HIST("hmpidXMip5"), hmpid.xMip()); + histos.fill(HIST("hmpidYMip5"), hmpid.yMip()); + histos.fill(HIST("hmpidXResiduals5"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResiduals5"), hmpid.yMip() - hmpid.yTrack()); + + if (hmpid.momentumTrack() > cutMinMomGlobalTrack) { + if (hmpid.momentumHmpid() > 0) { + // fill residual histos for positive charges + histos.fill(HIST("hmpidXResidualsPos5"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsPos5"), hmpid.yMip() - hmpid.yTrack()); + } + + if (hmpid.momentumHmpid() < 0) { + // fill residual histos for negative charges + histos.fill(HIST("hmpidXResidualsNeg5"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsNeg5"), hmpid.yMip() - hmpid.yTrack()); + } + } + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip5"), hmpid.chargeMip()); + } + histos.fill(HIST("hmpidClusSize5"), hmpid.clusterSize()); + histos.fill(HIST("TrackMom5"), hmpid.momentumTrack()); + histos.fill(HIST("hmpidMom5"), std::fabs(hmpid.momentumHmpid())); + histos.fill(HIST("hmpidXYMip5"), hmpid.xMip(), hmpid.yMip()); + + if (distanceCondition && mipChargeCondition) { + histos.fill(HIST("hmpidNPhotons5"), hmpid.nPhotons()); + sin2changle = static_cast(TMath::Power(TMath::Sin(hmpid.chAngle()), 2)); + if (hmpid.xMip() <= maxBoxHit && hmpid.xMip() >= minBoxHit && hmpid.yMip() <= maxBoxHit && hmpid.yMip() >= minBoxHit) { + histos.fill(HIST("nPhotons_vs_sin2Ch5"), sin2changle, hmpid.nPhotons()); + } + + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) + histos.fill(HIST("hmpidPhotsCharge5"), hmpid.photonsCharge()[i]); + } + } + + // plot per HV sector + if (fParam->inHVSector(hmpid.yMip()) == hv0) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH5_HV0"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH5_HV0"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH5_HV0"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv1) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH5_HV1"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH5_HV1"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH5_HV1"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv2) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH5_HV2"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH5_HV2"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH5_HV2"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv3) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH5_HV3"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH5_HV3"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH5_HV3"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv4) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH5_HV4"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH5_HV4"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH5_HV4"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv5) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH5_HV5"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH5_HV5"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH5_HV5"), hmpid.nPhotons()); + } + } + + ////////////////////////////////////////////////////////////////// + // fill plot photocathode + if (distanceCondition && mipChargeCondition && physicalChAngle) // condizione da verificare a priori + { + if (hmpid.xMip() >= xMinPc[0] && hmpid.xMip() <= xMaxPc[0] && hmpid.yMip() >= yMinPc[0] && hmpid.yMip() <= yMaxPc[0]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH5_PC0"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[1] && hmpid.xMip() <= xMaxPc[1] && hmpid.yMip() >= yMinPc[1] && hmpid.yMip() <= yMaxPc[1]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH5_PC1"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[2] && hmpid.xMip() <= xMaxPc[2] && hmpid.yMip() >= yMinPc[2] && hmpid.yMip() <= yMaxPc[2]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH5_PC2"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[3] && hmpid.xMip() <= xMaxPc[3] && hmpid.yMip() >= yMinPc[3] && hmpid.yMip() <= yMaxPc[3]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH5_PC3"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[4] && hmpid.xMip() <= xMaxPc[4] && hmpid.yMip() >= yMinPc[4] && hmpid.yMip() <= yMaxPc[4]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH5_PC4"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[5] && hmpid.xMip() <= xMaxPc[5] && hmpid.yMip() >= yMinPc[5] && hmpid.yMip() <= yMaxPc[5]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH5_PC5"), sin2changle, hmpid.nPhotons()); + } + } + } + + if (hmpid.chamber() == rich6) { + histos.fill(HIST("hmpidXTrack6"), hmpid.xTrack()); + histos.fill(HIST("hmpidYTrack6"), hmpid.yTrack()); + histos.fill(HIST("hmpidXMip6"), hmpid.xMip()); + histos.fill(HIST("hmpidYMip6"), hmpid.yMip()); + histos.fill(HIST("hmpidXResiduals6"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResiduals6"), hmpid.yMip() - hmpid.yTrack()); + + if (hmpid.momentumTrack() > cutMinMomGlobalTrack) { + if (hmpid.momentumHmpid() > 0) { + // fill residual histos for positive charges + histos.fill(HIST("hmpidXResidualsPos6"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsPos6"), hmpid.yMip() - hmpid.yTrack()); + } + + if (hmpid.momentumHmpid() < 0) { + // fill residual histos for negative charges + histos.fill(HIST("hmpidXResidualsNeg6"), hmpid.xMip() - hmpid.xTrack()); + histos.fill(HIST("hmpidYResidualsNeg6"), hmpid.yMip() - hmpid.yTrack()); + } + } + + if (distanceCondition) { + histos.fill(HIST("hmpidQMip6"), hmpid.chargeMip()); + } + histos.fill(HIST("hmpidClusSize6"), hmpid.clusterSize()); + histos.fill(HIST("TrackMom6"), hmpid.momentumTrack()); + histos.fill(HIST("hmpidMom6"), std::fabs(hmpid.momentumHmpid())); + histos.fill(HIST("hmpidXYMip6"), hmpid.xMip(), hmpid.yMip()); + + if (distanceCondition && mipChargeCondition) { + histos.fill(HIST("hmpidNPhotons6"), hmpid.nPhotons()); + sin2changle = static_cast(TMath::Power(TMath::Sin(hmpid.chAngle()), 2)); + if (hmpid.xMip() <= maxBoxHit && hmpid.xMip() >= minBoxHit && hmpid.yMip() <= maxBoxHit && hmpid.yMip() >= minBoxHit) { + histos.fill(HIST("nPhotons_vs_sin2Ch6"), sin2changle, hmpid.nPhotons()); + } + + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) + histos.fill(HIST("hmpidPhotsCharge6"), hmpid.photonsCharge()[i]); + } + } + + // plot per HV sector + if (fParam->inHVSector(hmpid.yMip()) == hv0) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH6_HV0"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH6_HV0"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH6_HV0"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv1) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH6_HV1"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH6_HV1"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH6_HV1"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv2) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH6_HV2"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH6_HV2"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH6_HV2"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv3) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH6_HV3"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH6_HV3"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH6_HV3"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv4) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH6_HV4"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH6_HV4"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH6_HV4"), hmpid.nPhotons()); + } + } + + if (fParam->inHVSector(hmpid.yMip()) == hv5) { + if (distanceCondition) { + histos.fill(HIST("hmpidQMip_RICH6_HV5"), hmpid.chargeMip()); + } + if (distanceCondition && mipChargeCondition && physicalChAngle) { + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + if (hmpid.photonsCharge()[i] > 0) { + histos.fill(HIST("hmpidPhotsCharge_RICH6_HV5"), hmpid.photonsCharge()[i]); + } + } + histos.fill(HIST("hmpidNPhotons_RICH6_HV5"), hmpid.nPhotons()); + } + } + + ////////////////////////////////////////////////////////////////// + // fill plot photocathode + if (distanceCondition && mipChargeCondition && physicalChAngle) // condizione da verificare a priori + { + if (hmpid.xMip() >= xMinPc[0] && hmpid.xMip() <= xMaxPc[0] && hmpid.yMip() >= yMinPc[0] && hmpid.yMip() <= yMaxPc[0]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH6_PC0"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[1] && hmpid.xMip() <= xMaxPc[1] && hmpid.yMip() >= yMinPc[1] && hmpid.yMip() <= yMaxPc[1]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH6_PC1"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[2] && hmpid.xMip() <= xMaxPc[2] && hmpid.yMip() >= yMinPc[2] && hmpid.yMip() <= yMaxPc[2]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH6_PC2"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[3] && hmpid.xMip() <= xMaxPc[3] && hmpid.yMip() >= yMinPc[3] && hmpid.yMip() <= yMaxPc[3]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH6_PC3"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[4] && hmpid.xMip() <= xMaxPc[4] && hmpid.yMip() >= yMinPc[4] && hmpid.yMip() <= yMaxPc[4]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH6_PC4"), sin2changle, hmpid.nPhotons()); + } + + if (hmpid.xMip() >= xMinPc[5] && hmpid.xMip() <= xMaxPc[5] && hmpid.yMip() >= yMinPc[5] && hmpid.yMip() <= yMaxPc[5]) { + histos.fill(HIST("nPhotons_vs_sin2Ch_RICH6_PC5"), sin2changle, hmpid.nPhotons()); + } + } + } + + double probsHMP[3]; + + getProbability(hmpid.chAngle(), std::fabs(hmpid.momentumHmpid()), probsHMP); + + if (distanceMipToTrack > maxDistanceForProb || hmpid.chargeMip() < cutQmip) + continue; + + histos.fill(HIST("hmpidCkovvsMom_nocut"), std::fabs(hmpid.momentumHmpid()), hmpid.chAngle()); + + if (probsHMP[0] < minProbParticle && probsHMP[1] < minProbParticle && probsHMP[2] < minProbParticle) + continue; + // if(hmpid.momentumTrack()<0.75 && hmpid.nPhotons()<7 && hmpid.chAngle()<0.52) continue; + + histos.fill(HIST("hmpidCkovvsMom"), std::fabs(hmpid.momentumHmpid()), hmpid.chAngle()); + + } // close loop on tracks + + } // close process +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfg) { return WorkflowSpec{adaptAnalysisTask(cfg)}; } diff --git a/DPG/Tasks/AOTTrack/PID/HMPID/hmpidTableProducer.cxx b/DPG/Tasks/AOTTrack/PID/HMPID/hmpidTableProducer.cxx new file mode 100644 index 00000000000..88150b6873f --- /dev/null +++ b/DPG/Tasks/AOTTrack/PID/HMPID/hmpidTableProducer.cxx @@ -0,0 +1,135 @@ +// 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. + +#include "tableHMPID.h" + +#include "Common/Core/PID/PIDTOF.h" +#include "Common/Core/trackUtilities.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/PIDResponse.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/TableProducer/PID/pidTOFBase.h" + +#include "CCDB/BasicCCDBManager.h" +#include "CCDB/CcdbApi.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::constants::physics; + +struct HmpidTableProducer { + HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + const AxisSpec axisEvtCounter{1, 0, +1, ""}; + + // CCDB configurable + Service ccdb; + struct : ConfigurableGroup { + Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "URL of the CCDB repository"}; + } ccdbConfig; + + Produces hmpidAnalysis; + + // using TrackCandidates = soa::Join; + + using CollisionCandidates = o2::soa::Join; + + using TrackCandidates = soa::Join; + + // using CentralityClass = o2::soa::Join; + + void init(o2::framework::InitContext&) + { + // Configure CCDB + ccdb->setURL(ccdbConfig.ccdbUrl); + ccdb->setCaching(true); + ccdb->setLocalObjectValidityChecking(); + + histos.add("eventCounter", "eventCounter", kTH1F, {axisEvtCounter}); + } + + // function to manage ccdb + int mCCDBRunNumber = 0; + void initCCDB(aod::BCsWithTimestamps::iterator const& bc) + { + if (mCCDBRunNumber == bc.runNumber()) { + return; + } + mCCDBRunNumber = bc.runNumber(); + } + + void process(soa::Join::iterator const& col, + const aod::HMPIDs& hmpids, + TrackCandidates const&, + aod::BCsWithTimestamps const&) + { + histos.fill(HIST("eventCounter"), 0.5); + + initCCDB(col.bc_as()); + + for (const auto& t : hmpids) { + + // global tracks associated to hmpid tracks + const auto& globalTrack = t.track_as(); + if (!globalTrack.isGlobalTrack()) + continue; + if (!globalTrack.hasITS() || !globalTrack.hasTPC() || !globalTrack.hasTOF()) + continue; + + // verify accessible collision + if (!globalTrack.has_collision()) { + continue; + } + + float hmpidPhotsCharge2[o2::aod::kDimPhotonsCharge]; + + for (int i = 0; i < o2::aod::kDimPhotonsCharge; i++) { + hmpidPhotsCharge2[i] = t.hmpidPhotsCharge()[i]; + } + + float centrality = col.centFV0A(); + + /////FILL TABLE + hmpidAnalysis( + t.hmpidSignal(), globalTrack.phi(), globalTrack.eta(), t.hmpidMom(), + globalTrack.p(), t.hmpidXTrack(), t.hmpidYTrack(), t.hmpidXMip(), + t.hmpidYMip(), t.hmpidNPhotons(), t.hmpidQMip(), (t.hmpidClusSize() % 1000000) / 1000, + t.hmpidClusSize() / 1000000, hmpidPhotsCharge2, globalTrack.eta(), globalTrack.phi(), + globalTrack.px(), globalTrack.py(), globalTrack.pz(), globalTrack.itsNCls(), + globalTrack.tpcNClsFound(), globalTrack.tpcNClsCrossedRows(), globalTrack.tpcChi2NCl(), globalTrack.itsChi2NCl(), + globalTrack.dcaXY(), globalTrack.dcaZ(), globalTrack.tpcNSigmaPi(), globalTrack.tofNSigmaPi(), + globalTrack.tpcNSigmaKa(), globalTrack.tofNSigmaKa(), globalTrack.tpcNSigmaPr(), globalTrack.tofNSigmaPr(), + globalTrack.tpcNSigmaDe(), globalTrack.tofNSigmaDe(), centrality); + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfg) { return WorkflowSpec{adaptAnalysisTask(cfg)}; } diff --git a/DPG/Tasks/AOTTrack/PID/HMPID/qaHMPID.cxx b/DPG/Tasks/AOTTrack/PID/HMPID/qaHMPID.cxx deleted file mode 100644 index a4e01d6a980..00000000000 --- a/DPG/Tasks/AOTTrack/PID/HMPID/qaHMPID.cxx +++ /dev/null @@ -1,311 +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. - -// O2 includes -#include "ReconstructionDataFormats/Track.h" -#include "Framework/runDataProcessing.h" -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/HistogramRegistry.h" -#include "Framework/RunningWorkflowInfo.h" -#include "ReconstructionDataFormats/TrackParametrization.h" -#include "Common/DataModel/PIDResponse.h" -#include "Common/Core/PID/PIDTOF.h" -#include "Common/TableProducer/PID/pidTOFBase.h" -#include "ReconstructionDataFormats/PID.h" -#include "Common/Core/trackUtilities.h" -#include "ReconstructionDataFormats/DCA.h" -#include "Framework/ASoAHelpers.h" -#include "Framework/ASoA.h" -#include "Common/DataModel/EventSelection.h" -#include "Common/DataModel/TrackSelectionTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -namespace o2::aod -{ - -namespace variables_table // declaration of columns to create -{ -DECLARE_SOA_COLUMN(ChAngle, chAngle, float); -DECLARE_SOA_COLUMN(Phi, phi, float); -DECLARE_SOA_COLUMN(Eta, eta, float); -DECLARE_SOA_COLUMN(MomHMPID, momMPID, float); -DECLARE_SOA_COLUMN(MomTrackX, momTrackX, float); -DECLARE_SOA_COLUMN(MomTrackY, momTrackY, float); -DECLARE_SOA_COLUMN(MomTrackZ, momTrackZ, float); -DECLARE_SOA_COLUMN(Xtrack, xtrack, float); -DECLARE_SOA_COLUMN(Ytrack, ytrack, float); -DECLARE_SOA_COLUMN(Xmip, xmip, float); -DECLARE_SOA_COLUMN(Ymip, ymip, float); -DECLARE_SOA_COLUMN(Nphotons, nphotons, float); -DECLARE_SOA_COLUMN(ChargeMIP, chargeMIP, float); -DECLARE_SOA_COLUMN(ClusterSize, clustersize, float); -DECLARE_SOA_COLUMN(Chamber, chamber, float); -DECLARE_SOA_COLUMN(Photons_charge, photons_charge, float[10]); - -DECLARE_SOA_COLUMN(EtaTrack, etatrack, float); -DECLARE_SOA_COLUMN(PhiTrack, phitrack, float); - -DECLARE_SOA_COLUMN(ITSNcluster, itsNcluster, float); -DECLARE_SOA_COLUMN(TPCNcluster, tpcNcluster, float); -DECLARE_SOA_COLUMN(TPCNClsCrossedRows, tpcNClsCrossedRows, float); -DECLARE_SOA_COLUMN(TPCchi2, tpcChi2, float); -DECLARE_SOA_COLUMN(ITSchi2, itsChi2, float); - -DECLARE_SOA_COLUMN(DCAxy, dcaxy, float); -DECLARE_SOA_COLUMN(DCAz, dcaz, float); - -} // namespace variables_table - -DECLARE_SOA_TABLE(HMPID_analysis, "AOD", "HMPIDANALYSIS", - variables_table::ChAngle, variables_table::Phi, variables_table::Eta, variables_table::MomHMPID, - variables_table::MomTrackX, variables_table::MomTrackY, variables_table::MomTrackZ, - variables_table::Xtrack, variables_table::Ytrack, variables_table::Xmip, - variables_table::Ymip, variables_table::Nphotons, variables_table::ChargeMIP, variables_table::ClusterSize, - variables_table::Chamber, variables_table::Photons_charge, variables_table::EtaTrack, variables_table::PhiTrack, - variables_table::ITSNcluster, variables_table::TPCNcluster, variables_table::TPCNClsCrossedRows, - variables_table::TPCchi2, variables_table::ITSchi2, variables_table::DCAxy, variables_table::DCAz); -} // namespace o2::aod - -struct pidHmpidQa { - - Produces HMPID_analysis; - - HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; - Configurable nBinsP{"nBinsP", 500, "Number of momentum bins"}; - Configurable minP{"minP", 0.01f, "Minimum momentum plotted (GeV/c)"}; - Configurable maxP{"maxP", 10.f, "Maximum momentum plotted (GeV/c)"}; - Configurable maxDCA{"maxDCA", 3.f, "Maximum DCA xy use for the plot (cm)"}; - Configurable maxDistance{"maxDistance", 5.f, "Maximum HMPID distance between the track and the cluster (cm)"}; - Configurable minCharge{"minCharge", 120.f, "Minimum HMPID charge collected in the cluster"}; - - void init(o2::framework::InitContext&) - { - AxisSpec momAxis{nBinsP, minP, maxP}; - - histos.add("hmpidSignal", "hmpidSignal", kTH1F, {{1000, 0, 1}}); - histos.add("hmpidMomvsTrackMom", "hmpidMomvsTrackMom", kTH2F, {{1200, 0, 30, "Track #it{p} (GeV/#it{c})"}, {1200, 0, 30, "HMP #it{p} (GeV/#it{c})"}}); - histos.add("PhivsEta", "PhivsEta", kTH2F, {{550, -0.55, 0.55, "#eta"}, {550, 0, 1.1, "#phi (rad)"}}); - histos.add("hmpidCkovvsMom", "hmpidCkovvsMom", kTH2F, {{500, 0, 10, "#it{p} (GeV/#it{c})"}, {1000, 0, 1, "Cherenkov angle (rad)"}}); - histos.add("hmpidXTrack", "hmpidXTrack", kTH1F, {{280, 0, 140, "X track (cm)"}}); - histos.add("hmpidYTrack", "hmpidYTrack", kTH1F, {{280, 0, 140, "Y track (cm)"}}); - histos.add("hmpidXMip", "hmpidXMip", kTH1F, {{280, 0, 140, "X mip (cm)"}}); - histos.add("hmpidYMip", "hmpidYMip", kTH1F, {{280, 0, 140, "X mip (cm)"}}); - histos.add("hmpidXResiduals", "hmpidXResiduals", kTH1F, {{400, -20, 20, "X Residuals (cm)"}}); - histos.add("hmpidYResiduals", "hmpidYResiduals", kTH1F, {{400, -20, 20, "Y Residuals (cm)"}}); - histos.add("hmpidNPhotons", "hmpidNPhotons", kTH1F, {{50, 0, 50, "Number of photons"}}); - histos.add("hmpidQMip", "hmpidQMip", kTH1F, {{2000, 200, 2200, "Charge (ADCD)"}}); - histos.add("hmpidClusSize", "hmpidClusSize", kTH1F, {{15, 0, 15, "MIP Cluster size"}}); - histos.add("TrackMom", "TrackMom", kTH1F, {{1200, -30, 30, "#it{p} (GeV/#it{c})"}}); - histos.add("hmpidMom", "hmpidMom", kTH1F, {{1200, -30, 30, "#it{p} (GeV/#it{c})"}}); - histos.add("hmpidPhotsCharge", "hmpidPhotsCharge", kTH1F, {{300, 0, 300}}); - for (int iCh = 0; iCh < 7; iCh++) { - histos.add(Form("hmpidXTrack%i", iCh), Form("hmpidXTrack%i", iCh), kTH1F, {{280, 0, 140, "X track (cm)"}}); - histos.add(Form("hmpidYTrack%i", iCh), Form("hmpidYTrack%i", iCh), kTH1F, {{280, 0, 140, "Y track (cm)"}}); - histos.add(Form("hmpidXMip%i", iCh), Form("hmpidXMip%i", iCh), kTH1F, {{280, 0, 140, "X mip (cm)"}}); - histos.add(Form("hmpidYMip%i", iCh), Form("hmpidYMip%i", iCh), kTH1F, {{280, 0, 140, "X mip (cm)"}}); - histos.add(Form("hmpidXResiduals%i", iCh), Form("hmpidXResiduals%i", iCh), kTH1F, {{400, -20, 20, "X Residuals (cm)"}}); - histos.add(Form("hmpidYResiduals%i", iCh), Form("hmpidYResiduals%i", iCh), kTH1F, {{400, -20, 20, "Y Residuals (cm)"}}); - histos.add(Form("hmpidNPhotons%i", iCh), Form("hmpidNPhotons%i", iCh), kTH1F, {{50, 0, 50, "Number of photons"}}); - histos.add(Form("hmpidQMip%i", iCh), Form("hmpidQMip%i", iCh), kTH1F, {{2000, 200, 2200, "Charge (ADCD)"}}); - histos.add(Form("hmpidClusSize%i", iCh), Form("hmpidClusSize%i", iCh), kTH1F, {{15, 0, 15, "MIP Cluster size"}}); - histos.add(Form("TrackMom%i", iCh), Form("TrackMom%i", iCh), kTH1F, {{1200, -30, 30, "#it{p} (GeV/#it{c})"}}); - histos.add(Form("hmpidMom%i", iCh), Form("hmpidMom%i", iCh), kTH1F, {{1200, -30, 30, "#it{p} (GeV/#it{c})"}}); - histos.add(Form("hmpidPhotsCharge%i", iCh), Form("hmpidPhotsCharge%i", iCh), kTH1F, {{300, 0, 300}}); - } - } - - using TrackCandidates = soa::Join; - - void process(const aod::HMPIDs& hmpids, - const TrackCandidates& /*tracks*/, - const aod::Collisions& /*colls*/) - - { - - for (const auto& t : hmpids) { - if (t.track_as().isGlobalTrack() != (uint8_t) true) { - continue; - } - - const auto& track = t.track_as(); - - if (!track.hasITS() || !track.hasTPC() || !track.hasTOF()) { - continue; - } - - float hmpidPhotsCharge2[10]; - - for (int i = 0; i < 10; i++) { - hmpidPhotsCharge2[i] = t.hmpidPhotsCharge()[i]; - } - - HMPID_analysis(t.hmpidSignal(), t.track_as().phi(), t.track_as().eta(), t.hmpidMom(), - track.px(), track.py(), track.pz(), t.hmpidXTrack(), t.hmpidYTrack(), t.hmpidXMip(), - t.hmpidYMip(), t.hmpidNPhotons(), t.hmpidQMip(), (t.hmpidClusSize() % 1000000) / 1000, t.hmpidClusSize() / 1000000, - hmpidPhotsCharge2, track.eta(), track.phi(), track.itsNCls(), track.tpcNClsFound(), track.tpcNClsCrossedRows(), - track.tpcChi2NCl(), track.itsChi2NCl(), track.dcaXY(), track.dcaZ()); - - histos.fill(HIST("hmpidSignal"), t.hmpidSignal()); - histos.fill(HIST("PhivsEta"), t.track_as().eta(), t.track_as().phi()); - histos.fill(HIST("hmpidMomvsTrackMom"), t.track_as().p(), std::abs(t.hmpidMom())); - histos.fill(HIST("hmpidCkovvsMom"), std::abs(t.hmpidMom()), t.hmpidSignal()); - histos.fill(HIST("hmpidXTrack"), t.hmpidXTrack()); - histos.fill(HIST("hmpidYTrack"), t.hmpidYTrack()); - histos.fill(HIST("hmpidXMip"), t.hmpidXMip()); - histos.fill(HIST("hmpidYMip"), t.hmpidYMip()); - if (t.track_as().p() > 1.5) { - histos.fill(HIST("hmpidXResiduals"), t.hmpidXMip() - t.hmpidXTrack()); - histos.fill(HIST("hmpidYResiduals"), t.hmpidYMip() - t.hmpidYTrack()); - } - histos.fill(HIST("hmpidNPhotons"), t.hmpidNPhotons()); - histos.fill(HIST("hmpidQMip"), t.hmpidQMip()); - histos.fill(HIST("hmpidClusSize"), (t.hmpidClusSize() % 1000000) / 1000); - histos.fill(HIST("TrackMom"), t.track_as().p()); - histos.fill(HIST("hmpidMom"), std::abs(t.hmpidMom())); - for (int i = 0; i < 10; i++) { - if (t.hmpidPhotsCharge()[i] > 0) - histos.fill(HIST("hmpidPhotsCharge"), t.hmpidPhotsCharge()[i]); - } - - if (t.hmpidClusSize() / 1000000 == 0) { - histos.fill(HIST("hmpidXTrack0"), t.hmpidXTrack()); - histos.fill(HIST("hmpidYTrack0"), t.hmpidYTrack()); - histos.fill(HIST("hmpidXMip0"), t.hmpidXMip()); - histos.fill(HIST("hmpidYMip0"), t.hmpidYMip()); - histos.fill(HIST("hmpidXResiduals0"), t.hmpidXMip() - t.hmpidXTrack()); - histos.fill(HIST("hmpidYResiduals0"), t.hmpidYMip() - t.hmpidYTrack()); - histos.fill(HIST("hmpidNPhotons0"), t.hmpidNPhotons()); - histos.fill(HIST("hmpidQMip0"), t.hmpidQMip()); - histos.fill(HIST("hmpidClusSize0"), (t.hmpidClusSize() % 1000000) / 1000); - histos.fill(HIST("TrackMom0"), t.track_as().p()); - histos.fill(HIST("hmpidMom0"), std::abs(t.hmpidMom())); - for (int i = 0; i < 10; i++) { - if (t.hmpidPhotsCharge()[i] > 0) - histos.fill(HIST("hmpidPhotsCharge0"), t.hmpidPhotsCharge()[i]); - } - } - - if (t.hmpidClusSize() / 1000000 == 1) { - histos.fill(HIST("hmpidXTrack1"), t.hmpidXTrack()); - histos.fill(HIST("hmpidYTrack1"), t.hmpidYTrack()); - histos.fill(HIST("hmpidXMip1"), t.hmpidXMip()); - histos.fill(HIST("hmpidYMip1"), t.hmpidYMip()); - histos.fill(HIST("hmpidXResiduals1"), t.hmpidXMip() - t.hmpidXTrack()); - histos.fill(HIST("hmpidYResiduals1"), t.hmpidYMip() - t.hmpidYTrack()); - histos.fill(HIST("hmpidNPhotons1"), t.hmpidNPhotons()); - histos.fill(HIST("hmpidQMip1"), t.hmpidQMip()); - histos.fill(HIST("hmpidClusSize1"), (t.hmpidClusSize() % 1000000) / 1000); - histos.fill(HIST("TrackMom1"), t.track_as().p()); - histos.fill(HIST("hmpidMom1"), std::abs(t.hmpidMom())); - for (int i = 0; i < 10; i++) { - if (t.hmpidPhotsCharge()[i] > 0) - histos.fill(HIST("hmpidPhotsCharge1"), t.hmpidPhotsCharge()[i]); - } - } - - if (t.hmpidClusSize() / 1000000 == 2) { - histos.fill(HIST("hmpidXTrack2"), t.hmpidXTrack()); - histos.fill(HIST("hmpidYTrack2"), t.hmpidYTrack()); - histos.fill(HIST("hmpidXMip2"), t.hmpidXMip()); - histos.fill(HIST("hmpidYMip2"), t.hmpidYMip()); - histos.fill(HIST("hmpidXResiduals2"), t.hmpidXMip() - t.hmpidXTrack()); - histos.fill(HIST("hmpidYResiduals2"), t.hmpidYMip() - t.hmpidYTrack()); - histos.fill(HIST("hmpidNPhotons2"), t.hmpidNPhotons()); - histos.fill(HIST("hmpidQMip2"), t.hmpidQMip()); - histos.fill(HIST("hmpidClusSize2"), (t.hmpidClusSize() % 1000000) / 1000); - histos.fill(HIST("TrackMom2"), t.track_as().p()); - histos.fill(HIST("hmpidMom2"), std::abs(t.hmpidMom())); - for (int i = 0; i < 10; i++) { - if (t.hmpidPhotsCharge()[i] > 0) - histos.fill(HIST("hmpidPhotsCharge2"), t.hmpidPhotsCharge()[i]); - } - } - - if (t.hmpidClusSize() / 1000000 == 3) { - histos.fill(HIST("hmpidXTrack3"), t.hmpidXTrack()); - histos.fill(HIST("hmpidYTrack3"), t.hmpidYTrack()); - histos.fill(HIST("hmpidXMip3"), t.hmpidXMip()); - histos.fill(HIST("hmpidYMip3"), t.hmpidYMip()); - histos.fill(HIST("hmpidXResiduals3"), t.hmpidXMip() - t.hmpidXTrack()); - histos.fill(HIST("hmpidYResiduals3"), t.hmpidYMip() - t.hmpidYTrack()); - histos.fill(HIST("hmpidNPhotons3"), t.hmpidNPhotons()); - histos.fill(HIST("hmpidQMip3"), t.hmpidQMip()); - histos.fill(HIST("hmpidClusSize3"), (t.hmpidClusSize() % 1000000) / 1000); - histos.fill(HIST("TrackMom3"), t.track_as().p()); - histos.fill(HIST("hmpidMom3"), std::abs(t.hmpidMom())); - for (int i = 0; i < 10; i++) { - if (t.hmpidPhotsCharge()[i] > 0) - histos.fill(HIST("hmpidPhotsCharge3"), t.hmpidPhotsCharge()[i]); - } - } - - if (t.hmpidClusSize() / 1000000 == 4) { - histos.fill(HIST("hmpidXTrack4"), t.hmpidXTrack()); - histos.fill(HIST("hmpidYTrack4"), t.hmpidYTrack()); - histos.fill(HIST("hmpidXMip4"), t.hmpidXMip()); - histos.fill(HIST("hmpidYMip4"), t.hmpidYMip()); - histos.fill(HIST("hmpidXResiduals4"), t.hmpidXMip() - t.hmpidXTrack()); - histos.fill(HIST("hmpidYResiduals4"), t.hmpidYMip() - t.hmpidYTrack()); - histos.fill(HIST("hmpidNPhotons4"), t.hmpidNPhotons()); - histos.fill(HIST("hmpidQMip4"), t.hmpidQMip()); - histos.fill(HIST("hmpidClusSize4"), (t.hmpidClusSize() % 1000000) / 1000); - histos.fill(HIST("TrackMom4"), t.track_as().p()); - histos.fill(HIST("hmpidMom4"), std::abs(t.hmpidMom())); - for (int i = 0; i < 10; i++) { - if (t.hmpidPhotsCharge()[i] > 0) - histos.fill(HIST("hmpidPhotsCharge4"), t.hmpidPhotsCharge()[i]); - } - } - - if (t.hmpidClusSize() / 1000000 == 5) { - histos.fill(HIST("hmpidXTrack5"), t.hmpidXTrack()); - histos.fill(HIST("hmpidYTrack5"), t.hmpidYTrack()); - histos.fill(HIST("hmpidXMip5"), t.hmpidXMip()); - histos.fill(HIST("hmpidYMip5"), t.hmpidYMip()); - histos.fill(HIST("hmpidXResiduals5"), t.hmpidXMip() - t.hmpidXTrack()); - histos.fill(HIST("hmpidYResiduals5"), t.hmpidYMip() - t.hmpidYTrack()); - histos.fill(HIST("hmpidNPhotons5"), t.hmpidNPhotons()); - histos.fill(HIST("hmpidQMip5"), t.hmpidQMip()); - histos.fill(HIST("hmpidClusSize5"), (t.hmpidClusSize() % 1000000) / 1000); - histos.fill(HIST("TrackMom5"), t.track_as().p()); - histos.fill(HIST("hmpidMom5"), std::abs(t.hmpidMom())); - for (int i = 0; i < 10; i++) { - if (t.hmpidPhotsCharge()[i] > 0) - histos.fill(HIST("hmpidPhotsCharge5"), t.hmpidPhotsCharge()[i]); - } - } - - if (t.hmpidClusSize() / 1000000 == 6) { - histos.fill(HIST("hmpidXTrack6"), t.hmpidXTrack()); - histos.fill(HIST("hmpidYTrack6"), t.hmpidYTrack()); - histos.fill(HIST("hmpidXMip6"), t.hmpidXMip()); - histos.fill(HIST("hmpidYMip6"), t.hmpidYMip()); - histos.fill(HIST("hmpidXResiduals6"), t.hmpidXMip() - t.hmpidXTrack()); - histos.fill(HIST("hmpidYResiduals6"), t.hmpidYMip() - t.hmpidYTrack()); - histos.fill(HIST("hmpidNPhotons6"), t.hmpidNPhotons()); - histos.fill(HIST("hmpidQMip6"), t.hmpidQMip()); - histos.fill(HIST("hmpidClusSize6"), (t.hmpidClusSize() % 1000000) / 1000); - histos.fill(HIST("TrackMom6"), t.track_as().p()); - histos.fill(HIST("hmpidMom6"), std::abs(t.hmpidMom())); - for (int i = 0; i < 10; i++) { - if (t.hmpidPhotsCharge()[i] > 0) - histos.fill(HIST("hmpidPhotsCharge6"), t.hmpidPhotsCharge()[i]); - } - } - } - } -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfg) { return WorkflowSpec{adaptAnalysisTask(cfg)}; } diff --git a/DPG/Tasks/AOTTrack/PID/HMPID/tableHMPID.h b/DPG/Tasks/AOTTrack/PID/HMPID/tableHMPID.h new file mode 100644 index 00000000000..045282d3e0e --- /dev/null +++ b/DPG/Tasks/AOTTrack/PID/HMPID/tableHMPID.h @@ -0,0 +1,107 @@ +// 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. + +#ifndef DPG_TASKS_AOTTRACK_PID_HMPID_TABLEHMPID_H_ +#define DPG_TASKS_AOTTRACK_PID_HMPID_TABLEHMPID_H_ + +#include "Framework/ASoA.h" +#include "Framework/AnalysisDataModel.h" + +namespace o2::aod +{ + +inline constexpr int kDimPhotonsCharge = 10; + +namespace variables_table +{ +DECLARE_SOA_COLUMN(ChAngle, chAngle, float); +DECLARE_SOA_COLUMN(Phi, phi, float); +DECLARE_SOA_COLUMN(Eta, eta, float); +DECLARE_SOA_COLUMN(MomentumHmpid, momentumHmpid, float); +DECLARE_SOA_COLUMN(MomentumTrack, momentumTrack, float); +DECLARE_SOA_COLUMN(XTrack, xTrack, float); +DECLARE_SOA_COLUMN(YTrack, yTrack, float); +DECLARE_SOA_COLUMN(XMip, xMip, float); +DECLARE_SOA_COLUMN(YMip, yMip, float); +DECLARE_SOA_COLUMN(NPhotons, nPhotons, float); +DECLARE_SOA_COLUMN(ChargeMip, chargeMip, float); +DECLARE_SOA_COLUMN(ClusterSize, clusterSize, float); +DECLARE_SOA_COLUMN(Chamber, chamber, float); +DECLARE_SOA_COLUMN(PhotonsCharge, photonsCharge, float[kDimPhotonsCharge]); + +DECLARE_SOA_COLUMN(EtaTrack, etaTrack, float); +DECLARE_SOA_COLUMN(PhiTrack, phiTrack, float); +DECLARE_SOA_COLUMN(Px, px, float); +DECLARE_SOA_COLUMN(Py, py, float); +DECLARE_SOA_COLUMN(Pz, pz, float); + +DECLARE_SOA_COLUMN(ItsNCluster, itsNCluster, float); +DECLARE_SOA_COLUMN(TpcNCluster, tpcNCluster, float); +DECLARE_SOA_COLUMN(TpcNClsCrossedRows, tpcNClsCrossedRows, float); +DECLARE_SOA_COLUMN(TpcChi2, tpcChi2, float); +DECLARE_SOA_COLUMN(ItsChi2, itsChi2, float); + +DECLARE_SOA_COLUMN(DcaXY, dcaXY, float); +DECLARE_SOA_COLUMN(DcaZ, dcaZ, float); + +DECLARE_SOA_COLUMN(TpcNSigmaPi, tpcNSigmaPi, float); +DECLARE_SOA_COLUMN(TofNSigmaPi, tofNSigmaPi, float); +DECLARE_SOA_COLUMN(TpcNSigmaKa, tpcNSigmaKa, float); +DECLARE_SOA_COLUMN(TofNSigmaKa, tofNSigmaKa, float); +DECLARE_SOA_COLUMN(TpcNSigmaPr, tpcNSigmaPr, float); +DECLARE_SOA_COLUMN(TofNSigmaPr, tofNSigmaPr, float); +DECLARE_SOA_COLUMN(TpcNSigmaDe, tpcNSigmaDe, float); +DECLARE_SOA_COLUMN(TofNSigmaDe, tofNSigmaDe, float); + +DECLARE_SOA_COLUMN(Centrality, centrality, float); + +} // namespace variables_table + +DECLARE_SOA_TABLE(HmpidAnalysis, "AOD", "HMPIDANALYSIS", + variables_table::ChAngle, + variables_table::Phi, + variables_table::Eta, + variables_table::MomentumHmpid, + variables_table::MomentumTrack, + variables_table::XTrack, + variables_table::YTrack, + variables_table::XMip, + variables_table::YMip, + variables_table::NPhotons, + variables_table::ChargeMip, + variables_table::ClusterSize, + variables_table::Chamber, + variables_table::PhotonsCharge, + variables_table::EtaTrack, + variables_table::PhiTrack, + variables_table::Px, + variables_table::Py, + variables_table::Pz, + variables_table::ItsNCluster, + variables_table::TpcNCluster, + variables_table::TpcNClsCrossedRows, + variables_table::TpcChi2, + variables_table::ItsChi2, + variables_table::DcaXY, + variables_table::DcaZ, + variables_table::TpcNSigmaPi, + variables_table::TofNSigmaPi, + variables_table::TpcNSigmaKa, + variables_table::TofNSigmaKa, + variables_table::TpcNSigmaPr, + variables_table::TofNSigmaPr, + variables_table::TpcNSigmaDe, + variables_table::TofNSigmaDe, + variables_table::Centrality); + +} // namespace o2::aod + +#endif // DPG_TASKS_AOTTRACK_PID_HMPID_TABLEHMPID_H_