diff --git a/EventFiltering/CMakeLists.txt b/EventFiltering/CMakeLists.txt index d67c1589457..a6001817596 100644 --- a/EventFiltering/CMakeLists.txt +++ b/EventFiltering/CMakeLists.txt @@ -54,7 +54,7 @@ o2physics_add_dpl_workflow(hf-filter-prepare-ml-samples o2physics_add_dpl_workflow(cf-filter SOURCES PWGCF/CFFilterAll.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore KFParticle::KFParticle O2::ReconstructionDataFormats O2::DetectorsBase COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(cf-filter-qa diff --git a/EventFiltering/PWGCF/CFFilterAll.cxx b/EventFiltering/PWGCF/CFFilterAll.cxx index 4e326968b03..6d272e825cf 100644 --- a/EventFiltering/PWGCF/CFFilterAll.cxx +++ b/EventFiltering/PWGCF/CFFilterAll.cxx @@ -14,1433 +14,1035 @@ /// /// \author Laura Serksnyte, TU München, laura.serksnyte@cern.ch; Anton Riedel, TU München, anton.riedel@cern.ch; Maximilian Korwieser, TU Munich, maximilian.korwieser@cern.ch -#include -#include #include #include #include "../filterTables.h" +#include "CCDB/BasicCCDBManager.h" +#include "DataFormatsParameters/GRPMagField.h" +#include "DCAFitter/DCAFitterN.h" +#include "DetectorsBase/Propagator.h" + #include "fairlogger/Logger.h" -#include "Framework/Configurable.h" -#include "Framework/ASoAHelpers.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/AnalysisTask.h" -#include "Framework/HistogramRegistry.h" -#include "Framework/runDataProcessing.h" -#include "CommonConstants/MathConstants.h" -#include "Common/Core/TrackSelection.h" -#include "Common/DataModel/TrackSelectionTables.h" #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/PIDResponse.h" #include "Common/DataModel/PIDResponseITS.h" -#include "PWGLF/DataModel/LFStrangenessTables.h" -#include "DataFormatsTPC/BetheBlochAleph.h" -#include "CCDB/BasicCCDBManager.h" -#include "CCDB/CcdbApi.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/Core/RecoDecay.h" + +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/Configurable.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/runDataProcessing.h" + +#include "PWGLF/Utils/strangenessBuilderHelper.h" #include "Math/GenVector/Boost.h" #include "Math/Vector4D.h" #include "TMath.h" -#include "TRandom3.h" using namespace o2; +using namespace o2::aod; using namespace o2::framework; using namespace o2::framework::expressions; -namespace CFTrigger +namespace cf_trigger { // enums -enum CFThreeBodyTriggers { kPPP, - kPPL, - kPLL, - kLLL, - kPPPhi, - kPPRho, - kNThreeBodyTriggers }; -enum CFTwoBodyTriggers { kPD, - kLD, - kNTwoBodyTriggers -}; -enum ParticleSpecies { - kProton, - kDeuteron, - kPion, - kLambda, - kNParticleSpecies +enum CFTriggers { + kPPP, + kPPL, + kPLL, + kLLL, + kPPPhi, + kPPRho, + kPD, + kLD, + kRhoD, + kPhiD, + kNTriggers }; -enum V0Daughters { - kDaughPion, - kDaughProton, - kNV0Daughters + +// variables for track selection +const std::vector trackNames{"Pion", "Kaon", "Proton", "Deuteron"}; +const uint32_t nTrackNames = 4; + +const std::vector trackSelectionNames{"AbsEtaMax", "TpcClusterMin", "TpcRowMin", "TpcCrossedOverFoundMin", "TpcSharedMax", "TpcFracSharedMax", "ItsClusterMin", "ItsIbClusterMin", "AbsDcaXyMax", "AbsDcaZMax", "Chi2TpcMax", "Chi2ItsMax"}; +const uint32_t nTrackSelectionNames = 12; + +const float trackSelectionTable[nTrackNames][nTrackSelectionNames] = { + {0.85, 90, 80, 0.83, 160, 1, 1, 0, 0.15, 0.15, 99, 99}, // Pion + {0.85, 90, 80, 0.83, 160, 1, 1, 0, 0.15, 0.15, 99, 99}, // Kaon + {0.85, 90, 80, 0.83, 160, 1, 1, 0, 0.15, 0.15, 99, 99}, // Proton + {0.85, 90, 80, 0.83, 160, 1, 1, 0, 0.15, 0.15, 99, 99}, // Deuteron }; -enum ParticleRejection { kRejProton, - kRejPion, - kRejElectron, - kNParticleRejection + +const std::vector pidSelectionNames{"ItsMin", "ItsMax", "TpcMin", "TpcMax", "TpcTofMax"}; +const uint32_t nPidSelectionNames = 5; + +const float pidSelectionTable[nTrackNames][nPidSelectionNames] = { + {-99, 99, -4, 4, 4}, // Pion + {-99, 99, -4, 4, 4}, // Kaon + {-99, 99, -4, 4, 4}, // Proton + {-3.5, 3.5, -3.5, 3.5, 3.5}, // Deuteron }; -enum PIDLimits { kTPCMin, - kTPCMax, - kTOFMin, - kTOFMax, - kTPCTOF, - kITSmin, - kITSmax, - kNPIDLimits + +const std::vector momentumSelectionNames{"PtMin", "PtMax", "PThres", "UseInnerParam"}; +const uint32_t nMomentumSelectionNames = 4; + +const float momentumSelectionTable[nTrackNames][nMomentumSelectionNames] = { + {0, 6, 0.4, -1}, // Pion + {0, 6, 0.5, -1}, // Kaon + {0.3, 6, 0.75, -1}, // Proton + {0.4, 2, 1.2, -1}, // Deuteron }; -// For configurable tables -static const std::vector CFTriggerNamesALL{"ppp", "ppL", "pLL", "LLL", "ppPhi", "ppRho", "pd", "Ld"}; -static const std::vector SpeciesNameAll{"Proton", "Deuteron", "Lambda", "Pion"}; -static const std::vector SpeciesName{"Proton", "Deuteron", "Pion"}; -static const std::vector SpeciesNameAnti{"AntiProton", "AntiDeuteron", "AntiPion"}; -static const std::vector SpeciesV0DaughterName{"Pion", "Proton"}; -static const std::vector SpeciesRejectionName{"Proton", "Pion", "Electron"}; -static const std::vector TPCCutName{"TPC min", "TPC max"}; -static const std::vector SpeciesMinTPCClustersName{"Proton", "Deuteron", "Pion"}; -static const std::vector SpeciesAvgTPCTOFName{"Proton", "AntiProton", "Deuteron", "AntiDeuteron", "Pion", "AntiPion"}; -static const std::vector TPCTOFAvgName{"TPC Avg", "TOF Avg"}; -static const std::vector PidCutsName{"TPC min", "TPC max", "TOF min", "TOF max", "TPCTOF max", "ITS min", "ITS max"}; -static const std::vector PtCutsName{"Pt min (particle)", "Pt max (particle)", "Pt min (antiparticle)", "Pt max (antiparticle)", "P thres"}; -static const std::vector MomCorCutsName{"Momemtum Correlation min", "Momemtum Correlation max"}; -static const std::vector PIDForTrackingName{"Switch", "Momemtum Threshold"}; -static const std::vector ThreeBodyFilterNames{"PPP", "PPL", "PLL", "LLL", "PPPhi", "PPRho"}; -static const std::vector TwoBodyFilterNames{"PD", "LD"}; -static const std::vector ParticleNames{"PPP", "aPaPaP", "PPL", "aPaPaL", "PLL", "aPaLaL", "LLL", "aLaLaL", "PPPhi", "aPaPPhi", "PPRho", "aPaPRho", "PD", "aPaD", "LD", "aLaD"}; - -static const int nPidRejection = 2; -static const int nTracks = 3; -static const int nPidAvg = 6; -static const int nPidCutsDaughers = 2; -static const int nPtCuts = 5; -static const int nAllTriggers = 8; -static const int nTriggerAllNames = 16; -static const int nMomCorCuts = 2; -static const int nTPCTOFAvg = 2; - -static const float pidcutsTable[nTracks][kNPIDLimits]{ - {-6.f, 6.f, -6.f, 6.f, 6.f, -99.f, 99.f}, - {-6.f, 6.f, -99.f, 99.f, 99.f, -6.f, 6.f}, - {-6.f, 6.f, -99.f, 99.f, 99.f, -9999.f, 9999.f}}; -static const float pidcutsTableAnti[nTracks][kNPIDLimits]{ - {-6.f, 6.f, -6.f, 6.f, 6.f, -99.f, 99.f}, - {-6.f, 6.f, -99.f, 99.f, 99.f, -6.f, 6.f}, - {-6.f, 6.f, -99.f, 99.f, 99.f, -9999.f, 9999.f}}; -static const float pidRejectionTable[kNParticleRejection][nPidRejection]{ - {-2.f, 2.f}, - {-2.f, 2.f}, - {-999.f, 999.f}}; -static const double pidTPCTOFAvgTable[nPidAvg][nTPCTOFAvg]{ - {0.f, 0.f}, - {0.f, 0.f}, - {0.f, 0.f}, - {0.f, 0.f}, - {0.f, 0.f}, - {0.f, 0.f}}; -static const float pidcutsV0DaughterTable[kNV0Daughters][nPidCutsDaughers]{ - {-6.f, 6.f}, - {-6.f, 6.f}}; -static const float ptcutsTable[kNParticleSpecies][nPtCuts]{ - {0.35f, 6.f, 0.35f, 6.0f, 0.75f}, - {0.35f, 1.6f, 0.35f, 1.6f, 99.f}, - {0.f, 6.f, 0.f, 6.f, 99.f}, - {0.f, 6.f, 0.f, 6.f, 99.f}}; -static const float NClustersMin[1][nTracks]{ - {60.0f, 60.0f, 60.0f}}; -static const float MomCorLimits[3][nMomCorCuts] = - {{-99, 99}, - {-99, 99}, - {-99, 99}}; -static const float PIDForTrackingTable[nTracks][2]{ - {-1, 0.75}, - {-1, 1.2}, - {-1, 1.2}}; -static const float ITSCutsTable[1][nTracks] = { - {1, 1, 0}}; - -static const float triggerSwitches[1][nAllTriggers]{ - {1, 1, 1, 1, 1, 1, 1, 1}}; - -static const float Q3Limits[1][kNThreeBodyTriggers]{ - {0.6f, 0.6f, 0.6f, 0.6f, 0.6f, 0.6f}}; - -static const float KstarLimits[1][kNTwoBodyTriggers]{ - {1.2f, 1.2f}}; - -static const float Downsample[2][nTriggerAllNames]{ - {-1., -1., -1., -1., -1., -1., -1., -1., -1., -1., -1., -1, -1., -1., -1., -1.}, - {1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.}}; - -} // namespace CFTrigger - -namespace o2::aod -{ -using FemtoFullCollision = - soa::Join::iterator; +// variables for triggers +const std::vector filterNames{"PPP", "PPL", "PLL", "LLL", "PPPhi", "PPRho", "PD", "LD", "PhiD", "RhoD"}; +const uint32_t nFilterNames = 10; -using FemtoFullTracks = - soa::Join; -} // namespace o2::aod +const std::vector switches{"Switch"}; +const uint32_t nSwitches = 1; -struct CFFilter { +const float filterTable[nSwitches][nFilterNames]{ + {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}}; - Produces tags; +const std::vector limitNames{"Tight Limit", "Loose Limit"}; +const uint32_t nLimitNames = 2; - Service ccdb; - o2::ccdb::CcdbApi ccdbApi; +const float limitTable[nLimitNames][nFilterNames]{ + {0.6f, 0.6f, 0.6f, 0.6f, 0.6f, 0.6f, 0.5f, 0.5f, 0.5f, 0.5f}, + {1.2f, 1.2f, 1.2f, 1.2f, 1.2f, 1.2f, 1.0f, 1.0f, 1.0f, 1.0f}}; + +using FullCollisions = soa::Join; +using FullCollision = FullCollisions::iterator; + +using FullTracks = soa::Join; + +} // namespace cf_trigger - Configurable ConfRngSeed{"ConfRngSeed", 69, "Seed for downsampling"}; - TRandom3* rng; +struct CFFilterAll { + + Produces tags; // Configs for events - Configurable ConfIsRun3{ - "ConfIsRun3", - true, - "Is Run3"}; - - Configurable ConfEvtSelectZvtx{ - "ConfEvtSelectZvtx", - true, - "Event selection includes max. z-Vertex"}; - Configurable ConfEvtZvtx{"ConfEvtZvtx", - 10.f, - "Evt sel: Max. z-Vertex (cm)"}; - Configurable ConfEvtOfflineCheck{ - "ConfEvtOfflineCheck", - false, - "Evt sel: check for offline selection"}; - Configurable ConfEvtTimeFrameBorderCheck{ - "ConfEvtTimeFrameBorderCheck", - true, - "Evt sel: check for offline selection"}; - Configurable ConfAutocorRejection{ - "ConfAutocorRejection", - true, - "Rejection autocorrelation pL pairs"}; + struct : ConfigurableGroup { + std::string prefix = "EventSel"; + Configurable zvtx{"zvtx", 12.f, "Max. z-Vertex (cm)"}; + Configurable eventSel{"eventSel", true, "Use sel8"}; + } EventSelection; // Configs for tracks - Configurable ConfDeuteronThPVMom{ - "ConfDeuteronThPVMom", - false, - "True: use momentum at PV instead of TPCinnerparameter for threshold"}; - - Configurable ConfUseManualPIDproton{ - "ConfUseManualPIDproton", - false, - "True: use home-made PID solution for proton "}; - Configurable ConfPIDBBProton{ - "ConfPIDBBProton", - "Users/l/lserksny/PIDProton", - "Path to the CCDB ocject for proton BB param"}; - Configurable ConfPIDBBAntiProton{ - "ConfPIDBBAntiProton", - "Users/l/lserksny/PIDAntiProton", - "Path to the CCDB ocject for antiproton BB param"}; - - Configurable ConfUseManualPIDdeuteron{ - "ConfUseManualPIDdeuteron", - false, - "True: use home-made PID solution for deuteron "}; - Configurable ConfPIDBBDeuteron{ - "ConfPIDBBDeuteron", - "Users/l/lserksny/PIDDeuteron", - "Path to the CCDB ocject for Deuteron BB param"}; - Configurable ConfPIDBBAntiDeuteron{ - "ConfPIDBBAntiDeuteron", - "Users/l/lserksny/PIDAntiDeuteron", - "Path to the CCDB ocject for antiDeuteron BB param"}; - - Configurable ConfUseManualPIDpion{ - "ConfUseManualPIDpion", - false, - "True: use home-made PID solution for pions"}; - Configurable ConfPIDBBPion{ - "ConfPIDBBPion", - "Users/l/lserksny/PIDPion", - "Path to the CCDB ocject for Pion BB param"}; - Configurable ConfPIDBBAntiPion{ - "ConfPIDBBAntiPion", - "Users/l/lserksny/PIDAntiPion", - "Path to the CCDB ocject for antiPion BB param"}; - - Configurable ConfUseManualPIDel{ - "ConfUseManualPIDel", - false, - "True: use home-made PID solution for electron"}; - Configurable ConfPIDBBElectron{ - "ConfPIDBBElectron", - "Users/l/lserksny/PIDElectron", - "Path to the CCDB ocject for Electron BB param"}; - Configurable ConfPIDBBAntiElectron{ - "ConfPIDBBAntiElectron", - "Users/l/lserksny/PIDAntiElectron", - "Path to the CCDB ocject for antiElectron BB param"}; - - Configurable ConfUseManualPIDdaughterPion{ - "ConfUseManualPIDdaughterPion", - false, - "True: use home-made PID solution for pion from V0"}; - Configurable ConfUseManualPIDdaughterProton{ - "ConfUseManualPIDdaughterProton", - false, - "True: use home-made PID solution for proton from V0"}; - - Configurable ConfUseAvgFromCCDB{ - "ConfUseAvgFromCCDB", - false, - "True: use TOF and TPC averages from CCDB"}; - Configurable ConfAvgPath{ - "ConfAvgPath", - "Users/l/lserksny/TPCTOFAvg", - "Path to the CCDB ocject for TOF and TPC averages"}; - - Configurable ConfRejectNotPropagatedTracks{ - "ConfRejectNotPropagatedTracks", - false, - "True: reject not propagated tracks"}; - Configurable ConfTrkEta{ - "ConfTrkEta", - 0.85, - "Eta"}; - Configurable> ConfTPCNClustersMin{ - "ConfTPCNClustersMin", - {CFTrigger::NClustersMin[0], 1, CFTrigger::nTracks, std::vector{"TPCNClusMin"}, CFTrigger::SpeciesMinTPCClustersName}, - "kstar limit for two body trigger"}; - Configurable ConfTrkTPCfCls{ - "ConfTrkTPCfCls", - 0.83, - "Minimum fraction of crossed rows over findable clusters"}; - Configurable ConfTrkTPCcRowsMin{ - "ConfTrkTPCcRowsMin", - 70, - "Minimum number of crossed TPC rows"}; - Configurable ConfTrkTPCsClsMax{ - "ConfTrkTPCsClsMax", - 160, - "Maximum number of shared TPC clusters"}; - Configurable> ConfTrkITSnclsMin{ - "ConfTrkITSnclsMin", - {CFTrigger::ITSCutsTable[0], 1, CFTrigger::nTracks, std::vector{"Cut"}, CFTrigger::SpeciesName}, - "Minimum number of ITS clusters"}; - Configurable> ConfTrkITSnclsIBMin{ - "ConfTrkITSnclsIBMin", - {CFTrigger::ITSCutsTable[0], 1, CFTrigger::nTracks, std::vector{"Cut"}, CFTrigger::SpeciesName}, - "Minimum number of ITS clusters in the inner barrel"}; - Configurable ConfTrkDCAxyMax{ - "ConfTrkDCAxyMax", - 0.15, - "Maximum DCA_xy"}; - Configurable ConfTrkDCAzMax{ - "ConfTrkDCAzMax", - 0.3, - "Maximum DCA_z"}; - // Checks taken from global track definition - Configurable ConfTrkRequireChi2MaxTPC{ - "ConfTrkRequireChi2MaxTPC", false, - "True: require max chi2 per TPC cluster"}; - Configurable ConfTrkRequireChi2MaxITS{ - "ConfTrkRequireChi2MaxITS", false, - "True: require max chi2 per ITS cluster"}; - Configurable - ConfTrkMaxChi2PerClusterTPC{ - "ConfTrkMaxChi2PerClusterTPC", - 4.0f, - "Minimal track selection: max allowed chi2 per TPC cluster"}; // 4.0 is default of - // global tracks - // on 20.01.2023 - Configurable - ConfTrkMaxChi2PerClusterITS{ - "ConfTrkMaxChi2PerClusterITS", - 36.0f, - "Minimal track selection: max allowed chi2 per ITS cluster"}; // 36.0 is default of - // global tracks - // on 20.01.2023 - Configurable ConfTrkTPCRefit{ - "ConfTrkTPCRefit", - false, - "True: require TPC refit"}; - Configurable ConfTrkITSRefit{ - "ConfTrkITSRefit", - false, - "True: require ITS refit"}; - - // PID selections - Configurable> ConfPIDCuts{ - "ConfPIDCuts", - {CFTrigger::pidcutsTable[0], CFTrigger::nTracks, CFTrigger::kNPIDLimits, CFTrigger::SpeciesName, CFTrigger::PidCutsName}, - "Particle PID selections"}; - Configurable> ConfPIDCutsAnti{ - "ConfPIDCutsAnti", - {CFTrigger::pidcutsTableAnti[0], CFTrigger::nTracks, CFTrigger::kNPIDLimits, CFTrigger::SpeciesNameAnti, CFTrigger::PidCutsName}, - "Particle PID selections for antiparticles; perfect case scenario identical to particles"}; - Configurable ConfRejectNOTDeuteron{ - "ConfRejectNOTDeuteron", - false, - "Reject deuteron candidates if they are compatible with electron, pion, proton"}; - Configurable> ConfPIDRejection{ - "ConfPIDRejection", - {CFTrigger::pidRejectionTable[0], CFTrigger::kNParticleRejection, CFTrigger::nPidRejection, CFTrigger::SpeciesRejectionName, CFTrigger::TPCCutName}, - "Particle PID Rejection selections (Deuteron candidates only)"}; - Configurable> ConfPIDTPCTOFAvg{ - "ConfPIDTPCTOFAvg", - {CFTrigger::pidTPCTOFAvgTable[0], CFTrigger::nPidAvg, CFTrigger::nTPCTOFAvg, CFTrigger::SpeciesAvgTPCTOFName, CFTrigger::TPCTOFAvgName}, - "Average expected nSigma of TPC and TOF, which is substracted in calculation of combined TPC and TOF nSigma"}; - - // Momentum selections - Configurable> ConfMomCorDifCut{ - "ConfMomCorDifCuts", - {CFTrigger::MomCorLimits[0], CFTrigger::nTracks, CFTrigger::nMomCorCuts, CFTrigger::SpeciesName, CFTrigger::MomCorCutsName}, - "ratio on momentum correlation difference (particle)"}; - Configurable> ConfMomCorDifCutAnti{ - "ConfMomCorDifCutsAnti", - {CFTrigger::MomCorLimits[0], CFTrigger::nTracks, CFTrigger::nMomCorCuts, CFTrigger::SpeciesNameAnti, CFTrigger::MomCorCutsName}, - "Cut on momentum correlation difference (antipartilce)"}; - Configurable ConfMomCorDifCutFlag{"ConfMomCorDifFlag", false, "Flag for cut on momentum correlation difference"}; - - Configurable> ConfMomCorRatioCut{ - "ConfMomCorRatioCuts", - {CFTrigger::MomCorLimits[0], CFTrigger::nTracks, CFTrigger::nMomCorCuts, CFTrigger::SpeciesName, CFTrigger::MomCorCutsName}, - "Cut on momentum correlation ratio (particle)"}; - Configurable> ConfMomCorRatioCutAnti{ - "ConfMomCorRatioCutsAnti", - {CFTrigger::MomCorLimits[0], CFTrigger::nTracks, CFTrigger::nMomCorCuts, CFTrigger::SpeciesNameAnti, CFTrigger::MomCorCutsName}, - "Cut on momentum correlation ratio (antipartilce)"}; - Configurable ConfMomCorRatioCutFlag{"ConfMomCorRatioFlag", false, "Flag for cut on momentum correlation ratio"}; - - Configurable> ConfPIDForTracking{ - "ConfPIDForTracking", - {CFTrigger::PIDForTrackingTable[0], CFTrigger::nTracks, 2, CFTrigger::SpeciesName, CFTrigger::PIDForTrackingName}, - "Use PID used in tracking up to momentum threshold"}; - - Configurable> ConfPtCuts{ - "ConfPtCuts", - {CFTrigger::ptcutsTable[0], CFTrigger::kNParticleSpecies, CFTrigger::nPtCuts, CFTrigger::SpeciesNameAll, CFTrigger::PtCutsName}, - "Particle Momentum selections"}; + struct : ConfigurableGroup { + std::string prefix = "TrackSel"; + Configurable> trackProperties{"trackProperties", + {cf_trigger::trackSelectionTable[0], + cf_trigger::nTrackNames, + cf_trigger::nTrackSelectionNames, + cf_trigger::trackNames, + cf_trigger::trackSelectionNames}, + "Track Selections"}; + + Configurable> momentum{"momentum", + {cf_trigger::momentumSelectionTable[0], + cf_trigger::nTrackNames, + cf_trigger::nMomentumSelectionNames, + cf_trigger::trackNames, + cf_trigger::momentumSelectionNames}, + "Momentum Selections"}; + + Configurable> pid{"pid", + {cf_trigger::pidSelectionTable[0], + cf_trigger::nTrackNames, + cf_trigger::nPidSelectionNames, + cf_trigger::trackNames, + cf_trigger::pidSelectionNames}, + "PID Selections"}; + } TrackSelections; // Configs for V0 - Configurable ConfV0PtMin{ - "ConfV0PtMin", - 0.f, - "Minimum transverse momentum of V0"}; - Configurable ConfV0DCADaughMax{ - "ConfV0DCADaughMax", - 1.8f, - "Maximum DCA between the V0 daughters"}; - Configurable ConfV0CPAMin{ - "ConfV0CPAMin", - 0.985f, - "Minimum CPA of V0"}; - Configurable ConfV0TranRadV0Min{ - "ConfV0TranRadV0Min", - 0.2f, - "Minimum transverse radius"}; - Configurable ConfV0TranRadV0Max{ - "ConfV0TranRadV0Max", - 100.f, - "Maximum transverse radius"}; - Configurable ConfV0DecVtxMax{"ConfV0DecVtxMax", - 100.f, - "Maximum distance from primary vertex"}; - Configurable ConfV0InvMassLowLimit{ - "ConfV0InvMassLowLimit", - 1.05, - "Lower limit of the V0 invariant mass"}; - Configurable ConfV0InvMassUpLimit{ - "ConfV0InvMassUpLimit", - 1.18, - "Upper limit of the V0 invariant mass"}; - - Configurable ConfV0RejectKaons{"ConfV0RejectKaons", - true, - "Switch to reject kaons"}; - Configurable ConfV0InvKaonMassLowLimit{ - "ConfV0InvKaonMassLowLimit", - 0.49, - "Lower limit of the V0 invariant mass for Kaon rejection"}; - Configurable ConfV0InvKaonMassUpLimit{ - "ConfV0InvKaonMassUpLimit", - 0.505, - "Upper limit of the V0 invariant mass for Kaon rejection"}; - - // config for V0 daughters - Configurable ConfDaughEta{ - "ConfDaughEta", - 0.85f, - "V0 Daugh sel: max eta"}; - Configurable ConfDaughTPCnclsMin{ - "ConfDaughTPCnclsMin", - 60.f, - "V0 Daugh sel: Min. nCls TPC"}; - Configurable ConfDaughDCAMin{ - "ConfDaughDCAMin", - 0.04f, - "V0 Daugh sel: Max. DCA Daugh to PV (cm)"}; - Configurable> ConfDaughPIDCuts{ - "ConfDaughPIDCuts", - {CFTrigger::pidcutsV0DaughterTable[0], CFTrigger::kNV0Daughters, CFTrigger::nPidCutsDaughers, CFTrigger::SpeciesV0DaughterName, CFTrigger::TPCCutName}, - "PID selections for Lambda daughters"}; - - // config for ppPhi struct : ConfigurableGroup { - std::string prefix = "PPPhi"; - Configurable ConfResoInvMassLowLimit{"ConfResoInvMassLowLimit", 1.011461, "Lower limit of the Reso invariant mass"}; - Configurable ConfResoInvMassUpLimit{"ConfResoInvMassUpLimit", 1.027461, "Upper limit of the Reso invariant mass"}; - - Configurable ConfTrkEtaKa{"ConfTrkEtaKa", 0.85, "Eta kaon daughters"}; // 0.8 - Configurable ConfTrkDCAxyKa{"ConfTrkDCAxyKa", 0.15, "DCAxy kaon daughters"}; // 0.1 - Configurable ConfTrkDCAzKa{"ConfTrkDCAzKa", 0.3, "DCAz kaon daughters"}; // 0.2 - Configurable ConfNClusKa{"ConfNClusKa", 70, "NClusters kaon daughters"}; // 0.2 - Configurable ConfNCrossedKa{"ConfNCrossedKa", 65, "NCrossedRows kaon daughters"}; // 0.2 - Configurable ConfTrkTPCfClsKa{"ConfTrkTPCfClsKa", 0.80, "Minimum fraction of crossed rows over findable clusters kaon daughters"}; // 0.2 - - Configurable ConfTrkPtKaUp{"ConfTrkPtKaUp", 6.0, "Pt_up kaon daughters"}; // 2.0 - Configurable ConfTrkPtKaDown{"ConfTrkPtKaDown", 0.05, "Pt_down kaon daughters"}; // 0.15 - Configurable ConfTrkPTPCKaThr{"ConfTrkPTPCKaThr", 0.40, "p_TPC,Thr kaon daughters"}; // 0.4 - Configurable ConfTrkKaSigmaPID{"ConfTrkKaSigmaPID", 3.50, "n_sigma kaon daughters"}; // 3.0 - } PPPhi; - - // config collection for ppRho // + std::string prefix = "V0BuilderOpts"; + Configurable minCrossedRows{"minCrossedRows", 70, "minimum TPC crossed rows for daughter tracks"}; + Configurable dcanegtopv{"dcanegtopv", 0.04, "DCA Neg To PV"}; + Configurable dcapostopv{"dcapostopv", 0.04, "DCA Pos To PV"}; + Configurable v0cospa{"v0cospa", 0.95, "V0 CosPA"}; // double -> N.B. dcos(x)/dx = 0 at x=0) + Configurable dcav0dau{"dcav0dau", 2.0, "DCA V0 Daughters"}; + Configurable v0radius{"v0radius", 0, "v0radius"}; + Configurable maxDaughterEta{"maxDaughterEta", 5, "Maximum daughter eta (in abs value)"}; + Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + } V0BuilderOpts; + + struct : ConfigurableGroup { + std::string prefix = "FitterOpts"; + Configurable propagateToPCA{"propagateToPCA", true, "Create tracks version propagated to PCA"}; + Configurable maxR{"maxR", 200., "reject PCA's above this radius"}; + Configurable minParamChange{"minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable minRelChi2Change{"minRelChi2Change", 0.9, "stop iteraterions if chi2/chi2old > this"}; + Configurable maxDzIni{"maxDzIni", 1.e9, "reject (if>0) PCA candicate if tracks DZ exceeds threshold"}; + Configurable maxDxyIni{"maxDxyIni", 4., "Same as above for DXY"}; + Configurable maxChi2{"maxChi2", 1.e9, "Maximum chi2"}; + Configurable useAbsDCA{"useAbsDCA", true, "Minimise abs. distance rather than chi2"}; + Configurable weightedFinalPCA{"weightedFinalPCA", false, "Weight final PCA"}; + } FitterOpts; + struct : ConfigurableGroup { - std::string prefix = "PPRho"; - Configurable ConfResoRho0InvMassLowLimit{"ConfResoRho0InvMassLowLimit", 0.7, "Lower limit of the RhoReso invariant mass"}; - Configurable ConfResoRho0InvMassUpLimit{"ConfResoRho0InvMassUpLimit", 0.85, "Upper limit of the RhoReso invariant mass"}; + std::string prefix = "LambdaSel"; + Configurable ptMin{"ptMin", 0.f, "Minimum transverse momentum of V0"}; + Configurable dcaDaughMax{"dcaDaughMax", 2.f, "Maximum DCA between the V0 daughters"}; + Configurable cpaMin{"cpaMin", 0.95f, "Minimum CPA of V0"}; + Configurable tranRadMin{"tranRadMin", 0.f, "Minimum transverse radius"}; + Configurable tranRadMax{"tranRadMax", 100.f, "Maximum transverse radius"}; + Configurable decVtxMax{"decVtxMax", 100.f, "Maximum distance from primary vertex"}; + Configurable invMassLow{"invMassLow", 1.05, "Lower limit of the V0 invariant mass"}; + Configurable invMassUp{"invMassUp", 1.18, "Upper limit of the V0 invariant mass"}; + Configurable rejectKaons{"rejectKaons", true, "Switch to reject kaons"}; + Configurable invKaonMassLow{"invKaonMassLow", 0.49, "Lower limit of the V0 invariant mass for Kaon rejection"}; + Configurable invKaonMassUp{"invKaonMassUp", 0.505, "Upper limit of the V0 invariant mass for Kaon rejection"}; + } LambdaSelections; - Configurable ConfTrkPtRho0CandLowLimit{"ConfTrkPtRho0CandLowLimit", 1.8, "Pt_LowLimit Rho0Cand"}; - Configurable ConfTrkPtRho0CandUpLimit{"ConfTrkPtRho0CandUpLimit", 10., "Pt_UpLimit Rho0Cand"}; - } PPRho; + struct : ConfigurableGroup { + std::string prefix = "LambdaDaughterSel"; + Configurable absEtaMax{"absEtaMax", 0.85f, "V0 Daugh sel: max eta"}; + Configurable tpcClusterMin{"tpcClusterMin", 70.f, "V0 Daugh sel: Min. nCls TPC"}; + Configurable dcaMin{"dcaMin", 0.04f, "V0 Daugh sel: Max. DCA Daugh to PV (cm)"}; + Configurable tpcMax{"tpcMax", 5, "PID selections for Lambda daughters"}; + } LambdaDaughterSelections; + + struct : ConfigurableGroup { + std::string prefix = "PhiSel"; + Configurable invMassLow{"invMassLow", 1.011461, "Lower limit of Phi invariant mass"}; + Configurable invMassUp{"invMassUp", 1.027461, "Upper limit of Phi invariant mass"}; + Configurable tightInvMassLow{"tightInvMassLow", 1.011461, "Lower tight limit of Phi invariant mass"}; + Configurable tightInvMassUp{"tightInvMassUp", 1.027461, "Upper tight limit of Phi invariant mass"}; + } PhiSelections; + + struct : ConfigurableGroup { + std::string prefix = "RhoSel"; + Configurable invMassLow{"invMassLow", 0.7, "Lower limit of Rho invariant mass"}; + Configurable invMassUp{"invMassUp", 0.85, "Upper limit of Rho invariant mass"}; + Configurable ptLow{"ptLow", 3, "Lower pt limit for rho"}; + Configurable tightInvMassLow{"tightInvMassLow", 0.73, "Lower tight limit of Rho invariant mass"}; + Configurable tightInvMassUp{"tightInvMassUp", 0.82, "Upper tight limit of Rho invariant mass"}; + } RhoSelections; // Trigger selections - Configurable> ConfTriggerSwitches{ - "ConfTriggerSwitches", - {CFTrigger::triggerSwitches[0], 1, CFTrigger::nAllTriggers, std::vector{"Switch"}, CFTrigger::CFTriggerNamesALL}, - "Turn on specific trigger"}; - - Configurable> ConfQ3Limits{ - "ConfQ3Limits", - {CFTrigger::Q3Limits[0], 1, CFTrigger::kNThreeBodyTriggers, std::vector{"Limit"}, CFTrigger::ThreeBodyFilterNames}, - "Q3 limits for three body trigger"}; - - Configurable> ConfKstarLimits{ - "ConfKstarLimits", - {CFTrigger::KstarLimits[0], 1, CFTrigger::kNTwoBodyTriggers, std::vector{"Limit"}, CFTrigger::TwoBodyFilterNames}, - "kstar limit for two body trigger"}; - - Configurable> ConfDownsample{ - "ConfDownsample", - {CFTrigger::Downsample[0], 2, CFTrigger::nTriggerAllNames, std::vector{"Switch", "Factor"}, CFTrigger::ParticleNames}, - "Downsample individual particle species (Switch has to be larger than 0, Factor has to smaller than 1)"}; + struct : ConfigurableGroup { + std::string prefix = "Triggers"; + Configurable> filterSwitches{"filterSwitches", + {cf_trigger::filterTable[0], + cf_trigger::nSwitches, + cf_trigger::nFilterNames, + cf_trigger::switches, + cf_trigger::filterNames}, + "Switch for triggers"}; + Configurable> limits{"limits", + {cf_trigger::limitTable[0], + cf_trigger::nLimitNames, + cf_trigger::nFilterNames, + cf_trigger::limitNames, + cf_trigger::filterNames}, + "Limits for trigger. Tight limit without downsampling and loose with downsampling"}; + } TriggerSelections; + + struct : ConfigurableGroup { + std::string prefix = "Binning"; + ConfigurableAxis multiplicity{"multiplicity", {200, 0, 200}, "Binning Multiplicity"}; + ConfigurableAxis zvtx{"zvtx", {30, -15, 15}, "Binning Zvertex"}; + + ConfigurableAxis momentum{"momentum", {600, 0, 6}, "Binning Momentum"}; + ConfigurableAxis eta{"eta", {200, -1, 1}, "Binning eta"}; + ConfigurableAxis phi{"phi", {720, 0, o2::constants::math::TwoPI}, "Binning phi"}; + ConfigurableAxis dca{"dca", {100, -0.2, 0.2}, "Binning Dca"}; + + ConfigurableAxis nsigma{"nsigma", {500, -5, 5}, "Binning nsigma"}; + ConfigurableAxis nsigmaComb{"nsigmaComb", {500, 0, 5}, "Binning nsigma comb"}; + ConfigurableAxis tpcSignal{"tpcSignal", {500, 0, 500}, "Binning Tpc Signal"}; + ConfigurableAxis itsSignal{"itsSignal", {150, 0, 15}, "Binning Its Signal"}; + ConfigurableAxis tofSignal{"tofSignal", {120, 0, 1.2}, "Binning Tof Signal"}; + ConfigurableAxis tpcCluster{"tpcCluster", {153, 0, 153}, "Binning Tpc Clusters"}; + ConfigurableAxis tpcChi2{"tpcChi2", {100, 0, 5}, "Binning TPC chi2"}; + ConfigurableAxis itsCluster{"itsCluster", {8, -0.5, 7.5}, "Binning Its Clusters"}; + ConfigurableAxis itsIbCluster{"itsIbCluster", {4, -0.5, 3.5}, "Binning Its Inner Barrel Clusters"}; + ConfigurableAxis itsChi2{"itsChi2", {100, 0, 50}, "Binning ITS chi2"}; + + ConfigurableAxis momCor{"momCor", {100, -1, 1}, "Binning Ratios"}; + ConfigurableAxis ratio{"ratio", {200, 0, 2}, "Binning Ratios"}; + + ConfigurableAxis invMassLambda{"invMassLambda", {200, 1, 1.2}, "Binning Invariant Mass Lambda"}; + ConfigurableAxis invMassK0short{"invMassK0short", {100, 0.48, 0.52}, "Binning Invariant Mass K0short"}; + + ConfigurableAxis dcaDaugh{"dcaDaugh", {200, 0, 2}, "Binning daughter DCA at decay vertex"}; + ConfigurableAxis cpa{"cpa", {100, 0.9, 1}, "Binning CPA"}; + ConfigurableAxis transRad{"transRad", {100, 0, 100}, "Binning Transverse Radius"}; + ConfigurableAxis decayVtx{"decayVtx", {100, 0, 100}, "Binning Decay Vertex"}; + + ConfigurableAxis invMassPhi{"invMassPhi", {700, 0.8, 1.5}, "Binning Invariant Mass Phi"}; + + ConfigurableAxis invMassRho{"invMassRho", {600, 0.6, 1.2}, "Binning Invariant Mass Rho"}; + + ConfigurableAxis q3{"q3", {300, 0, 3}, "Binning Decay Q3"}; + ConfigurableAxis kstar{"kstar", {300, 0, 3}, "Binning Decay Kstar"}; + + } Binning; HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject}; - // HistogramRegistry registryQA{"registryQA", {}, OutputObjHandlingPolicy::AnalysisObject}; - std::vector BBProton, BBAntiproton, BBDeuteron, BBAntideuteron, BBPion, BBAntipion, BBElectron, BBAntielectron, TPCTOFAvg; + // helper object flor building lambdas + o2::pwglf::strangenessBuilderHelper mStraHelper; + Service ccdb; + int mRunNumber = 0; + float mBz = 0.; + + // 4vectors for all particles + std::vector vecProton, vecAntiProton, vecDeuteron, vecAntiDeuteron, vecLambda, vecAntiLambda, vecKaon, vecAntiKaon, vecPhi, vecPion, vecAntiPion, vecRho; + // indices for all particles + std::vector idxProton, idxAntiProton, idxDeuteron, idxAntiDeuteron, idxKaon, idxAntiKaon, idxPion, idxAntiPion; + // indices for lambda daughters + std::vector idxLambdaDaughProton, idxLambdaDaughPion, idxAntiLambdaDaughProton, idxAntiLambdaDaughPion, idxPhiDaughPos, idxPhiDaughNeg, idxRhoDaughPos, idxRhoDaughNeg; + + // arrays to store found pairs/tripplets and trigger decisions + std::array keepEventTightLimit; + std::array keepEventLooseLimit; + std::array signalTightLimit; + std::array signalLooseLimit; + void init(o2::framework::InitContext&) { - rng = new TRandom3(ConfRngSeed.value); - - // init the ccdb - ccdb->setURL("http://alice-ccdb.cern.ch"); - ccdbApi.init("http://alice-ccdb.cern.ch"); - ccdb->setCaching(true); - ccdb->setLocalObjectValidityChecking(); - - // Set avg if not taking from ccdb - if (!ConfUseAvgFromCCDB) { - TPCTOFAvg = {ConfPIDTPCTOFAvg->get("Proton", "TPC Avg"), - ConfPIDTPCTOFAvg->get("Proton", "TOF Avg"), - ConfPIDTPCTOFAvg->get("AntiProton", "TPC Avg"), - ConfPIDTPCTOFAvg->get("AntiProton", "TOF Avg"), - ConfPIDTPCTOFAvg->get("Deuteron", "TPC Avg"), - ConfPIDTPCTOFAvg->get("Deuteron", "TOF Avg"), - ConfPIDTPCTOFAvg->get("AntiDeuteron", "TPC Avg"), - ConfPIDTPCTOFAvg->get("AntiDeuteron", "TOF Avg")}; - } - - // global histograms - registry.add("fProcessedEvents", "CF - event filtered;;Events", HistType::kTH1F, {{10, -0.5, 9.5}}); - std::vector eventTitles = {"all", "rejected", "ppp", "ppL", "pLL", "LLL", "ppPhi", "ppRho", "pD", "LD"}; - for (size_t iBin = 0; iBin < eventTitles.size(); iBin++) { - registry.get(HIST("fProcessedEvents"))->GetXaxis()->SetBinLabel(iBin + 1, eventTitles[iBin].data()); + // setup strangeness builder + mStraHelper.v0selections.minCrossedRows = V0BuilderOpts.minCrossedRows.value; + mStraHelper.v0selections.dcanegtopv = V0BuilderOpts.dcanegtopv.value; + mStraHelper.v0selections.dcapostopv = V0BuilderOpts.dcapostopv.value; + mStraHelper.v0selections.v0cospa = V0BuilderOpts.v0cospa.value; + mStraHelper.v0selections.dcav0dau = V0BuilderOpts.dcav0dau.value; + mStraHelper.v0selections.v0radius = V0BuilderOpts.v0radius.value; + mStraHelper.v0selections.maxDaughterEta = V0BuilderOpts.maxDaughterEta.value; + + mStraHelper.fitter.setPropagateToPCA(FitterOpts.propagateToPCA.value); + mStraHelper.fitter.setMaxR(FitterOpts.maxR.value); + mStraHelper.fitter.setMinParamChange(FitterOpts.minParamChange.value); + mStraHelper.fitter.setMinRelChi2Change(FitterOpts.minRelChi2Change.value); + mStraHelper.fitter.setMaxDZIni(FitterOpts.maxDzIni.value); + mStraHelper.fitter.setMaxDXYIni(FitterOpts.maxDxyIni.value); + mStraHelper.fitter.setMaxChi2(FitterOpts.maxChi2.value); + mStraHelper.fitter.setUseAbsDCA(FitterOpts.useAbsDCA.value); + mStraHelper.fitter.setWeightedFinalPCA(FitterOpts.weightedFinalPCA.value); + + // setup histograms + int allTriggers = 2 * cf_trigger::nFilterNames; + int prossedEventsBins = 3 + allTriggers; + std::vector triggerTitles = {"ppp_LooseQ3", "ppp_TightQ3", + "ppL_LooseQ3", "ppL_TightQ3", + "pLL_LooseQ3", "pLL_TightQ3", + "LLL_LooseQ3", "LLL_TightQ3", + "ppPhi_LooseQ3", "ppPhi_TightQ3", + "ppRho_LooseQ3", "ppRho_TightQ3", + "pD_LooseKstar", "pD_TightKstar", + "LD_LooseKstar", "LD_TightKstar", + "PhiD_LooseKstar", "PhiD_TightKstar", + "RhoD_LooseKstar", "RhoD_TightKstar"}; + + registry.add("fProcessedEvents", "CF - event filtered;;Events", HistType::kTH1F, {{prossedEventsBins, -0.5, prossedEventsBins - 0.5}}); + registry.get(HIST("fProcessedEvents"))->GetXaxis()->SetBinLabel(1, "all"); + registry.get(HIST("fProcessedEvents"))->GetXaxis()->SetBinLabel(2, "accepted_loose"); + registry.get(HIST("fProcessedEvents"))->GetXaxis()->SetBinLabel(3, "accepted_tight"); + + registry.add("fTriggerCorrelations", "CF - Trigger correlations", HistType::kTH2F, {{allTriggers, -0.5, allTriggers - 0.5}, {allTriggers, -0.5, allTriggers - 0.5}}); + + for (size_t iBin = 0; iBin < triggerTitles.size(); iBin++) { + registry.get(HIST("fProcessedEvents"))->GetXaxis()->SetBinLabel(iBin + 4, triggerTitles[iBin].data()); // start triggers from 4th bin + registry.get(HIST("fTriggerCorrelations"))->GetXaxis()->SetBinLabel(iBin + 1, triggerTitles[iBin].data()); + registry.get(HIST("fTriggerCorrelations"))->GetYaxis()->SetBinLabel(iBin + 1, triggerTitles[iBin].data()); } // event cuts - registry.add("EventCuts/fMultiplicityBefore", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - registry.add("EventCuts/fMultiplicityAfter", "Multiplicity after event cuts;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - registry.add("EventCuts/fZvtxBefore", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - registry.add("EventCuts/fZvtxAfter", "Zvtx after event cuts;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - - // mom correlations p vs pTPC - registry.add("TrackCuts/TracksBefore/fMomCorrelationPos", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - registry.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsPos", "fMomCorrelationAfterCuts;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - registry.add("TrackCuts/TracksBefore/fMomCorrelationNeg", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - registry.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsNeg", "fMomCorrelationAfterCuts;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - - registry.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsProton", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - registry.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiProton", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - registry.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsDeuteron", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - registry.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiDeuteron", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - - registry.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsPion", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{1000, 0.0f, 20.0f}, {1000, 0.0f, 20.0f}}}); - registry.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiPion", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{1000, 0.0f, 20.0f}, {1000, 0.0f, 20.0f}}}); - - // all tracks - registry.add("TrackCuts/TracksBefore/fPtTrackBefore", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/TracksBefore/fEtaTrackBefore", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/TracksBefore/fPhiTrackBefore", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); + registry.add("EventQA/Before/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("EventQA/Before/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + + registry.add("EventQA/After/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("EventQA/After/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + + // all tracks before cuts + registry.add("TrackQA/Before/Particle/fPt", "Transverse;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/Before/Particle/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("TrackQA/Before/Particle/fPhi", "Azimuthal;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("TrackQA/Before/Particle/fMomCor", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {Binning.momentum, Binning.momCor}}); + registry.add("TrackQA/Before/Particle/fItsSignal", "ITSSignal;p_{TPC} (GeV/c);ITS Signal", {HistType::kTH2F, {Binning.momentum, Binning.itsSignal}}); + registry.add("TrackQA/Before/Particle/fTpcSignal", "TPCSignal;p_{TPC} (GeV/c);TPC Signal", {HistType::kTH2F, {Binning.momentum, Binning.tpcSignal}}); + registry.add("TrackQA/Before/Particle/fTofSignal", "TOFSignal;p_{TPC} (GeV/c);TOF Signal", {HistType::kTH2F, {Binning.momentum, Binning.tofSignal}}); + + registry.add("TrackQA/Before/AntiParticle/fPt", "Transverse momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/Before/AntiParticle/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("TrackQA/Before/AntiParticle/fPhi", "Azimuthal angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("TrackQA/Before/AntiParticle/fMomCor", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {Binning.momentum, Binning.momCor}}); + registry.add("TrackQA/Before/AntiParticle/fItsSignal", "ITSSignal;p_{TPC} (GeV/c);ITS Signal", {HistType::kTH2F, {Binning.momentum, Binning.itsSignal}}); + registry.add("TrackQA/Before/AntiParticle/fTpcSignal", "TPCSignal;p_{TPC} (GeV/c);TPC Signal", {HistType::kTH2F, {Binning.momentum, Binning.tpcSignal}}); + registry.add("TrackQA/Before/AntiParticle/fTofSignal", "TOFSignal;p_{TPC} (GeV/c);TOF Signal", {HistType::kTH2F, {Binning.momentum, Binning.tofSignal}}); // PID vs momentum before cuts - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCvsPProtonBefore", "NSigmaTPC Proton Before;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTOFvsPProtonBefore", "NSigmaTOF Proton Before;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCTOFvsPProtonBefore", "NsigmaTPCTOF Proton Before;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaITSvsPProtonBefore", "NSigmaITS Proton Before;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCvsPAntiProtonBefore", "NSigmaTPC AntiProton Before;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTOFvsPAntiProtonBefore", "NSigmaTOF AntiProton Before;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCTOFvsPAntiProtonBefore", "NSigmaTPCTOF AntiProton Before;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaITSvsPAntiProtonBefore", "NSigmaITS AntiProton Before;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCvsPDeuteronBefore", "NSigmaTPC Deuteron Before;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTOFvsPDeuteronBefore", "NSigmaTOF Deuteron Before;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCTOFvsPDeuteronBefore", "NSigmaTPCTOF Deuteron Before;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaITSvsPDeuteronBefore", "NSigmaITS Deuteron Before;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCvsPAntiDeuteronBefore", "NSigmaTPC AntiDeuteron Before;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTOFvsPAntiDeuteronBefore", "NSigmaTOF AntiDeuteron Before;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCTOFvsPAntiDeuteronBefore", "NSigmaTPCTOF AntiDeuteron Before;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaITSvsPAntiDeuteronBefore", "NSigmaITS AntiDeuteron Before;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCvsPDeuteronBeforeP", "NSigmaTPC Deuteron BeforeP;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCvsPAntiDeuteronBeforeP", "NSigmaTPC AntiDeuteron BeforeP;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - // TPC signal - registry.add("TrackCuts/TPCSignal/fTPCSignal", "TPCSignal;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalP", "TPCSignalP;p (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalALLCUTS", "TPCSignalALLCUTS;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalALLCUTSP", "TPCSignalALLCUTSP;p (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - - // TPC signal anti - registry.add("TrackCuts/TPCSignal/fTPCSignalAnti", "TPCSignal;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalAntiP", "TPCSignalP;p (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalAntiALLCUTS", "TPCSignalALLCUTS;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalAntiALLCUTSP", "TPCSignalALLCUTSP;p(GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - - // TPC signal particles - registry.add("TrackCuts/TPCSignal/fTPCSignalProton", "fTPCSignalProton;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalAntiProton", "fTPCSignalAntiProton;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalDeuteron", "fTPCSignalDeuteron;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalAntiDeuteron", "fTPCSignalAntiDeuteron;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalPionMinusV0Daughter", "fTPCSignalPionMinusV0Daughter;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalPionPlusV0Daughter", "fTPCSignalPionPlusV0Daughter;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalProtonMinusV0Daughter", "fTPCSignalProtonMinusV0Daughter;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalProtonPlusV0Daughter", "fTPCSignalProtonPlusV0Daughter;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalPion", "fTPCSignalPion;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - registry.add("TrackCuts/TPCSignal/fTPCSignalAntiPion", "fTPCSignalAntiPion;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - - // PID vs momentum before cuts daughters - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCvsPProtonV0DaughBefore", "NSigmaTPC Proton V0Daught Before;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCvsPPionMinusV0DaughBefore", "NSigmaTPC AntiPion V0Daught Before;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCvsPAntiProtonAntiV0DaughBefore", "NSigmaTPC AntiProton antiV0Daught Before;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/NSigmaBefore/fNsigmaTPCvsPPionPlusAntiV0DaughBefore", "NSigmaTPC Pion antiV0Daught Before;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + registry.add("TrackQA/Before/Pion/fNsigmaITS", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Pion/fNsigmaTPC", "NSigmaTPC;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Pion/fNsigmaTOF", "NSigmaTOF;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Pion/fNsigmaTPCTOF", "NsigmaTPCTOF;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/Before/AntiPion/fNsigmaITS", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiPion/fNsigmaTPC", "NSigmaTPC;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiPion/fNsigmaTOF", "NSigmaTOF;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiPion/fNsigmaTPCTOF", "NsigmaTPCTOF;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/Before/Kaon/fNsigmaITS", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Kaon/fNsigmaTPC", "NSigmaTPC;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Kaon/fNsigmaTOF", "NSigmaTOF;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Kaon/fNsigmaTPCTOF", "NsigmaTPCTOF;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/Before/AntiKaon/fNsigmaITS", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiKaon/fNsigmaTPC", "NSigmaTPC;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiKaon/fNsigmaTOF", "NSigmaTOF;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiKaon/fNsigmaTPCTOF", "NsigmaTPCTOF;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/Before/Proton/fNsigmaITS", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Proton/fNsigmaTPC", "NSigmaTPC;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Proton/fNsigmaTOF", "NSigmaTOF;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Proton/fNsigmaTPCTOF", "NsigmaTPCTOF;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/Before/AntiProton/fNsigmaITS", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiProton/fNsigmaTPC", "NSigmaTPC;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiProton/fNsigmaTOF", "NSigmaTOF;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiProton/fNsigmaTPCTOF", "NsigmaTPCTOF;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/Before/Deuteron/fNsigmaITS", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Deuteron/fNsigmaTPC", "NSigmaTPC;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Deuteron/fNsigmaTOF", "NSigmaTOF;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/Deuteron/fNsigmaTPCTOF", "NsigmaTPCTOF;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/Before/AntiDeuteron/fNsigmaITS", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiDeuteron/fNsigmaTPC", "NSigmaTPC;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiDeuteron/fNsigmaTOF", "NSigmaTOF;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/Before/AntiDeuteron/fNsigmaTPCTOF", "NsigmaTPCTOF;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + // Pion + registry.add("TrackQA/After/Pion/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/Pion/fPTpc", "Momentum at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/Pion/fMomCor", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {Binning.momentum, Binning.momCor}}); + registry.add("TrackQA/After/Pion/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("TrackQA/After/Pion/fPhi", "Azimuthal angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + registry.add("TrackQA/After/Pion/fNsigmaIts", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Pion/fNsigmaTpc", "NSigmaTPC;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Pion/fNsigmaTof", "NSigmaTOF;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Pion/fNsigmaTpcTof", "NSigmaTPCTOF;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/After/Pion/fItsSignal", "ITS Signal;p (GeV/c); (cm)", {HistType::kTH2F, {Binning.momentum, Binning.itsSignal}}); + registry.add("TrackQA/After/Pion/fTpcSignal", "TPC Signal;p (GeV/c);TPC Signal", {HistType::kTH2F, {Binning.momentum, Binning.tpcSignal}}); + registry.add("TrackQA/After/Pion/fTofBeta", "TOF #beta;p (GeV/c);#beta_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.tofSignal}}); + + registry.add("TrackQA/After/Pion/fDcaXy", "DCA_{xy};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("TrackQA/After/Pion/fDcaZ", "DCA_{z};p_{T} (GeV/c); DCA_{Z};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + + registry.add("TrackQA/After/Pion/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Pion/fTpcCrossedRows", "TPC Crossed Rows;TPC Crossed Rows;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Pion/fTpcSharedClusters", "TPC Shared Clusters;TPC Shared Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Pion/fTpcSharedClusterOverClusterss", "TPC Shared Clusters/Clusters;TPC Shared Clusters/Clusters;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/Pion/fTpcFindableOverRows", "TPC Findabled/Crossed Rows;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/Pion/fTpcChi2OverCluster", "TPC #chi^{2}/Cluster;TPC #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.tpcChi2}); + + registry.add("TrackQA/After/Pion/fItsClusters", "ITS Clusters;ITS Clusters;Entries", HistType::kTH1F, {Binning.itsCluster}); + registry.add("TrackQA/After/Pion/fItsIbClusters", "ITS Inner Barrel Clusters;ITS Inner Barrel Clusters;Entries", HistType::kTH1F, {Binning.itsIbCluster}); + registry.add("TrackQA/After/Pion/fItsChi2OverCluster", "ITS #chi^{2}/Cluster;ITS #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.itsChi2}); + + // antiPion + registry.add("TrackQA/After/AntiPion/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/AntiPion/fPTpc", "Momentum at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/AntiPion/fMomCor", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {Binning.momentum, Binning.momCor}}); + registry.add("TrackQA/After/AntiPion/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("TrackQA/After/AntiPion/fPhi", "Azimuthal angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + registry.add("TrackQA/After/AntiPion/fNsigmaIts", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiPion/fNsigmaTpc", "NSigmaTPC;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiPion/fNsigmaTof", "NSigmaTOF;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiPion/fNsigmaTpcTof", "NSigmaTPCTOF;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/After/AntiPion/fItsSignal", "ITS Signal;p (GeV/c); (cm)", {HistType::kTH2F, {Binning.momentum, Binning.itsSignal}}); + registry.add("TrackQA/After/AntiPion/fTpcSignal", "TPC Signal;p (GeV/c);TPC Signal", {HistType::kTH2F, {Binning.momentum, Binning.tpcSignal}}); + registry.add("TrackQA/After/AntiPion/fTofBeta", "TOF #beta;p (GeV/c);#beta_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.tofSignal}}); + + registry.add("TrackQA/After/AntiPion/fDcaXy", "DCA_{xy};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("TrackQA/After/AntiPion/fDcaZ", "DCA_{z};p_{T} (GeV/c); DCA_{Z};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + + registry.add("TrackQA/After/AntiPion/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiPion/fTpcCrossedRows", "TPC Crossed Rows;TPC Crossed Rows;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiPion/fTpcSharedClusters", "TPC Shared Clusters;TPC Shared Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiPion/fTpcSharedClusterOverClusterss", "TPC Shared Clusters/Clusters;TPC Shared Clusters/Clusters;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/AntiPion/fTpcFindableOverRows", "TPC Findabled/Crossed Rows;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/AntiPion/fTpcChi2OverCluster", "TPC #chi^{2}/Cluster;TPC #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.tpcChi2}); + + registry.add("TrackQA/After/AntiPion/fItsClusters", "ITS Clusters;ITS Clusters;Entries", HistType::kTH1F, {Binning.itsCluster}); + registry.add("TrackQA/After/AntiPion/fItsIbClusters", "ITS Inner Barrel Clusters;ITS Inner Barrel Clusters;Entries", HistType::kTH1F, {Binning.itsIbCluster}); + registry.add("TrackQA/After/AntiPion/fItsChi2OverCluster", "ITS #chi^{2}/Cluster;ITS #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.itsChi2}); + + // Kaon + registry.add("TrackQA/After/Kaon/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/Kaon/fPTpc", "Momentum at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/Kaon/fMomCor", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {Binning.momentum, Binning.momCor}}); + registry.add("TrackQA/After/Kaon/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("TrackQA/After/Kaon/fPhi", "Azimuthal angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + registry.add("TrackQA/After/Kaon/fNsigmaIts", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Kaon/fNsigmaTpc", "NSigmaTPC;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Kaon/fNsigmaTof", "NSigmaTOF;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Kaon/fNsigmaTpcTof", "NSigmaTPCTOF;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/After/Kaon/fItsSignal", "ITS Signal;p (GeV/c); (cm)", {HistType::kTH2F, {Binning.momentum, Binning.itsSignal}}); + registry.add("TrackQA/After/Kaon/fTpcSignal", "TPC Signal;p (GeV/c);TPC Signal", {HistType::kTH2F, {Binning.momentum, Binning.tpcSignal}}); + registry.add("TrackQA/After/Kaon/fTofBeta", "TOF #beta;p (GeV/c);#beta_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.tofSignal}}); + + registry.add("TrackQA/After/Kaon/fDcaXy", "DCA_{xy};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("TrackQA/After/Kaon/fDcaZ", "DCA_{z};p_{T} (GeV/c); DCA_{Z};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + + registry.add("TrackQA/After/Kaon/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Kaon/fTpcCrossedRows", "TPC Crossed Rows;TPC Crossed Rows;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Kaon/fTpcSharedClusters", "TPC Shared Clusters;TPC Shared Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Kaon/fTpcSharedClusterOverClusterss", "TPC Shared Clusters/Clusters;TPC Shared Clusters/Clusters;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/Kaon/fTpcFindableOverRows", "TPC Findabled/Crossed Rows;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/Kaon/fTpcChi2OverCluster", "TPC #chi^{2}/Cluster;TPC #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.tpcChi2}); + + registry.add("TrackQA/After/Kaon/fItsClusters", "ITS Clusters;ITS Clusters;Entries", HistType::kTH1F, {Binning.itsCluster}); + registry.add("TrackQA/After/Kaon/fItsIbClusters", "ITS Inner Barrel Clusters;ITS Inner Barrel Clusters;Entries", HistType::kTH1F, {Binning.itsIbCluster}); + registry.add("TrackQA/After/Kaon/fItsChi2OverCluster", "ITS #chi^{2}/Cluster;ITS #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.itsChi2}); + + // antiKaon + registry.add("TrackQA/After/AntiKaon/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/AntiKaon/fPTpc", "Momentum at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/AntiKaon/fMomCor", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {Binning.momentum, Binning.momCor}}); + registry.add("TrackQA/After/AntiKaon/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("TrackQA/After/AntiKaon/fPhi", "Azimuthal angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + registry.add("TrackQA/After/AntiKaon/fNsigmaIts", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiKaon/fNsigmaTpc", "NSigmaTPC;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiKaon/fNsigmaTof", "NSigmaTOF;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiKaon/fNsigmaTpcTof", "NSigmaTPCTOF;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/After/AntiKaon/fItsSignal", "ITS Signal;p (GeV/c); (cm)", {HistType::kTH2F, {Binning.momentum, Binning.itsSignal}}); + registry.add("TrackQA/After/AntiKaon/fTpcSignal", "TPC Signal;p (GeV/c);TPC Signal", {HistType::kTH2F, {Binning.momentum, Binning.tpcSignal}}); + registry.add("TrackQA/After/AntiKaon/fTofBeta", "TOF #beta;p (GeV/c);#beta_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.tofSignal}}); + + registry.add("TrackQA/After/AntiKaon/fDcaXy", "DCA_{xy};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("TrackQA/After/AntiKaon/fDcaZ", "DCA_{z};p_{T} (GeV/c); DCA_{Z};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + + registry.add("TrackQA/After/AntiKaon/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiKaon/fTpcCrossedRows", "TPC Crossed Rows;TPC Crossed Rows;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiKaon/fTpcSharedClusters", "TPC Shared Clusters;TPC Shared Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiKaon/fTpcSharedClusterOverClusterss", "TPC Shared Clusters/Clusters;TPC Shared Clusters/Clusters;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/AntiKaon/fTpcFindableOverRows", "TPC Findabled/Crossed Rows;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/AntiKaon/fTpcChi2OverCluster", "TPC #chi^{2}/Cluster;TPC #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.tpcChi2}); + + registry.add("TrackQA/After/AntiKaon/fItsClusters", "ITS Clusters;ITS Clusters;Entries", HistType::kTH1F, {Binning.itsCluster}); + registry.add("TrackQA/After/AntiKaon/fItsIbClusters", "ITS Inner Barrel Clusters;ITS Inner Barrel Clusters;Entries", HistType::kTH1F, {Binning.itsIbCluster}); + registry.add("TrackQA/After/AntiKaon/fItsChi2OverCluster", "ITS #chi^{2}/Cluster;ITS #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.itsChi2}); // proton - // TEST P TPC - registry.add("TrackCuts/Proton/fPProton", "Momentum of protons at PV;p (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Proton/fPTPCProton", "Momentum of protons at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Proton/fPtProton", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Proton/fMomCorProtonDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - registry.add("TrackCuts/Proton/fMomCorProtonRatio", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - registry.add("TrackCuts/Proton/fEtaProton", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Proton/fPhiProton", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - registry.add("TrackCuts/Proton/fNsigmaTPCvsPProton", "NSigmaTPC Proton;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Proton/fNsigmaTOFvsPProton", "NSigmaTOF Proton;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Proton/fNsigmaTPCTOFvsPProton", "NSigmaTPCTOF Proton;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - registry.add("TrackCuts/Proton/fNsigmaITSvsPProton", "NSigmaITS Proton;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - registry.add("TrackCuts/Proton/fNsigmaTPCvsPProtonP", "NSigmaTPC Proton P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Proton/fNsigmaTOFvsPProtonP", "NSigmaTOF Proton P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Proton/fNsigmaTPCTOFvsPProtonP", "NSigmaTPCTOF Proton P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - registry.add("TrackCuts/Proton/fDCAxyProton", "fDCAxy Proton;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/Proton/fDCAzProton", "fDCAz Proton;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/Proton/fTPCsClsProton", "fTPCsCls Proton;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Proton/fTPCcRowsProton", "fTPCcRows Proton;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Proton/fTrkTPCfClsProton", "fTrkTPCfCls Proton;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - registry.add("TrackCuts/Proton/fTPCnclsProton", "fTPCncls Proton;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); + registry.add("TrackQA/After/Proton/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/Proton/fPTpc", "Momentum at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/Proton/fMomCor", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {Binning.momentum, Binning.momCor}}); + registry.add("TrackQA/After/Proton/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("TrackQA/After/Proton/fPhi", "Azimuthal angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + registry.add("TrackQA/After/Proton/fNsigmaIts", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Proton/fNsigmaTpc", "NSigmaTPC;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Proton/fNsigmaTof", "NSigmaTOF;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Proton/fNsigmaTpcTof", "NSigmaTPCTOF;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/After/Proton/fItsSignal", "ITS Signal;p (GeV/c); (cm)", {HistType::kTH2F, {Binning.momentum, Binning.itsSignal}}); + registry.add("TrackQA/After/Proton/fTpcSignal", "TPC Signal;p (GeV/c);TPC Signal", {HistType::kTH2F, {Binning.momentum, Binning.tpcSignal}}); + registry.add("TrackQA/After/Proton/fTofBeta", "TOF #beta;p (GeV/c);#beta_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.tofSignal}}); + + registry.add("TrackQA/After/Proton/fDcaXy", "DCA_{xy};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("TrackQA/After/Proton/fDcaZ", "DCA_{z};p_{T} (GeV/c); DCA_{Z};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + + registry.add("TrackQA/After/Proton/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Proton/fTpcCrossedRows", "TPC Crossed Rows;TPC Crossed Rows;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Proton/fTpcSharedClusters", "TPC Shared Clusters;TPC Shared Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Proton/fTpcSharedClusterOverClusterss", "TPC Shared Clusters/Clusters;TPC Shared Clusters/Clusters;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/Proton/fTpcFindableOverRows", "TPC Findabled/Crossed Rows;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/Proton/fTpcChi2OverCluster", "TPC #chi^{2}/Cluster;TPC #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.tpcChi2}); + + registry.add("TrackQA/After/Proton/fItsClusters", "ITS Clusters;ITS Clusters;Entries", HistType::kTH1F, {Binning.itsCluster}); + registry.add("TrackQA/After/Proton/fItsIbClusters", "ITS Inner Barrel Clusters;ITS Inner Barrel Clusters;Entries", HistType::kTH1F, {Binning.itsIbCluster}); + registry.add("TrackQA/After/Proton/fItsChi2OverCluster", "ITS #chi^{2}/Cluster;ITS #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.itsChi2}); // antiproton - registry.add("TrackCuts/AntiProton/fPtAntiProton", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/AntiProton/fMomCorAntiProtonDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - registry.add("TrackCuts/AntiProton/fMomCorAntiProtonRatio", "Momentum correlation;p_{reco} (GeV/c); |p_{TPC} - p_{reco}| (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - registry.add("TrackCuts/AntiProton/fEtaAntiProton", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/AntiProton/fPhiAntiProton", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - registry.add("TrackCuts/AntiProton/fNsigmaTPCvsPAntiProton", "NSigmaTPC AntiProton;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiProton/fNsigmaTOFvsPAntiProton", "NSigmaTOF AntiProton;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiProton/fNsigmaTPCTOFvsPAntiProton", "NSigmaTPCTOF AntiProton;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - registry.add("TrackCuts/AntiProton/fNsigmaITSvsPAntiProton", "NSigmaITS AntiProton;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - registry.add("TrackCuts/AntiProton/fNsigmaTPCvsPAntiProtonP", "NSigmaTPC AntiProton P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiProton/fNsigmaTOFvsPAntiProtonP", "NSigmaTOF AntiProton P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiProton/fNsigmaTPCTOFvsPAntiProtonP", "NSigmaTPCTOF AntiProton P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - registry.add("TrackCuts/AntiProton/fDCAxyAntiProton", "fDCAxy AntiProton;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/AntiProton/fDCAzAntiProton", "fDCAz AntiProton;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/AntiProton/fTPCsClsAntiProton", "fTPCsCls AntiProton;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/AntiProton/fTPCcRowsAntiProton", "fTPCcRows AntiProton;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/AntiProton/fTrkTPCfClsAntiProton", "fTrkTPCfCls AntiProton;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - registry.add("TrackCuts/AntiProton/fTPCnclsAntiProton", "fTPCncls AntiProton;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // deuteron - registry.add("TrackCuts/Deuteron/fPtDeuteron", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Deuteron/fMomCorDeuteronDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - registry.add("TrackCuts/Deuteron/fMomCorDeuteronRatio", "Momentum correlation;p_{reco} (GeV/c); |p_{TPC} - p_{reco}| (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - registry.add("TrackCuts/Deuteron/fEtaDeuteron", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Deuteron/fPhiDeuteron", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - registry.add("TrackCuts/Deuteron/fNsigmaTPCvsPDeuteron", "NSigmaTPC Deuteron;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Deuteron/fNsigmaTOFvsPDeuteron", "NSigmaTOF Deuteron;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Deuteron/fNsigmaTPCTOFvsPDeuteron", "NSigmaTPCTOF Deuteron;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - registry.add("TrackCuts/Deuteron/fNsigmaITSvsPDeuteron", "NSigmaITS Deuteron;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - registry.add("TrackCuts/Deuteron/fNsigmaTPCvsPDeuteronP", "NSigmaTPC Deuteron vd P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Deuteron/fNsigmaTOFvsPDeuteronP", "NSigmaTOF Deuteron P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Deuteron/fNsigmaTPCTOFvsPDeuteronP", "NSigmaTPCTOF Deuteron P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - registry.add("TrackCuts/Deuteron/fDCAxyDeuteron", "fDCAxy Deuteron;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/Deuteron/fDCAzDeuteron", "fDCAz Deuteron;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/Deuteron/fTPCsClsDeuteron", "fTPCsCls Deuteron;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Deuteron/fTPCcRowsDeuteron", "fTPCcRows Deuteron;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Deuteron/fTrkTPCfClsDeuteron", "fTrkTPCfCls Deuteron;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - registry.add("TrackCuts/Deuteron/fTPCnclsDeuteron", "fTPCncls Deuteron;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // antideuteron - registry.add("TrackCuts/AntiDeuteron/fPtAntiDeuteron", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/AntiDeuteron/fMomCorAntiDeuteronDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - registry.add("TrackCuts/AntiDeuteron/fMomCorAntiDeuteronRatio", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - registry.add("TrackCuts/AntiDeuteron/fEtaAntiDeuteron", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/AntiDeuteron/fPhiAntiDeuteron", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - registry.add("TrackCuts/AntiDeuteron/fNsigmaTPCvsPAntiDeuteron", "NSigmaTPC AntiDeuteron;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiDeuteron/fNsigmaTOFvsPAntiDeuteron", "NSigmaTOF AntiDeuteron;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiDeuteron/fNsigmaTPCTOFvsPAntiDeuteron", "NSigmaTPCTOF AntiDeuteron;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - registry.add("TrackCuts/AntiDeuteron/fNsigmaITSvsPAntiDeuteron", "NSigmaITS AntiDeuteron;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - registry.add("TrackCuts/AntiDeuteron/fNsigmaTPCvsPAntiDeuteronP", "NSigmaTPC AntiDeuteron P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiDeuteron/fNsigmaTOFvsPAntiDeuteronP", "NSigmaTOF AntiDeuteron P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiDeuteron/fNsigmaTPCTOFvsPAntiDeuteronP", "NSigmaTPCTOF AntiDeuteron P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - registry.add("TrackCuts/AntiDeuteron/fDCAxyAntiDeuteron", "fDCAxy AntiDeuteron;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/AntiDeuteron/fDCAzAntiDeuteron", "fDCAz AntiDeuteron;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/AntiDeuteron/fTPCsClsAntiDeuteron", "fTPCsCls AntiDeuteron;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/AntiDeuteron/fTPCcRowsAntiDeuteron", "fTPCcRows AntiDeuteron;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/AntiDeuteron/fTrkTPCfClsAntiDeuteron", "fTrkTPCfCls AntiDeuteron;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - registry.add("TrackCuts/AntiDeuteron/fTPCnclsAntiDeuteron", "fTPCncls AntiDeuteron;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // lambda before selections - registry.add("TrackCuts/V0Before/fInvMassLambdavsAntiLambda", "Invariant mass of Lambda vs AntiLambda;M_{#pi p};Entries", HistType::kTH2F, {{500, 1.03, 1.5}, {500, 1.03, 1.5}}); - registry.add("TrackCuts/V0Before/fPtLambdaBefore", "Transverse momentum of all processed V0s before cuts;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/V0Before/fInvMassLambdaBefore", "Invariant mass of all processed V0s (Lambda) before cuts;M_{#pi p};Entries", HistType::kTH1F, {{500, 1.03, 1.5}}); - registry.add("TrackCuts/V0Before/fInvMassAntiLambdaBefore", "Invariant mass of all processed V0s (antiLambda) before cuts;M_{#pi p};Entries", HistType::kTH1F, {{500, 1.03, 1.5}}); - registry.add("TrackCuts/V0Before/fInvMassV0BeforeKaonvsV0Before", "Invariant mass of rejected K0 vs V0s (V0Before);M_{#pi p};;M_{#pi #pi}", HistType::kTH2F, {{500, 1.03, 1.5}, {500, 0.3, 0.6}}); - registry.add("TrackCuts/V0Before/fV0DCADaugh", "V0DCADaugh;DCA_{daugh};Entries", HistType::kTH1F, {{500, -4, 4}}); - registry.add("TrackCuts/V0Before/fV0CPA", "V0 CPA;CPA;Entries", HistType::kTH1F, {{500, 0.7, 1}}); - registry.add("TrackCuts/V0Before/fV0TranRad", "V0 TranRad;TranRad;Entries", HistType::kTH1F, {{500, 0, 150}}); - registry.add("TrackCuts/V0Before/f0DecVtxX", "V0 DecVtxX;DecVtX;Entries", HistType::kTH1F, {{500, 0, 150}}); - registry.add("TrackCuts/V0Before/f0DecVtxY", "V0 DecVtxY;DecVtY;Entries", HistType::kTH1F, {{500, 0, 150}}); - registry.add("TrackCuts/V0Before/f0DecVtxZ", "V0 DecVtxZ;DecVtz;Entries", HistType::kTH1F, {{500, 0, 150}}); - - registry.add("TrackCuts/V0Before/PosDaughter/Eta", "V0Before Pos Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/V0Before/PosDaughter/DCAXY", "V0Before Pos Daugh DCAXY;DCA_{XY};Entries", HistType::kTH1F, {{500, -2.5f, 2.5f}}); - registry.add("TrackCuts/V0Before/PosDaughter/fTPCncls", "V0Before Pos Daugh TPCncls;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/V0Before/NegDaughter/Eta", "V0Before Neg Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/V0Before/NegDaughter/DCAXY", "V0Before Neg Daugh DCAXY;DCA_{XY};Entries", HistType::kTH1F, {{500, -2.5f, 2.5f}}); - registry.add("TrackCuts/V0Before/NegDaughter/fTPCncls", "V0Before Neg Daugh TPCncls;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/V0Before/PosDaughter/fNsigmaTPCvsPProtonV0Daugh", "NSigmaTPC Proton V0Daught;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/V0Before/NegDaughter/fNsigmaTPCvsPPionMinusV0Daugh", "NSigmaTPC AntiPion V0Daught;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/V0Before/NegDaughter/fNsigmaTPCvsPAntiProtonV0Daugh", "NSigmaTPC Proton V0Daught;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/V0Before/PosDaughter/fNsigmaTPCvsPPionPlusV0Daugh", "NSigmaTPC AntiPion V0Daught;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - // lambda - registry.add("TrackCuts/Lambda/fPtLambda", "Transverse momentum V0s;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Lambda/fInvMassLambda", "Invariant mass V0s (Lambda);M_{#pi p};Entries", HistType::kTH1F, {{500, 1.03, 1.5}}); - registry.add("TrackCuts/Lambda/fInvMassLambdaKaonvsLambda", "Invariant mass of rejected K0 vs V0s (Lambda);M_{#pi p};M_{#pi #pi}", HistType::kTH2F, {{500, 1.03, 1.5}, {500, 0.3, 0.6}}); - registry.add("TrackCuts/Lambda/fV0DCADaugh", "V0DCADaugh;DCA_{daugh};Entries", HistType::kTH1F, {{500, -4, 4}}); - registry.add("TrackCuts/Lambda/fV0CPA", "V0 CPA;CPA;Entries", HistType::kTH1F, {{500, 0.7, 1}}); - registry.add("TrackCuts/Lambda/fV0TranRad", "V0 TranRad;TranRad;Entries", HistType::kTH1F, {{500, 0, 150}}); - registry.add("TrackCuts/Lambda/f0DecVtxX", "V0 DecVtxX;DecVtX;Entries", HistType::kTH1F, {{500, 0, 150}}); - registry.add("TrackCuts/Lambda/f0DecVtxY", "V0 DecVtxY;DecVtY;Entries", HistType::kTH1F, {{500, 0, 150}}); - registry.add("TrackCuts/Lambda/f0DecVtxZ", "V0 DecVtxZ;DecVtZ;Entries", HistType::kTH1F, {{500, 0, 150}}); - - // Lambda daughter - registry.add("TrackCuts/Lambda/PosDaughter/Eta", "Lambda Pos Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Lambda/PosDaughter/DCAXY", "Lambda Pos Daugh DCAXY;DCA_{XY};Entries", HistType::kTH1F, {{500, -2.5f, 2.5f}}); - registry.add("TrackCuts/Lambda/PosDaughter/fTPCncls", "Lambda Pos Daugh TPCncls;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Lambda/NegDaughter/Eta", "Lambda Neg Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Lambda/NegDaughter/DCAXY", "Lambda Neg Daugh DCAXY;DCA_{XY};Entries", HistType::kTH1F, {{500, -2.5f, 2.5f}}); - registry.add("TrackCuts/Lambda/NegDaughter/fTPCncls", "Lambda Neg Daugh TPCncls;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Lambda/PosDaughter/fNsigmaTPCvsPProtonV0Daugh", "NSigmaTPC Proton V0Daught;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Lambda/NegDaughter/fNsigmaTPCvsPPionMinusV0Daugh", "NSigmaTPC AntiPion V0Daught;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - // antilambda - registry.add("TrackCuts/AntiLambda/fPtAntiLambda", "Transverse momentum V0s;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/AntiLambda/fInvMassAntiLambda", "Invariant mass V0s (Lambda);M_{#pi p};Entries", HistType::kTH1F, {{500, 1.03, 1.5}}); - registry.add("TrackCuts/AntiLambda/fInvMassAntiLambdaKaonvsAntiLambda", "Invariant mass of rejected K0 vs V0s (Lambda);M_{#pi p};M_{#pi #pi}", HistType::kTH2F, {{500, 1.03, 1.5}, {500, 0.3, 0.6}}); - registry.add("TrackCuts/AntiLambda/fV0DCADaugh", "V0DCADaugh;DCA_{daugh};Entries", HistType::kTH1F, {{500, -4, 4}}); - registry.add("TrackCuts/AntiLambda/fV0CPA", "V0 CPA;CPA;Entries", HistType::kTH1F, {{500, 0.7, 1}}); - registry.add("TrackCuts/AntiLambda/fV0TranRad", "V0 TranRad;TranRad;Entries", HistType::kTH1F, {{500, 0, 150}}); - registry.add("TrackCuts/AntiLambda/f0DecVtxX", "V0 DecVtxX;DecVtX;Entries", HistType::kTH1F, {{500, 0, 150}}); - registry.add("TrackCuts/AntiLambda/f0DecVtxY", "V0 DecVtxY;DecVtY;Entries", HistType::kTH1F, {{500, 0, 150}}); - registry.add("TrackCuts/AntiLambda/f0DecVtxZ", "V0 DecVtxZ;DecVtZ;Entries", HistType::kTH1F, {{500, 0, 150}}); - - // AntiLambda daughter - registry.add("TrackCuts/AntiLambda/PosDaughter/Eta", "AntiLambda Pos Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/AntiLambda/PosDaughter/DCAXY", "AntiLambda Pos Daugh DCAXY;DCA_{XY};Entries", HistType::kTH1F, {{500, -2.5f, 2.5f}}); - registry.add("TrackCuts/AntiLambda/PosDaughter/fTPCncls", "AntiLambda Pos Daugh TPCncls;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/AntiLambda/NegDaughter/Eta", "AntiLambda Neg Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/AntiLambda/NegDaughter/DCAXY", "AntiLambda Neg Daugh DCAXY;DCA_{XY};Entries", HistType::kTH1F, {{500, -2.5f, 2.5f}}); - registry.add("TrackCuts/AntiLambda/NegDaughter/fTPCncls", "AntiLambda Neg Daugh TPCncls;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/AntiLambda/NegDaughter/fNsigmaTPCvsPAntiProtonAntiV0Daugh", "NSigmaTPC AntiProton antiV0Daught;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiLambda/PosDaughter/fNsigmaTPCvsPPionPlusAntiV0Daugh", "NSigmaTPC Pion antiV0Daught;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - // Phi - - registry.add("TrackCuts/Phi/Before/fInvMass", "Invariant mass V0s;M_{KK};Entries", HistType::kTH1F, {{7000, 0.8, 1.5}}); - registry.add("TrackCuts/Phi/Before/fPt", "Transverse momentum V0s;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Phi/Before/fEta", "Pseudorapidity of V0;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Phi/Before/fPhi", "Azimuthal angle of V0;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - - registry.add("TrackCuts/Phi/Before/PosDaughter/fP", "Momentum of Kaons at PV;p (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fPTPC", "Momentum of Kaons at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fPt", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fMomCorDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fMomCorRatio", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fEta", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fPhi", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fNsigmaTPCvsP", "NSigmaTPC Kaon;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fNsigmaTOFvsP", "NSigmaTOF Kaon;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fNsigmaTPCTOFvsP", "NSigmaTPCTOF Kaon;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fDCAxy", "fDCAxy Kaon;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fDCAz", "fDCAz Kaon;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fTPCsCls", "fTPCsCls Kaon;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fTPCcRows", "fTPCcRows Kaon;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fTrkTPCfCls", "fTrkTPCfCls Kaon;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - registry.add("TrackCuts/Phi/Before/PosDaughter/fTPCncls", "fTPCncls Kaon;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - registry.add("TrackCuts/Phi/Before/NegDaughter/fP", "Momentum of Kaons at PV;p (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fPTPC", "Momentum of Kaons at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fPt", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fMomCorDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fMomCorRatio", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fEta", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fPhi", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fNsigmaTPCvsP", "NSigmaTPC Kaon;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fNsigmaTOFvsP", "NSigmaTOF Kaon;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fNsigmaTPCTOFvsP", "NSigmaTPCTOF Kaon;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fDCAxy", "fDCAxy Kaon;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fDCAz", "fDCAz Kaon;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fTPCsCls", "fTPCsCls Kaon;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fTPCcRows", "fTPCcRows Kaon;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fTrkTPCfCls", "fTrkTPCfCls Kaon;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - registry.add("TrackCuts/Phi/Before/NegDaughter/fTPCncls", "fTPCncls Kaon;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - registry.add("TrackCuts/Phi/After/fInvMass", "Invariant mass V0s;M_{KK};Entries", HistType::kTH1F, {{7000, 0.8, 1.5}}); - registry.add("TrackCuts/Phi/After/fPt", "Transverse momentum V0s;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Phi/After/fEta", "Pseudorapidity of V0;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Phi/After/fPhi", "Azimuthal angle of V0;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - - // phi daughter - registry.add("TrackCuts/Phi/After/PosDaughter/fPt", "Transverse momentum Pos Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Phi/After/PosDaughter/fEta", "Phi Pos Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Phi/After/PosDaughter/fPhi", "Azimuthal angle of Pos Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - - registry.add("TrackCuts/Phi/After/NegDaughter/fPt", "Transverse momentum Neg Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Phi/After/NegDaughter/fEta", "Phi Neg Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Phi/After/NegDaughter/fPhi", "Azimuthal angle of Neg Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - - // pions - registry.add("TrackCuts/Pion/fPPion", "Momentum of Pions at PV;p (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Pion/fPTPCPion", "Momentum of Pions at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Pion/fPtPion", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Pion/fMomCorPionDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - registry.add("TrackCuts/Pion/fMomCorPionRatio", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - registry.add("TrackCuts/Pion/fEtaPion", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Pion/fPhiPion", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - registry.add("TrackCuts/Pion/fNsigmaTPCvsPPion", "NSigmaTPC Pion;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Pion/fNsigmaTOFvsPPion", "NSigmaTOF Pion;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Pion/fNsigmaTPCTOFvsPPion", "NSigmaTPCTOF Pion;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - registry.add("TrackCuts/Pion/fNsigmaTPCvsPPionP", "NSigmaTPC Pion P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Pion/fNsigmaTOFvsPPionP", "NSigmaTOF Pion P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/Pion/fNsigmaTPCTOFvsPPionP", "NSigmaTPCTOF Pion P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - registry.add("TrackCuts/Pion/fDCAxyPion", "fDCAxy Pion;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/Pion/fDCAzPion", "fDCAz Pion;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/Pion/fTPCsClsPion", "fTPCsCls Pion;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Pion/fTPCcRowsPion", "fTPCcRows Pion;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/Pion/fTrkTPCfClsPion", "fTrkTPCfCls Pion;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - registry.add("TrackCuts/Pion/fTPCnclsPion", "fTPCncls Pion;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // anti-pions - registry.add("TrackCuts/AntiPion/fPtAntiPion", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/AntiPion/fMomCorAntiPionDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - registry.add("TrackCuts/AntiPion/fMomCorAntiPionRatio", "Momentum correlation;p_{reco} (GeV/c); |p_{TPC} - p_{reco}| (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - registry.add("TrackCuts/AntiPion/fEtaAntiPion", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/AntiPion/fPhiAntiPion", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - registry.add("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPion", "NSigmaTPC AntiPion;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPion", "NSigmaTOF AntiPion;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPion", "NSigmaTPCTOF AntiPion;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - registry.add("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPionP", "NSigmaTPC AntiPion P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPionP", "NSigmaTOF AntiPion P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - registry.add("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPionP", "NSigmaTPCTOF AntiPion P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - registry.add("TrackCuts/AntiPion/fDCAxyAntiPion", "fDCAxy AntiPion;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/AntiPion/fDCAzAntiPion", "fDCAz AntiPion;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - registry.add("TrackCuts/AntiPion/fTPCsClsAntiPion", "fTPCsCls AntiPion;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/AntiPion/fTPCcRowsAntiPion", "fTPCcRows AntiPion;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - registry.add("TrackCuts/AntiPion/fTrkTPCfClsAntiPion", "fTrkTPCfCls AntiPion;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - registry.add("TrackCuts/AntiPion/fTPCnclsAntiPion", "fTPCncls AntiPion;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // rho QA - // daughter pos before - registry.add("TrackCuts/Rho/Before/PosDaughter/fInvMass", "Invariant mass Rho Pos Daugh;M_{#pi};Entries", HistType::kTH1F, {{500, 0, 1}}); - registry.add("TrackCuts/Rho/Before/PosDaughter/fPt", "Transverse momentum Rho Pos Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Rho/Before/PosDaughter/fEta", "Rho Pos Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Rho/Before/PosDaughter/fPhi", "Azimuthal angle of Rho Pos Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // daughter neg before - registry.add("TrackCuts/Rho/Before/NegDaughter/fInvMass", "Invariant mass Rho Neg Daugh;M_{#pi};Entries", HistType::kTH1F, {{500, 0, 1}}); - registry.add("TrackCuts/Rho/Before/NegDaughter/fPt", "Transverse momentum Rho Neg Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Rho/Before/NegDaughter/fEta", "Rho Neg Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Rho/Before/NegDaughter/fPhi", "Azimuthal angle of Rho Neg Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // rhoCand before - registry.add("TrackCuts/Rho/Before/fInvMass", "Invariant mass RhoCand;M_{#pi#pi};Entries", HistType::kTH1F, {{5000, 0, 5}}); - registry.add("TrackCuts/Rho/Before/fPt", "Transverse momentum RhoCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Rho/Before/fEta", "Pseudorapidity of RhoCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Rho/Before/fPhi", "Azimuthal angle of RhoCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // daughter pos after - registry.add("TrackCuts/Rho/After/PosDaughter/fPt", "Transverse momentum RhoCand Pos Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Rho/After/PosDaughter/fEta", "RhoCand Pos Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Rho/After/PosDaughter/fPhi", "Azimuthal angle of RhoCand Pos Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // daughter neg after - registry.add("TrackCuts/Rho/After/NegDaughter/fPt", "Transverse momentum RhoCand Neg Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Rho/After/NegDaughter/fEta", "RhoCand Neg Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Rho/After/NegDaughter/fPhi", "Azimuthal angle of RhoCand Neg Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // rhoCand after - registry.add("TrackCuts/Rho/After/fInvMass", "Invariant mass RhoCand;M_{#pi#pi};Entries", HistType::kTH1F, {{5000, 0, 5}}); - registry.add("TrackCuts/Rho/After/fPt", "Transverse momentum RhoCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - registry.add("TrackCuts/Rho/After/fEta", "Pseudorapidity of RhoCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - registry.add("TrackCuts/Rho/After/fPhi", "Azimuthal angle of RhoCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); + registry.add("TrackQA/After/AntiProton/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/AntiProton/fPTpc", "Momentum at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/AntiProton/fMomCor", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {Binning.momentum, Binning.momCor}}); + registry.add("TrackQA/After/AntiProton/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("TrackQA/After/AntiProton/fPhi", "Azimuthal angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + registry.add("TrackQA/After/AntiProton/fNsigmaIts", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiProton/fNsigmaTpc", "NSigmaTPC;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiProton/fNsigmaTof", "NSigmaTOF;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiProton/fNsigmaTpcTof", "NSigmaTPCTOF;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/After/AntiProton/fItsSignal", "ITS Signal;p (GeV/c); (cm)", {HistType::kTH2F, {Binning.momentum, Binning.itsSignal}}); + registry.add("TrackQA/After/AntiProton/fTpcSignal", "TPC Signal;p (GeV/c);TPC Signal", {HistType::kTH2F, {Binning.momentum, Binning.tpcSignal}}); + registry.add("TrackQA/After/AntiProton/fTofBeta", "TOF #beta;p (GeV/c);#beta_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.tofSignal}}); + + registry.add("TrackQA/After/AntiProton/fDcaXy", "DCA_{xy};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("TrackQA/After/AntiProton/fDcaZ", "DCA_{z};p_{T} (GeV/c); DCA_{Z};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + + registry.add("TrackQA/After/AntiProton/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiProton/fTpcCrossedRows", "TPC Crossed Rows;TPC Crossed Rows;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiProton/fTpcSharedClusters", "TPC Shared Clusters;TPC Shared Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiProton/fTpcSharedClusterOverClusterss", "TPC Shared Clusters/Clusters;TPC Shared Clusters/Clusters;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/AntiProton/fTpcFindableOverRows", "TPC Findabled/Crossed Rows;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/AntiProton/fTpcChi2OverCluster", "TPC #chi^{2}/Cluster;TPC #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.tpcChi2}); + + registry.add("TrackQA/After/AntiProton/fItsClusters", "ITS Clusters;ITS Clusters;Entries", HistType::kTH1F, {Binning.itsCluster}); + registry.add("TrackQA/After/AntiProton/fItsIbClusters", "ITS Inner Barrel Clusters;ITS Inner Barrel Clusters;Entries", HistType::kTH1F, {Binning.itsIbCluster}); + registry.add("TrackQA/After/AntiProton/fItsChi2OverCluster", "ITS #chi^{2}/Cluster;ITS #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.itsChi2}); + + // Deuteron + registry.add("TrackQA/After/Deuteron/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/Deuteron/fPTpc", "Momentum at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/Deuteron/fMomCor", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {Binning.momentum, Binning.momCor}}); + registry.add("TrackQA/After/Deuteron/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("TrackQA/After/Deuteron/fPhi", "Azimuthal angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + registry.add("TrackQA/After/Deuteron/fNsigmaIts", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Deuteron/fNsigmaTpc", "NSigmaTPC;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Deuteron/fNsigmaTof", "NSigmaTOF;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/Deuteron/fNsigmaTpcTof", "NSigmaTPCTOF;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigmaComb}}); + + registry.add("TrackQA/After/Deuteron/fItsSignal", "ITS Signal;p (GeV/c); (cm)", {HistType::kTH2F, {Binning.momentum, Binning.itsSignal}}); + registry.add("TrackQA/After/Deuteron/fTpcSignal", "TPC Signal;p (GeV/c);TPC Signal", {HistType::kTH2F, {Binning.momentum, Binning.tpcSignal}}); + registry.add("TrackQA/After/Deuteron/fTofBeta", "TOF #beta;p (GeV/c);#beta_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.tofSignal}}); + + registry.add("TrackQA/After/Deuteron/fDcaXy", "DCA_{xy};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("TrackQA/After/Deuteron/fDcaZ", "DCA_{z};p_{T} (GeV/c); DCA_{Z};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + + registry.add("TrackQA/After/Deuteron/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Deuteron/fTpcCrossedRows", "TPC Crossed Rows;TPC Crossed Rows;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Deuteron/fTpcSharedClusters", "TPC Shared Clusters;TPC Shared Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/Deuteron/fTpcSharedClusterOverClusterss", "TPC Shared Clusters/Clusters;TPC Shared Clusters/Clusters;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/Deuteron/fTpcFindableOverRows", "TPC Findabled/Crossed Rows;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/Deuteron/fTpcChi2OverCluster", "TPC #chi^{2}/Cluster;TPC #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.tpcChi2}); + + registry.add("TrackQA/After/Deuteron/fItsClusters", "ITS Clusters;ITS Clusters;Entries", HistType::kTH1F, {Binning.itsCluster}); + registry.add("TrackQA/After/Deuteron/fItsIbClusters", "ITS Inner Barrel Clusters;ITS Inner Barrel Clusters;Entries", HistType::kTH1F, {Binning.itsIbCluster}); + registry.add("TrackQA/After/Deuteron/fItsChi2OverCluster", "ITS #chi^{2}/Cluster;ITS #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.itsChi2}); + + // AntiDeuteron + registry.add("TrackQA/After/AntiDeuteron/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/AntiDeuteron/fPTpc", "Momentum at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("TrackQA/After/AntiDeuteron/fMomCor", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {Binning.momentum, Binning.momCor}}); + registry.add("TrackQA/After/AntiDeuteron/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("TrackQA/After/AntiDeuteron/fPhi", "Azimuthal angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + registry.add("TrackQA/After/AntiDeuteron/fNsigmaIts", "NSigmaITS;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiDeuteron/fNsigmaTpc", "NSigmaTPC;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiDeuteron/fNsigmaTof", "NSigmaTOF;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("TrackQA/After/AntiDeuteron/fNsigmaTpcTof", "NSigmaTPCTOF;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + + registry.add("TrackQA/After/AntiDeuteron/fItsSignal", "ITS Signal;p (GeV/c); (cm)", {HistType::kTH2F, {Binning.momentum, Binning.itsSignal}}); + registry.add("TrackQA/After/AntiDeuteron/fTpcSignal", "TPC Signal;p (GeV/c);TPC Signal", {HistType::kTH2F, {Binning.momentum, Binning.tpcSignal}}); + registry.add("TrackQA/After/AntiDeuteron/fTofBeta", "TOF #beta;p (GeV/c);#beta_{TOF}", {HistType::kTH2F, {Binning.momentum, Binning.tofSignal}}); + + registry.add("TrackQA/After/AntiDeuteron/fDcaXy", "DCA_{xy};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("TrackQA/After/AntiDeuteron/fDcaZ", "DCA_{z};p_{T} (GeV/c); DCA_{Z};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + + registry.add("TrackQA/After/AntiDeuteron/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiDeuteron/fTpcCrossedRows", "TPC Crossed Rows;TPC Crossed Rows;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiDeuteron/fTpcSharedClusters", "TPC Shared Clusters;TPC Shared Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("TrackQA/After/AntiDeuteron/fTpcSharedClusterOverClusterss", "TPC Shared Clusters/Clusters;TPC Shared Clusters/Clusters;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/AntiDeuteron/fTpcFindableOverRows", "TPC Findabled/Crossed Rows;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {Binning.ratio}); + registry.add("TrackQA/After/AntiDeuteron/fTpcChi2OverCluster", "TPC #chi^{2}/Cluster;TPC #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.tpcChi2}); + + registry.add("TrackQA/After/AntiDeuteron/fItsClusters", "ITS Clusters;ITS Clusters;Entries", HistType::kTH1F, {Binning.itsCluster}); + registry.add("TrackQA/After/AntiDeuteron/fItsIbClusters", "ITS Inner Barrel Clusters;ITS Inner Barrel Clusters;Entries", HistType::kTH1F, {Binning.itsIbCluster}); + registry.add("TrackQA/After/AntiDeuteron/fItsChi2OverCluster", "ITS #chi^{2}/Cluster;ITS #chi^{2}/Cluster;Entries", HistType::kTH1F, {Binning.itsChi2}); + + // Lambda before + registry.add("LambdaQA/Before/fPt", "Transverse momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("LambdaQA/Before/fEta", "Psedurapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("LambdaQA/Before/fPhi", "Azimuthal Angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("LambdaQA/Before/fInvMassLambda", "Invariant mass Lambda;M_{#pi p};Entries", HistType::kTH1F, {Binning.invMassLambda}); + registry.add("LambdaQA/Before/fInvMassAntiLambda", "Invariant mass AntiLambda;M_{#pi p};Entries", HistType::kTH1F, {Binning.invMassLambda}); + registry.add("LambdaQA/Before/fInvMassLambdaVsAntiLambda", "Invariant mass of Lambda vs AntiLambda;M_{#pi p};Entries", HistType::kTH2F, {Binning.invMassLambda, Binning.invMassLambda}); + registry.add("LambdaQA/Before/fInvMassLambdaVsKaon", "Invariant mass of Lambda vs K0;M_{#pi p};;M_{#pi #pi}", HistType::kTH2F, {Binning.invMassLambda, Binning.invMassK0short}); + registry.add("LambdaQA/Before/fInvMassAntiLambdaVsKaon", "Invariant mass of AntiLambda vs K0;M_{#pi p};;M_{#pi #pi}", HistType::kTH2F, {Binning.invMassLambda, Binning.invMassK0short}); + registry.add("LambdaQA/Before/fDcaDaugh", "DCA_{Daugh};DCA_{daugh};Entries", HistType::kTH1F, {Binning.dcaDaugh}); + registry.add("LambdaQA/Before/fCpa", "Cosine of pointing angle;CPA;Entries", HistType::kTH1F, {Binning.cpa}); + registry.add("LambdaQA/Before/fTranRad", "Transverse Radisu;TranRad;Entries", HistType::kTH1F, {Binning.transRad}); + registry.add("LambdaQA/Before/fDecVtx", "Decay vertex displacement;DecVtx;Entries", HistType::kTH1F, {Binning.decayVtx}); + registry.add("LambdaQA/Before/PosDaughter/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("LambdaQA/Before/PosDaughter/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("LambdaQA/Before/PosDaughter/fPhi", "Azimuthal Angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("LambdaQA/Before/PosDaughter/fDcaXy", "DCA_{XY};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("LambdaQA/Before/PosDaughter/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("LambdaQA/Before/PosDaughter/fNsigmaTpcProton", "NSigmaTPC Proton;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("LambdaQA/Before/PosDaughter/fNsigmaTpcPion", "NSigmaTPC Pion;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("LambdaQA/Before/NegDaughter/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("LambdaQA/Before/NegDaughter/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("LambdaQA/Before/NegDaughter/fPhi", "Azimuthal Angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("LambdaQA/Before/NegDaughter/fDcaXy", "DCA_{XY};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("LambdaQA/Before/NegDaughter/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("LambdaQA/Before/NegDaughter/fNsigmaTpcProton", "NSigmaTPC AnitProton;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("LambdaQA/Before/NegDaughter/fNsigmaTpcPion", "NSigmaTPC AntiPion;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + + // Lambda after + registry.add("LambdaQA/After/Lambda/fPt", "Transverse momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("LambdaQA/After/Lambda/fEta", "Psedurapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("LambdaQA/After/Lambda/fPhi", "Azimuthal Angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("LambdaQA/After/Lambda/fInvMass", "Invariant mass;M_{#pi p};Entries", HistType::kTH1F, {Binning.invMassLambda}); + registry.add("LambdaQA/After/Lambda/fInvMassLambdaVsAntiLambda", "Invariant mass of Lambda vs AntiLambda;M_{#pi p};Entries", HistType::kTH2F, {Binning.invMassLambda, Binning.invMassLambda}); + registry.add("LambdaQA/After/Lambda/fInvMassLambdaVsKaon", "Invariant mass of rejected K0 vs V0s;M_{#pi p};;M_{#pi #pi}", HistType::kTH2F, {Binning.invMassLambda, Binning.invMassK0short}); + registry.add("LambdaQA/After/Lambda/fDcaDaugh", "DCA_{Daugh};DCA_{daugh};Entries", HistType::kTH1F, {Binning.dcaDaugh}); + registry.add("LambdaQA/After/Lambda/fCpa", "Cosine of pointing angle;CPA;Entries", HistType::kTH1F, {Binning.cpa}); + registry.add("LambdaQA/After/Lambda/fTranRad", "Transverse Radisu;TranRad;Entries", HistType::kTH1F, {Binning.transRad}); + registry.add("LambdaQA/After/Lambda/fDecVtx", "Decay vertex displacement;DecVtx;Entries", HistType::kTH1F, {Binning.decayVtx}); + registry.add("LambdaQA/After/Lambda/PosDaughter/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("LambdaQA/After/Lambda/PosDaughter/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("LambdaQA/After/Lambda/PosDaughter/fPhi", "Azimuthal Angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("LambdaQA/After/Lambda/PosDaughter/fDcaXy", "DCA_{XY};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("LambdaQA/After/Lambda/PosDaughter/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("LambdaQA/After/Lambda/PosDaughter/fNsigmaTpc", "NSigmaTPC Proton;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("LambdaQA/After/Lambda/NegDaughter/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("LambdaQA/After/Lambda/NegDaughter/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("LambdaQA/After/Lambda/NegDaughter/fPhi", "Azimuthal Angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("LambdaQA/After/Lambda/NegDaughter/fDcaXy", "DCA_{XY};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("LambdaQA/After/Lambda/NegDaughter/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("LambdaQA/After/Lambda/NegDaughter/fNsigmaTpc", "NSigmaTPC AntiPion;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + + // AntiLambda after + registry.add("LambdaQA/After/AntiLambda/fPt", "Transverse momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("LambdaQA/After/AntiLambda/fEta", "Psedurapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("LambdaQA/After/AntiLambda/fPhi", "Azimuthal Angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("LambdaQA/After/AntiLambda/fInvMass", "Invariant mass;M_{#pi p};Entries", HistType::kTH1F, {Binning.invMassLambda}); + registry.add("LambdaQA/After/AntiLambda/fInvMassAntiLambdaVsLambda", "Invariant mass of Lambda vs AntiLambda;M_{#pi p};Entries", HistType::kTH2F, {Binning.invMassLambda, Binning.invMassLambda}); + registry.add("LambdaQA/After/AntiLambda/fInvMassAntiLambdaVsKaon", "Invariant mass of rejected K0 vs V0s;M_{#pi p};;M_{#pi #pi}", HistType::kTH2F, {Binning.invMassLambda, Binning.invMassK0short}); + registry.add("LambdaQA/After/AntiLambda/fDcaDaugh", "DCA_{Daugh};DCA_{daugh};Entries", HistType::kTH1F, {Binning.dcaDaugh}); + registry.add("LambdaQA/After/AntiLambda/fCpa", "Cosine of pointing angle;CPA;Entries", HistType::kTH1F, {Binning.cpa}); + registry.add("LambdaQA/After/AntiLambda/fTranRad", "Transverse Radisu;TranRad;Entries", HistType::kTH1F, {Binning.transRad}); + registry.add("LambdaQA/After/AntiLambda/fDecVtx", "Decay vertex displacement;DecVtx;Entries", HistType::kTH1F, {Binning.decayVtx}); + registry.add("LambdaQA/After/AntiLambda/PosDaughter/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("LambdaQA/After/AntiLambda/PosDaughter/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("LambdaQA/After/AntiLambda/PosDaughter/fPhi", "Azimuthal Angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("LambdaQA/After/AntiLambda/PosDaughter/fDcaXy", "DCA_{XY};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("LambdaQA/After/AntiLambda/PosDaughter/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("LambdaQA/After/AntiLambda/PosDaughter/fNsigmaTpc", "NSigmaTPC Proton;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + registry.add("LambdaQA/After/AntiLambda/NegDaughter/fPt", "Transverse Momentum;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("LambdaQA/After/AntiLambda/NegDaughter/fEta", "Pseudorapidity;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("LambdaQA/After/AntiLambda/NegDaughter/fPhi", "Azimuthal Angle;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + registry.add("LambdaQA/After/AntiLambda/NegDaughter/fDcaXy", "DCA_{XY};p_{T} (GeV/c); DCA_{XY};Entries", HistType::kTH2F, {Binning.momentum, Binning.dca}); + registry.add("LambdaQA/After/AntiLambda/NegDaughter/fTpcClusters", "TPC Clusters;TPC Clusters;Entries", HistType::kTH1F, {Binning.tpcCluster}); + registry.add("LambdaQA/After/AntiLambda/NegDaughter/fNsigmaTpc", "NSigmaTPC AntiPion;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {Binning.momentum, Binning.nsigma}}); + + // Phi before + registry.add("PhiQA/Before/fInvMass", "Invariant mass #phi;M_{KK};Entries", HistType::kTH1F, {Binning.invMassPhi}); + registry.add("PhiQA/Before/fPt", "Transverse momentum #phi;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("PhiQA/Before/fEta", "Pseudorapidity of V0;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("PhiQA/Before/fPhi", "Azimuthal angle of #phi;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + // Phi after + registry.add("PhiQA/After/fInvMass", "Invariant mass #phi;M_{KK};Entries", HistType::kTH1F, {Binning.invMassPhi}); + registry.add("PhiQA/After/fPt", "Transverse momentum #phi;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("PhiQA/After/fEta", "Pseudorapidity of #phi;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("PhiQA/After/fPhi", "Azimuthal angle of #Phi;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + // Rho before + registry.add("RhoQA/Before/fInvMass", "Invariant mass #rho;M_{#pi#pi};Entries", HistType::kTH1F, {Binning.invMassRho}); + registry.add("RhoQA/Before/fPt", "Transverse momentum #rho;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("RhoQA/Before/fEta", "Pseudorapidity of #rho;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("RhoQA/Before/fPhi", "Azimuthal angle of #rho;#varphi;Entries", HistType::kTH1F, {Binning.phi}); + + // Rho after + registry.add("RhoQA/After/fInvMass", "Invariant mass #rho;M_{#pi#pi};Entries", HistType::kTH1F, {Binning.invMassRho}); + registry.add("RhoQA/After/fPt", "Transverse momentum #rho;p_{T} (GeV/c);Entries", HistType::kTH1F, {Binning.momentum}); + registry.add("RhoQA/After/fEta", "Pseudorapidity of #rho;#eta;Entries", HistType::kTH1F, {Binning.eta}); + registry.add("RhoQA/After/fPhi", "Azimuthal angle of #rho;#phi;Entries", HistType::kTH1F, {Binning.phi}); // for ppp - registry.add("ppp/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - registry.add("ppp/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - registry.add("ppp/fSE_particle", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppp/fSE_particle_downsample", "Same Event distribution (downsampled)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppp/fSE_antiparticle", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppp/fSE_antiparticle_downsample", "Same Event distribution (downsampled)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppp/fProtonPtVsQ3", "pT (proton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("ppp/fAntiProtonPtVsQ3", "pT (antiproton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); + registry.add("PPP/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("PPP/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + registry.add("PPP/fSE_particle", "Same Event distribution;Q_{3} (GeV/c);Entries", HistType::kTH1F, {Binning.q3}); + registry.add("PPP/fSE_antiparticle", "Same Event distribution;Q_{3} (GeV/c);Entries", HistType::kTH1F, {Binning.q3}); + registry.add("PPP/fProtonPtVsQ3", "Proton p_{T} vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); + registry.add("PPP/fAntiProtonPtVsQ3", "AntiProton p_{T} vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); // for ppl - registry.add("ppl/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - registry.add("ppl/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - registry.add("ppl/fSE_particle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppl/fSE_particle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppl/fSE_antiparticle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppl/fSE_antiparticle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppl/fProtonPtVsQ3", "pT (proton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("ppl/fAntiProtonPtVsQ3", "pT (proton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("ppl/fLambdaPtVsQ3", "pT (lambda) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("ppl/fAntiLambdaPtVsQ3", "pT (antilambda) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); + registry.add("PPL/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("PPL/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + registry.add("PPL/fSE_particle", "Same Event distribution;Q_{3} (GeV/c);Entries", HistType::kTH1F, {Binning.q3}); + registry.add("PPL/fSE_antiparticle", "Same Event distribution;Q_{3} (GeV/c);Entries", HistType::kTH1F, {Binning.q3}); + registry.add("PPL/fProtonPtVsQ3", "Proton p_{T} vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); + registry.add("PPL/fAntiProtonPtVsQ3", "AntiProton p_{T} vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); + registry.add("PPL/fLambdaPtVsQ3", "Lambda p_{T} vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); + registry.add("PPL/fAntiLambdaPtVsQ3", "AntiLambda p_{T} vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); // for pll - registry.add("pll/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - registry.add("pll/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - registry.add("pll/fSE_particle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("pll/fSE_particle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("pll/fSE_antiparticle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("pll/fSE_antiparticle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("pll/fProtonPtVsQ3", "Q3 vs pT (proton)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("pll/fAntiProtonPtVsQ3", "Q3 vs pT (antiproton)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("pll/fLambdaPtVsQ3", "Q3 vs pT (lambda)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("pll/fAntiLambdaPtVsQ3", "Q3 vs pT (antilambda)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); + registry.add("PLL/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("PLL/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + registry.add("PLL/fSE_particle", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {Binning.q3}); + registry.add("PLL/fSE_antiparticle", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {Binning.q3}); + registry.add("PLL/fProtonPtVsQ3", "Proton p_{T}Q3 vs pT", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); + registry.add("PLL/fAntiProtonPtVsQ3", "AntiProton p_{T} vs Q3", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); + registry.add("PLL/fLambdaPtVsQ3", "Lambda p_{T} vs Q3", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); + registry.add("PLL/fAntiLambdaPtVsQ3", "AntiLambda p_{T} vs Q3", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); // for lll - registry.add("lll/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - registry.add("lll/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - registry.add("lll/fSE_particle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("lll/fSE_particle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("lll/fSE_antiparticle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("lll/fSE_antiparticle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("lll/fLambdaPtVsQ3", "Q3 vs pT (lambda)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("lll/fAntiLambdaPtVsQ3", "Q3 vs pT (antilambda)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); + registry.add("LLL/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("LLL/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + registry.add("LLL/fSE_particle", "Same Event distribution;Q_{3} (GeV/c);Entries", HistType::kTH1F, {Binning.q3}); + registry.add("LLL/fSE_antiparticle", "Same Event distribution;Q_{3} (GeV/c);Entries", HistType::kTH1F, {Binning.q3}); + registry.add("LLL/fLambdaPtVsQ3", "Lambda p_{T} vs Q3", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); + registry.add("LLL/fAntiLambdaPtVsQ3", "AntiLambda p_{T} vs Q3", {HistType::kTH2F, {Binning.momentum, Binning.q3}}); // for ppPhi - registry.add("ppphi/fMultiplicity", "Multiplicity of all triggered events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - registry.add("ppphi/fZvtx", "Zvtx of all triggered events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - registry.add("ppphi/fSE_particle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppphi/fSE_particle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppphi/fSE_antiparticle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppphi/fSE_antiparticle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppphi/fProtonPtVsQ3", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppphi/fPhiPtVsQ3", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppphi/fAntiProtonPtVsQ3", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppphi/fAntiPhiPtVsQ3", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); + registry.add("PPPhi/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("PPPhi/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + registry.add("PPPhi/fSE_particle", "Same Event distribution;Q_{3} (GeV/c);Entries", HistType::kTH1F, {Binning.q3}); + registry.add("PPPhi/fSE_antiparticle", "Same Event distribution;Q_{3} (GeV/c);Entries", HistType::kTH1F, {Binning.q3}); + registry.add("PPPhi/fProtonPtVsQ3", "Proton p_{T} vs Q_{3}", HistType::kTH2F, {Binning.momentum, Binning.q3}); + registry.add("PPPhi/fAntiProtonPtVsQ3", "AntiLambda p_{T} vs Q3", HistType::kTH2F, {Binning.momentum, Binning.q3}); + registry.add("PPPhi/fPhiPtVsQ3", "#phi p_{T} vs Q_{3};p_{T} (GeV/c); Q_{3} (GeV/c)", HistType::kTH2F, {Binning.momentum, Binning.q3}); + registry.add("PPPhi/fPhiInvMassVsQ3", "#phi mass vs Q_{3};M_{K^{+}K^{-}} (GeV/c^{2});Q_{3} (GeV/c)", HistType::kTH2F, {Binning.invMassPhi, Binning.q3}); // for ppRho - registry.add("ppRho/fMultiplicity", "Multiplicity of all triggered events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - registry.add("ppRho/fZvtx", "Zvtx of all triggered events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - registry.add("ppRho/fSE_particle", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppRho/fSE_particle_downsample", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppRho/fSE_antiparticle", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppRho/fSE_antiparticle_downsample", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppRho/fProtonPtVsQ3", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppRho/fAntiProtonPtVsQ3", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ppRho/fRhoCandPtVsQ3", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {{8000, 0, 8}}); + registry.add("PPRho/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("PPRho/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + registry.add("PPRho/fSE_particle", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {Binning.q3}); + registry.add("PPRho/fSE_antiparticle", "Same Event distribution;Q_{3} (GeV/c);SE", HistType::kTH1F, {Binning.q3}); + registry.add("PPRho/fProtonPtVsQ3", "Proton p_{T} vs Q3", HistType::kTH2F, {Binning.momentum, Binning.q3}); + registry.add("PPRho/fAntiProtonPtVsQ3", "AntiProton p_{T} vs Q3", HistType::kTH2F, {Binning.momentum, Binning.q3}); + registry.add("PPRho/fRhoPtVsQ3", "#rho p_{T} vs Q3;Q_{3} (GeV/c);SE", HistType::kTH2F, {Binning.momentum, Binning.q3}); + registry.add("PPRho/fRhoInvMassVsQ3", "#rho mass vs Q_{3};M_{#pi^{+}#pi^{-}} (GeV/c^{2});Q_{3} (GeV/c)", HistType::kTH2F, {Binning.invMassRho, Binning.q3}); // for pd - registry.add("pd/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - registry.add("pd/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - registry.add("pd/fSE_particle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("pd/fSE_particle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("pd/fSE_antiparticle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("pd/fSE_antiparticle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("pd/fProtonPtVskstar", "pT (proton) vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("pd/fAntiProtonPtVskstar", "pT (antiproton) vs k^{*};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("pd/fDeuteronPtVskstar", "pT (deuteron) vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("pd/fAntiDeuteronPtVskstar", "pT (antideuteron) vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); + registry.add("PD/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("PD/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + registry.add("PD/fSE_particle", "Same Event distribution;k^{*} (GeV/c);Entries", HistType::kTH1F, {Binning.kstar}); + registry.add("PD/fSE_antiparticle", "Same Event distribution;k^{*} (GeV/c);Entries", HistType::kTH1F, {Binning.kstar}); + registry.add("PD/fProtonPtVskstar", "Proton p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("PD/fAntiProtonPtVskstar", "AntiProton p_{T} vs k^{*};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("PD/fDeuteronPtVskstar", "Deuteron p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("PD/fAntiDeuteronPtVskstar", "AntiDeuteron p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); // for ld - registry.add("ld/fMultiplicity", "Multiplicity of all processed events", HistType::kTH1F, {{500, 0, 500}}); - registry.add("ld/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - registry.add("ld/fSE_particle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ld/fSE_particle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ld/fSE_antiparticle", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ld/fSE_antiparticle_downsample", "Same Event distribution;SE;Q_{3} (GeV/c)", HistType::kTH1F, {{8000, 0, 8}}); - registry.add("ld/fDeuteronPtVskstar", "pT (deuteron) vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("ld/fAntiDeuteronPtVskstar", "pT (antideuteron) vs k^{*};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("ld/fLambdaPtVskstar", "pT (lambda) vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - registry.add("ld/fAntiLambdaPtVskstar", "pT (antilambda) vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); + registry.add("LD/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("LD/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + registry.add("LD/fSE_particle", "Same Event distribution;k^{*} (GeV/c);Entries", HistType::kTH1F, {Binning.kstar}); + registry.add("LD/fSE_antiparticle", "Same Event distribution;k^{*} (GeV/c);Entries", HistType::kTH1F, {Binning.kstar}); + registry.add("LD/fDeuteronPtVskstar", "Deuteron p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("LD/fAntiDeuteronPtVskstar", "AntiDeuteron p_{T} vs k^{*};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("LD/fLambdaPtVskstar", "Lambda p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("LD/fAntiLambdaPtVskstar", "AntiLambda p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + + // for phid + registry.add("PhiD/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("PhiD/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + registry.add("PhiD/fSE_particle", "Same Event distribution;k^{*} (GeV/c);Entries", HistType::kTH1F, {Binning.kstar}); + registry.add("PhiD/fSE_antiparticle", "Same Event distribution;k^{*} (GeV/c);Entries", HistType::kTH1F, {Binning.kstar}); + registry.add("PhiD/fPhiPtVskstar", "Phi p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("PhiD/fDeuteronPtVskstar", "Deuteron p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("PhiD/fAntiDeuteronPtVskstar", "AntiDeuteron p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("PhiD/fPhiInvMassVskstar", "#phi mass vs k^{*};M_{K^{+}K^{-}} (GeV/c^{2});k^{*} (GeV/c)", HistType::kTH2F, {Binning.invMassRho, Binning.kstar}); + + // for rhod + registry.add("RhoD/fMultiplicity", "Multiplicity;Mult;Entries", HistType::kTH1F, {Binning.multiplicity}); + registry.add("RhoD/fZvtx", "Zvtx;Z_{vtx};Entries", HistType::kTH1F, {Binning.zvtx}); + registry.add("RhoD/fSE_particle", "Same Event distribution;k^{*} (GeV/c);Entries", HistType::kTH1F, {Binning.kstar}); + registry.add("RhoD/fSE_antiparticle", "Same Event distribution;k^{*} (GeV/c);Entries", HistType::kTH1F, {Binning.kstar}); + registry.add("RhoD/fRhoPtVskstar", "Rho p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("RhoD/fDeuteronPtVskstar", "Deuteron p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("RhoD/fAntiDeuteronPtVskstar", "AntiDeuteron p_{T} vs k^{*};k^{*} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {Binning.momentum, Binning.kstar}}); + registry.add("RhoD/fRhoInvMassVskstar", "#rho mass vs k^{*};M_{#pi^{+}#pi^{-}} (GeV/c^{2});k^{*} (GeV/c)", HistType::kTH2F, {Binning.invMassRho, Binning.kstar}); } - float mMassElectron = o2::constants::physics::MassElectron; - float mMassPion = o2::constants::physics::MassPionCharged; - float mMassProton = o2::constants::physics::MassProton; - float mMassLambda = o2::constants::physics::MassLambda; - float mMassDeuteron = o2::constants::physics::MassDeuteron; - float mMassPhi = o2::constants::physics::MassPhi; - float mMassKaonPlus = o2::constants::physics::MassKPlus; - float mMassKaonMinus = o2::constants::physics::MassKMinus; - float mMassRho0 = 0.7665; // GeV/c^2 // o2::constants::physics::MassRho0; //Will not work as this is missing in the central framework, also ROOT reports the lepton production value of 0.77549 GeV/c^2, which is wrong for the hadron production at ALICE. + void initCCDB(int run) + { + if (run != mRunNumber) { + mRunNumber = run; + o2::parameters::GRPMagField* grpmag = ccdb->getForRun("GLO/Config/GRPMagField", run); + o2::base::Propagator::initFieldFromGRP(grpmag); + mBz = static_cast(grpmag->getNominalL3Field()); - int currentRunNumber = -999; - int lastRunNumber = -999; + mStraHelper.fitter.setBz(mBz); + } + if (!mStraHelper.lut) { /// done only once + ccdb->setURL(V0BuilderOpts.ccdbUrl); + ccdb->setCaching(true); + ccdb->setLocalObjectValidityChecking(); + ccdb->setFatalWhenNull(true); + auto* lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get("GLO/Param/MatLUT")); + o2::base::Propagator::Instance()->setMatLUT(lut); + mStraHelper.lut = lut; + } + } template - bool isSelectedEvent(T const& col) + bool checkEvent(T const& col) { - if (ConfEvtSelectZvtx && std::abs(col.posZ()) > ConfEvtZvtx) { + if (std::abs(col.posZ()) > EventSelection.zvtx.value) { return false; } - if (ConfEvtOfflineCheck && !col.sel8()) { + if (EventSelection.eventSel.value && !col.sel8()) { return false; } - // if event is close to the timeframe border, return false - if (ConfEvtTimeFrameBorderCheck && !col.selection_bit(aod::evsel::kNoTimeFrameBorder)) { - return false; - } - return true; } template - bool isSelectedTrack(T const& track, CFTrigger::ParticleSpecies partSpecies) + bool checkTrack(T const& track, std::string trackName) { - const auto charge = track.sign(); - const auto pT = track.pt(); - float momCorDif = track.tpcInnerParam() - track.p(); - float momCorRatio = momCorDif / track.p(); - const auto eta = track.eta(); - const auto tpcNClsF = track.tpcNClsFound(); - const auto tpcRClsC = track.tpcCrossedRowsOverFindableCls(); - const auto tpcNClsC = track.tpcNClsCrossedRows(); - const auto tpcNClsS = track.tpcNClsShared(); - const auto itsNCls = track.itsNCls(); - const auto itsNClsIB = track.itsNClsInnerBarrel(); - const auto dcaXY = track.dcaXY(); - const auto dcaZ = track.dcaZ(); - - if (charge > 0) { - if (pT < ConfPtCuts->get(partSpecies, "Pt min (particle)")) { - return false; - } - if (pT > ConfPtCuts->get(partSpecies, "Pt max (particle)")) { - return false; - } - if (ConfMomCorDifCutFlag.value && momCorDif < ConfMomCorDifCut->get(partSpecies, "Momemtum Correlation min")) { - return false; - } - if (ConfMomCorDifCutFlag.value && momCorDif > ConfMomCorDifCut->get(partSpecies, "Momemtum Correlation max")) { - return false; - } - if (ConfMomCorRatioCutFlag.value && momCorRatio < ConfMomCorRatioCut->get(partSpecies, "Momemtum Correlation min")) { - return false; - } - if (ConfMomCorRatioCutFlag.value && momCorRatio > ConfMomCorRatioCut->get(partSpecies, "Momemtum Correlation max")) { - return false; - } - } - if (charge < 0) { - if (pT < ConfPtCuts->get(partSpecies, "Pt min (antiparticle)")) { - return false; - } - if (pT > ConfPtCuts->get(partSpecies, "Pt max (antiparticle)")) { - return false; - } - if (ConfMomCorDifCutFlag.value && momCorDif < ConfMomCorDifCutAnti->get(partSpecies, "Momemtum Correlation min")) { - return false; - } - if (ConfMomCorDifCutFlag.value && momCorDif > ConfMomCorDifCutAnti->get(partSpecies, "Momemtum Correlation max")) { - return false; - } - if (ConfMomCorRatioCutFlag.value && momCorRatio < ConfMomCorRatioCutAnti->get(partSpecies, "Momemtum Correlation min")) { - return false; - } - if (ConfMomCorRatioCutFlag.value && momCorRatio > ConfMomCorRatioCutAnti->get(partSpecies, "Momemtum Correlation max")) { - return false; - } - } - - if (std::abs(eta) > ConfTrkEta) { - return false; - } - if (tpcNClsF < ConfTPCNClustersMin->get("TPCNClusMin", partSpecies)) { - return false; - } - if (tpcRClsC < ConfTrkTPCfCls) { + if (std::abs(track.eta()) > TrackSelections.trackProperties->get(trackName.c_str(), "AbsEtaMax")) { return false; } - if (tpcNClsC < ConfTrkTPCcRowsMin) { + if (track.tpcNClsFound() < TrackSelections.trackProperties->get(trackName.c_str(), "TpcClusterMin")) { return false; } - if (tpcNClsS > ConfTrkTPCsClsMax) { + if (track.tpcNClsCrossedRows() < TrackSelections.trackProperties->get(trackName.c_str(), "TpcRowMin")) { return false; } - if (itsNCls < ConfTrkITSnclsMin->get(static_cast(0), partSpecies)) { + if (track.tpcCrossedRowsOverFindableCls() < TrackSelections.trackProperties->get(trackName.c_str(), "TpcCrossedOverFoundMin")) { return false; } - if (itsNClsIB < ConfTrkITSnclsIBMin->get(static_cast(0), partSpecies)) { + if (track.tpcNClsShared() > TrackSelections.trackProperties->get(trackName.c_str(), "TpcSharedMax")) { return false; } - if (std::abs(dcaXY) > ConfTrkDCAxyMax) { + if (track.tpcFractionSharedCls() > TrackSelections.trackProperties->get(trackName.c_str(), "TpcFracSharedMax")) { return false; } - if (std::abs(dcaZ) > ConfTrkDCAzMax) { + if (track.itsNCls() < TrackSelections.trackProperties->get(trackName.c_str(), "ItsClusterMin")) { return false; } - // TODO: which dca, put dcaxy for now - if (ConfRejectNotPropagatedTracks && std::abs(dcaXY) > 1e3) { + if (track.itsNClsInnerBarrel() < TrackSelections.trackProperties->get(trackName.c_str(), "ItsIbClusterMin")) { return false; } - if (ConfTrkRequireChi2MaxTPC && track.tpcChi2NCl() >= ConfTrkMaxChi2PerClusterTPC) { + if (std::abs(track.dcaXY()) > TrackSelections.trackProperties->get(trackName.c_str(), "AbsDcaXyMax")) { return false; } - if (ConfTrkRequireChi2MaxITS && track.itsChi2NCl() >= ConfTrkMaxChi2PerClusterITS) { + if (std::abs(track.dcaZ()) > TrackSelections.trackProperties->get(trackName.c_str(), "AbsDcaZMax")) { return false; } - if (ConfTrkTPCRefit && !track.hasTPC()) { + if (track.tpcChi2NCl() > TrackSelections.trackProperties->get(trackName.c_str(), "Chi2TpcMax")) { return false; } - if (ConfTrkITSRefit && !track.hasITS()) { + if (track.itsChi2NCl() > TrackSelections.trackProperties->get(trackName.c_str(), "Chi2ItsMax")) { return false; } return true; } - template - bool isSelectedV0Daughter(T const& track, V const& v0, float charge, CFTrigger::V0Daughters species, double nSigmaTPCDaug[2]) + template + bool checkTrackPid(T const& track, std::string trackName) { - const auto tpcNClsF = track.tpcNClsFound(); - float eta = -1; - float dca = -1; - if (charge > 0) { - eta = v0.positiveeta(); - dca = v0.dcapostopv(); - } else if (charge < 0) { - eta = v0.negativeeta(); - dca = v0.dcanegtopv(); - } - const auto sign = track.sign(); - double nSigmaTPC = -999.f; + float momentum = -99; - if (charge < 0 && sign > 0) { - return false; - } - if (charge > 0 && sign < 0) { - return false; - } - if (std::abs(eta) > ConfDaughEta) { - return false; - } - if (tpcNClsF < ConfDaughTPCnclsMin) { - return false; - } - if (std::abs(dca) < ConfDaughDCAMin) { - return false; - } - - switch (species) { - case CFTrigger::kDaughPion: - nSigmaTPC = nSigmaTPCDaug[1]; - break; - case CFTrigger::kDaughProton: - nSigmaTPC = nSigmaTPCDaug[0]; - break; - default: - LOG(fatal) << "Particle species for V0 daughters not found"; - } - - if (nSigmaTPC < ConfDaughPIDCuts->get(species, "TPC min") || - nSigmaTPC > ConfDaughPIDCuts->get(species, "TPC max")) { - return false; + if (TrackSelections.momentum->get(trackName.c_str(), "UseInnerParam") < 0) { + momentum = track.p(); + } else { + momentum = track.tpcInnerParam(); } - return true; - } - template - bool isSelectedTrackPID(T const& track, CFTrigger::ParticleSpecies partSpecies, bool Rejection, double nSigmaTPC[2], int charge) - { - // nSigma should have entries [proton, deuteron, pion] - bool isSelected = false; - bool pThres = true; - float nSigma = -999.; - float nSigmaIts = -999.; - - // check tracking PID - uint8_t SpeciesForTracking = 0; - if (partSpecies == CFTrigger::kProton) { - SpeciesForTracking = o2::track::PID::Proton; - } else if (partSpecies == CFTrigger::kDeuteron) { - SpeciesForTracking = o2::track::PID::Deuteron; - } else if (partSpecies == CFTrigger::kPion) { - SpeciesForTracking = o2::track::PID::Pion; + float nsigmaITS = -99; + float nsigmaTPC = -99; + float nsigmaTPCTOF = -99; + + if (trackName == std::string("Pion")) { + nsigmaITS = track.itsNSigmaPi(); + nsigmaTPC = track.tpcNSigmaPi(); + nsigmaTPCTOF = RecoDecay::sqrtSumOfSquares(track.tpcNSigmaPi(), track.tofNSigmaPi()); + } else if (trackName == std::string("Kaon")) { + nsigmaITS = track.itsNSigmaKa(); + nsigmaTPC = track.tpcNSigmaKa(); + nsigmaTPCTOF = RecoDecay::sqrtSumOfSquares(track.tpcNSigmaKa(), track.tofNSigmaKa()); + } else if (trackName == std::string("Proton")) { + nsigmaITS = track.itsNSigmaPr(); + nsigmaTPC = track.tpcNSigmaPr(); + nsigmaTPCTOF = RecoDecay::sqrtSumOfSquares(track.tpcNSigmaPr(), track.tofNSigmaPr()); + } else if (trackName == std::string("Deuteron")) { + nsigmaITS = track.itsNSigmaDe(); + nsigmaTPC = track.tpcNSigmaDe(); + nsigmaTPCTOF = RecoDecay::sqrtSumOfSquares(track.tpcNSigmaDe(), track.tofNSigmaDe()); } else { - LOG(warn) << "Unknown PID for tracking encountered"; + LOG(fatal) << "Unsupported track type"; } - if (ConfPIDForTracking->get(partSpecies, "Switch") > 0 && track.tpcInnerParam() < ConfPIDForTracking->get(partSpecies, "Momemtum Threshold")) { - if (track.pidForTracking() != SpeciesForTracking) { + if (momentum < TrackSelections.momentum->get(trackName.c_str(), "PThres")) { + if (nsigmaITS < TrackSelections.pid->get(trackName.c_str(), "ItsMin") || nsigmaITS > TrackSelections.pid->get(trackName.c_str(), "ItsMax")) { return false; } - } - - // check momentum threshold - if (track.tpcInnerParam() <= ConfPtCuts->get(partSpecies, "P thres")) { - pThres = true; - } else { - pThres = false; - } - if (CFTrigger::kDeuteron == partSpecies && ConfDeuteronThPVMom) { - if (track.p() <= ConfPtCuts->get(partSpecies, "P thres")) { - pThres = true; - } else { - pThres = false; - } - } - // compute nsigma - switch (partSpecies) { - case CFTrigger::kProton: - nSigmaIts = track.itsNSigmaPr(); - if (pThres) { - nSigma = nSigmaTPC[0]; - } else { - if (charge > 0) { - nSigma = std::sqrt(std::pow(nSigmaTPC[0] - TPCTOFAvg[0], 2) + std::pow(track.tofNSigmaPr() - TPCTOFAvg[1], 2)); - } else { - nSigma = std::sqrt(std::pow(nSigmaTPC[0] - TPCTOFAvg[2], 2) + std::pow(track.tofNSigmaPr() - TPCTOFAvg[3], 2)); - } - } - break; - case CFTrigger::kDeuteron: - nSigmaIts = track.itsNSigmaDe(); - if (pThres) { - nSigma = nSigmaTPC[1]; - } else { - if (charge > 0) { - nSigma = std::sqrt(std::pow(nSigmaTPC[1] - TPCTOFAvg[4], 2) + std::pow(track.tofNSigmaDe() - TPCTOFAvg[5], 2)); - } else { - nSigma = std::sqrt(std::pow(nSigmaTPC[1] - TPCTOFAvg[6], 2) + std::pow(track.tofNSigmaDe() - TPCTOFAvg[7], 2)); - } - } - break; - case CFTrigger::kLambda: - LOG(fatal) << "No PID selection for Lambdas"; - break; - case CFTrigger::kPion: - nSigmaIts = track.itsNSigmaPi(); - if (pThres) { - nSigma = nSigmaTPC[2]; - } else { - if (charge > 0) { - nSigma = std::sqrt(std::pow(nSigmaTPC[2] - TPCTOFAvg[8], 2) + std::pow(track.tofNSigmaPr() - TPCTOFAvg[9], 2)); - } else { - nSigma = std::sqrt(std::pow(nSigmaTPC[2] - TPCTOFAvg[10], 2) + std::pow(track.tofNSigmaPr() - TPCTOFAvg[11], 2)); - } - } - break; - default: - LOG(fatal) << "Particle species not known"; - } - // check if track is selected - - auto TPCmin = (charge > 0) ? ConfPIDCuts->get(partSpecies, CFTrigger::kTPCMin) - : ConfPIDCutsAnti->get(partSpecies, CFTrigger::kTPCMin); - - auto TPCmax = (charge > 0) ? ConfPIDCuts->get(partSpecies, CFTrigger::kTPCMax) - : ConfPIDCutsAnti->get(partSpecies, CFTrigger::kTPCMax); - - auto TPCTOFmax = (charge > 0) ? ConfPIDCuts->get(partSpecies, CFTrigger::kTPCTOF) - : ConfPIDCutsAnti->get(partSpecies, CFTrigger::kTPCTOF); - - auto ITSmin = (charge > 0) ? ConfPIDCuts->get(partSpecies, CFTrigger::kITSmin) - : ConfPIDCutsAnti->get(partSpecies, CFTrigger::kITSmin); - - auto ITSmax = (charge < 0) ? ConfPIDCuts->get(partSpecies, CFTrigger::kITSmax) - : ConfPIDCutsAnti->get(partSpecies, CFTrigger::kITSmax); - - if (pThres) { - if (nSigma > TPCmin && - nSigma < TPCmax && - nSigmaIts > ITSmin && - nSigmaIts < ITSmax) { - isSelected = true; + if (nsigmaTPC < TrackSelections.pid->get(trackName.c_str(), "TpcMin") || nsigmaTPC > TrackSelections.pid->get(trackName.c_str(), "TpcMax")) { + return false; } } else { - if (nSigma < TPCTOFmax) { - isSelected = true; - } - } - // for deuterons normally, we want to reject tracks that have a high - // probablilty of being another particle - if (Rejection) { - double nSigmaPi = track.tpcNSigmaPi(); - double nSigmaEl = track.tpcNSigmaEl(); - if (ConfUseManualPIDpion) { - auto bgScalingPion = 1 / mMassPion; // momentum scaling? - if (BBPion.size() == 6 && charge > 0) - nSigmaPi = updatePID(track, bgScalingPion, BBPion); - if (BBAntipion.size() == 6 && charge < 0) - nSigmaPi = updatePID(track, bgScalingPion, BBAntipion); - } - if (ConfUseManualPIDel) { - auto bgScalingElectron = 1 / mMassElectron; // momentum scaling? - if (BBElectron.size() == 6 && charge < 0) - nSigmaEl = updatePID(track, bgScalingElectron, BBElectron); - if (BBAntielectron.size() == 6 && charge > 0) - nSigmaEl = updatePID(track, bgScalingElectron, BBAntielectron); - } - if ((ConfPIDRejection->get(CFTrigger::kRejProton, CFTrigger::kTPCMin) < nSigmaTPC[0] && - ConfPIDRejection->get(CFTrigger::kRejProton, CFTrigger::kTPCMax) > nSigmaTPC[0]) || - (ConfPIDRejection->get(CFTrigger::kRejPion, CFTrigger::kTPCMin) < nSigmaPi && - ConfPIDRejection->get(CFTrigger::kRejPion, CFTrigger::kTPCMax) > nSigmaPi) || - (ConfPIDRejection->get(CFTrigger::kRejElectron, CFTrigger::kTPCMin) < nSigmaEl && - ConfPIDRejection->get(CFTrigger::kRejElectron, CFTrigger::kTPCMax) > nSigmaEl)) { + if (nsigmaTPCTOF > TrackSelections.pid->get(trackName.c_str(), "TpcTofMax")) { return false; } } - return isSelected; + return true; } - template - bool isSelectedMinimalV0(C const& /*col*/, V const& v0, T const& posTrack, - T const& negTrack, float charge, double nSigmaTPCPos[2], double nSigmaTPCNeg[2]) + bool checkLambda(float lambdaPt, float lambdaDauDca, float lambdaCpa, float lambdaRadius, float lambdaPos, float kaonMass, float lambdaMass) { - const auto signPos = posTrack.sign(); - const auto signNeg = negTrack.sign(); - if (signPos < 0 || signNeg > 0) { - LOG(info) << "Something wrong in isSelectedMinimal"; - LOG(info) << "ERROR - Wrong sign for V0 daughters"; - } - const float pT = v0.pt(); - const std::vector decVtx = {v0.x(), v0.y(), v0.z()}; - const float tranRad = v0.v0radius(); - const float dcaDaughv0 = v0.dcaV0daughters(); - const float cpav0 = v0.v0cosPA(); - - const float invMassLambda = v0.mLambda(); - const float invMassAntiLambda = v0.mAntiLambda(); - - if (charge > 0 && (invMassLambda < ConfV0InvMassLowLimit || invMassLambda > ConfV0InvMassUpLimit)) { - return false; - } - if (charge < 0 && (invMassAntiLambda < ConfV0InvMassLowLimit || invMassAntiLambda > ConfV0InvMassUpLimit)) { + if (lambdaPt < LambdaSelections.ptMin) { return false; } - if (ConfV0RejectKaons) { - const float invMassKaon = v0.mK0Short(); - if (invMassKaon > ConfV0InvKaonMassLowLimit && invMassKaon < ConfV0InvKaonMassUpLimit) { - return false; - } - } - if (pT < ConfV0PtMin) { + if (lambdaDauDca > LambdaSelections.dcaDaughMax) { return false; } - if (dcaDaughv0 > ConfV0DCADaughMax) { + if (lambdaCpa < LambdaSelections.cpaMin) { return false; } - if (cpav0 < ConfV0CPAMin) { + if (lambdaRadius < LambdaSelections.tranRadMin) { return false; } - if (tranRad < ConfV0TranRadV0Min) { + if (lambdaRadius > LambdaSelections.tranRadMax) { return false; } - if (tranRad > ConfV0TranRadV0Max) { + if (lambdaPos > LambdaSelections.decVtxMax) { return false; } - for (size_t i = 0; i < decVtx.size(); i++) { - if (decVtx.at(i) > ConfV0DecVtxMax) { + if (LambdaSelections.rejectKaons) { + if (kaonMass > LambdaSelections.invKaonMassLow && kaonMass < LambdaSelections.invKaonMassUp) { return false; } } - if (charge > 0) { - if (!isSelectedV0Daughter(posTrack, v0, 1, CFTrigger::kDaughProton, nSigmaTPCPos)) { - return false; - } - if (!isSelectedV0Daughter(negTrack, v0, -1, CFTrigger::kDaughPion, nSigmaTPCNeg)) { - return false; - } + if (lambdaMass < LambdaSelections.invMassLow) { + return false; } - if (charge < 0) { - if (!isSelectedV0Daughter(posTrack, v0, 1, CFTrigger::kDaughPion, nSigmaTPCPos)) { - return false; - } - if (!isSelectedV0Daughter(negTrack, v0, -1, CFTrigger::kDaughProton, nSigmaTPCNeg)) { - return false; - } + if (lambdaMass > LambdaSelections.invMassUp) { + return false; } return true; } template - bool isSelectedTrackKaon(T const& track) + bool checkLambdaDaughter(T const& track, float eta, float dca, float nSigmaTPC) { - bool isSelected = false; - if (track.pt() <= PPPhi.ConfTrkPtKaUp.value && track.pt() >= PPPhi.ConfTrkPtKaDown.value && std::abs(track.eta()) <= PPPhi.ConfTrkEtaKa.value && std::abs(track.dcaXY()) <= PPPhi.ConfTrkDCAxyKa.value && std::abs(track.dcaZ()) <= PPPhi.ConfTrkDCAzKa.value && track.tpcNClsCrossedRows() >= PPPhi.ConfNCrossedKa.value && track.tpcNClsFound() >= PPPhi.ConfNClusKa.value && track.tpcCrossedRowsOverFindableCls() >= PPPhi.ConfTrkTPCfClsKa.value) { - if (track.tpcInnerParam() < PPPhi.ConfTrkPTPCKaThr.value && std::abs(track.tpcNSigmaKa()) <= PPPhi.ConfTrkKaSigmaPID.value) { - isSelected = true; - } - if (track.tpcInnerParam() >= PPPhi.ConfTrkPTPCKaThr.value && std::abs(std::sqrt(track.tpcNSigmaKa() * track.tpcNSigmaKa() + track.tofNSigmaKa() * track.tofNSigmaKa())) <= PPPhi.ConfTrkKaSigmaPID.value) { - isSelected = true; - } + if (std::abs(eta) > LambdaDaughterSelections.absEtaMax.value) { + return false; } - return isSelected; - } - - double translatePhi(double phi) - { - if (phi < 0) { - phi += 2 * M_PI; // Add 2 pi to make it positive + if (std::abs(dca) < LambdaDaughterSelections.dcaMin.value) { + return false; } - return phi; + if (track.tpcNClsFound() < LambdaDaughterSelections.tpcClusterMin.value) { + return false; + } + if (std::abs(nSigmaTPC) > LambdaDaughterSelections.tpcMax.value) { + return false; + } + return true; } float getkstar(const ROOT::Math::PtEtaPhiMVector part1, @@ -1453,18 +1055,18 @@ struct CFFilter { const float betay = beta * std::sin(trackSum.Phi()) * std::sin(trackSum.Theta()); const float betaz = beta * std::cos(trackSum.Theta()); - ROOT::Math::PxPyPzMVector PartOneCMS(part1); - ROOT::Math::PxPyPzMVector PartTwoCMS(part2); + ROOT::Math::PxPyPzMVector partOneCMS(part1); + ROOT::Math::PxPyPzMVector partTwoCMS(part2); const ROOT::Math::Boost boostPRF = ROOT::Math::Boost(-betax, -betay, -betaz); - PartOneCMS = boostPRF(PartOneCMS); - PartTwoCMS = boostPRF(PartTwoCMS); - const ROOT::Math::PxPyPzMVector trackRelK = PartOneCMS - PartTwoCMS; + partOneCMS = boostPRF(partOneCMS); + partTwoCMS = boostPRF(partTwoCMS); + const ROOT::Math::PxPyPzMVector trackRelK = partOneCMS - partTwoCMS; return 0.5 * trackRelK.P(); } - ROOT::Math::PxPyPzEVector getqij(const ROOT::Math::PtEtaPhiMVector parti, - const ROOT::Math::PtEtaPhiMVector partj) + ROOT::Math::PxPyPzEVector + getqij(const ROOT::Math::PtEtaPhiMVector parti, const ROOT::Math::PtEtaPhiMVector partj) { ROOT::Math::PxPyPzEVector vecparti(parti); ROOT::Math::PxPyPzEVector vecpartj(partj); @@ -1473,1137 +1075,1120 @@ struct CFFilter { float scaling = trackDifference.Dot(trackSum) / trackSum.Dot(trackSum); return trackDifference - scaling * trackSum; } - float getQ3(const ROOT::Math::PtEtaPhiMVector part1, - const ROOT::Math::PtEtaPhiMVector part2, - const ROOT::Math::PtEtaPhiMVector part3) + float getQ3(const ROOT::Math::PtEtaPhiMVector part1, const ROOT::Math::PtEtaPhiMVector part2, const ROOT::Math::PtEtaPhiMVector part3) { ROOT::Math::PxPyPzEVector q12 = getqij(part1, part2); ROOT::Math::PxPyPzEVector q23 = getqij(part2, part3); ROOT::Math::PxPyPzEVector q31 = getqij(part3, part1); - float Q32 = q12.M2() + q23.M2() + q31.M2(); - return sqrt(-Q32); - } - - std::vector setValuesBB(aod::BCsWithTimestamps::iterator const& bunchCrossing, const std::string ccdbPath) - { - map metadata; - auto h = ccdbApi.retrieveFromTFileAny(ccdbPath, metadata, bunchCrossing.timestamp()); - // auto h = ccdb->getForTimeStamp(ccdbPath, bunchCrossing.timestamp()); //check if possible to use this without getting fatal - if (!h) { - std::vector dummy; - LOG(info) << "File from CCDB in path " << ccdbPath << " was not found for run " << bunchCrossing.runNumber() << ". Will use default PID task values!"; - return dummy; - } - LOG(info) << "File from CCDB in path " << ccdbPath << " was found for run " << bunchCrossing.runNumber() << "!"; - - TAxis* axis = h->GetXaxis(); - std::vector v{static_cast(h->GetBinContent(axis->FindBin("bb1"))), - static_cast(h->GetBinContent(axis->FindBin("bb2"))), - static_cast(h->GetBinContent(axis->FindBin("bb3"))), - static_cast(h->GetBinContent(axis->FindBin("bb4"))), - static_cast(h->GetBinContent(axis->FindBin("bb5"))), - static_cast(h->GetBinContent(axis->FindBin("Resolution")))}; - return v; - } - - std::vector setValuesAvg(aod::BCsWithTimestamps::iterator const& bunchCrossing, const std::string ccdbPath) - { - map metadata; - auto h = ccdbApi.retrieveFromTFileAny(ccdbPath, metadata, bunchCrossing.timestamp()); - // auto h = ccdb->getForTimeStamp(ccdbPath, bunchCrossing.timestamp()); //check if possible to use this without getting fatal - if (!h) { - std::vector dummy{ConfPIDTPCTOFAvg->get("Proton", "TPC Avg"), - ConfPIDTPCTOFAvg->get("Proton", "TOF Avg"), - ConfPIDTPCTOFAvg->get("AntiProton", "TPC Avg"), - ConfPIDTPCTOFAvg->get("AntiProton", "TOF Avg"), - ConfPIDTPCTOFAvg->get("Deuteron", "TPC Avg"), - ConfPIDTPCTOFAvg->get("Deuteron", "TOF Avg"), - ConfPIDTPCTOFAvg->get("AntiDeuteron", "TPC Avg"), - ConfPIDTPCTOFAvg->get("AntiDeuteron", "TOF Avg")}; - LOG(info) << "File from CCDB in path " << ccdbPath << " was not found for run " << bunchCrossing.runNumber() << ". Will use constant values from ConfPIDTPCTOFAvg!"; - return dummy; - } - LOG(info) << "File from CCDB in path " << ccdbPath << " was found for run " << bunchCrossing.runNumber() << "!"; - - TAxis* axis = h->GetXaxis(); - std::vector v{static_cast(h->GetBinContent(axis->FindBin("TPCProton"))), - static_cast(h->GetBinContent(axis->FindBin("TOFProton"))), - static_cast(h->GetBinContent(axis->FindBin("TPCAntiproton"))), - static_cast(h->GetBinContent(axis->FindBin("TOFAntiproton"))), - static_cast(h->GetBinContent(axis->FindBin("TPCDeuteron"))), - static_cast(h->GetBinContent(axis->FindBin("TOFDeuteron"))), - static_cast(h->GetBinContent(axis->FindBin("TPCAntideuteron"))), - static_cast(h->GetBinContent(axis->FindBin("TOFAntideuteron")))}; - return v; + float q32 = q12.M2() + q23.M2() + q31.M2(); + return std::sqrt(-q32); } template - double updatePID(T const& track, double bgScaling, std::vector BB) + float itsSignal(T const& track) { - double expBethe = tpc::BetheBlochAleph(static_cast(track.tpcInnerParam() * bgScaling), BB[0], BB[1], BB[2], BB[3], BB[4]); - double expSigma = expBethe * BB[5]; - return static_cast((track.tpcSignal() - expBethe) / expSigma); - } - - void process(aod::FemtoFullCollision const& col, aod::BCsWithTimestamps const&, aod::FemtoFullTracks const& tracks, o2::aod::V0Datas const& fullV0s) + uint32_t clsizeflag = track.itsClusterSizes(); + auto clSizeLayer0 = (clsizeflag >> (0 * 4)) & 0xf; + auto clSizeLayer1 = (clsizeflag >> (1 * 4)) & 0xf; + auto clSizeLayer2 = (clsizeflag >> (2 * 4)) & 0xf; + auto clSizeLayer3 = (clsizeflag >> (3 * 4)) & 0xf; + auto clSizeLayer4 = (clsizeflag >> (4 * 4)) & 0xf; + auto clSizeLayer5 = (clsizeflag >> (5 * 4)) & 0xf; + auto clSizeLayer6 = (clsizeflag >> (6 * 4)) & 0xf; + int numLayers = 7; + int sumClusterSizes = clSizeLayer1 + clSizeLayer2 + clSizeLayer3 + clSizeLayer4 + clSizeLayer5 + clSizeLayer6 + clSizeLayer0; + float cosLamnda = 1. / std::cosh(track.eta()); + return (static_cast(sumClusterSizes) / numLayers) * cosLamnda; + }; + + void process(cf_trigger::FullCollision const& col, aod::BCs const&, cf_trigger::FullTracks const& tracks, o2::aod::V0s const& v0s) { - if (!ConfIsRun3) { - LOG(fatal) << "Run 2 processing is not implemented!"; - } - - if (ConfUseManualPIDproton || ConfUseManualPIDdeuteron || ConfUseAvgFromCCDB) { - currentRunNumber = col.bc_as().runNumber(); - if (currentRunNumber != lastRunNumber) { - auto bc = col.bc_as(); - if (ConfUseManualPIDproton || ConfUseManualPIDdaughterProton) { - BBProton = setValuesBB(bc, ConfPIDBBProton); - BBAntiproton = setValuesBB(bc, ConfPIDBBAntiProton); - } - if (ConfUseManualPIDdeuteron) { - BBDeuteron = setValuesBB(bc, ConfPIDBBDeuteron); - BBAntideuteron = setValuesBB(bc, ConfPIDBBAntiDeuteron); - } - if (ConfUseManualPIDpion || ConfUseManualPIDdaughterPion) { - BBPion = setValuesBB(bc, ConfPIDBBPion); - BBAntipion = setValuesBB(bc, ConfPIDBBAntiPion); - } - if (ConfUseManualPIDpion) { - BBElectron = setValuesBB(bc, ConfPIDBBElectron); - BBAntielectron = setValuesBB(bc, ConfPIDBBAntiElectron); - } - if (ConfUseAvgFromCCDB) { - TPCTOFAvg = setValuesAvg(bc, ConfAvgPath); - } - lastRunNumber = currentRunNumber; - } - } - - auto tracksWithItsPid = soa::Attach(tracks); + auto tracksWithItsPid = soa::Attach(tracks); registry.fill(HIST("fProcessedEvents"), 0); - registry.fill(HIST("EventCuts/fMultiplicityBefore"), col.multNTracksPV()); - registry.fill(HIST("EventCuts/fZvtxBefore"), col.posZ()); + registry.fill(HIST("EventQA/Before/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("EventQA/Before/fZvtx"), col.posZ()); - bool keepEvent3N[CFTrigger::kNThreeBodyTriggers] = {false, false, false, false, false, false}; - int lowQ3Triplets[CFTrigger::kNThreeBodyTriggers] = {0, 0, 0, 0, 0, 0}; - - bool keepEvent2N[CFTrigger::kNTwoBodyTriggers] = {false, false}; - int lowKstarPairs[CFTrigger::kNTwoBodyTriggers] = {0, 0}; - - if (isSelectedEvent(col)) { - - registry.fill(HIST("EventCuts/fMultiplicityAfter"), col.multNTracksPV()); - registry.fill(HIST("EventCuts/fZvtxAfter"), col.posZ()); - - // keep track of proton indices - std::vector ProtonIndex = {}; - std::vector AntiProtonIndex = {}; - - // Prepare vectors for different species - std::vector protons, antiprotons, deuterons, antideuterons, lambdas, antilambdas, kaons, antikaons, phi, pions, antipions, rho; - - // create deuteron and proton vectors (and corresponding antiparticles) for pair and triplet creation - for (auto& track : tracksWithItsPid) { - - double nTPCSigmaP[3]{track.tpcNSigmaPr(), track.tpcNSigmaDe(), track.tpcNSigmaPi()}; - double nTPCSigmaN[3]{track.tpcNSigmaPr(), track.tpcNSigmaDe(), track.tpcNSigmaPi()}; + if (!checkEvent(col)) { + return; + } - if (ConfUseManualPIDproton) { - auto bgScalingProton = 1 / mMassProton; // momentum scaling? - if (BBProton.size() == 6) - nTPCSigmaP[0] = updatePID(track, bgScalingProton, BBProton); - if (BBAntiproton.size() == 6) - nTPCSigmaN[0] = updatePID(track, bgScalingProton, BBAntiproton); - } - if (ConfUseManualPIDdeuteron) { - auto bgScalingDeuteron = 1 / mMassDeuteron; // momentum scaling? - if (BBDeuteron.size() == 6) - nTPCSigmaP[1] = updatePID(track, bgScalingDeuteron, BBDeuteron); - if (BBAntideuteron.size() == 6) - nTPCSigmaN[1] = updatePID(track, bgScalingDeuteron, BBAntideuteron); + registry.fill(HIST("EventQA/After/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("EventQA/After/fZvtx"), col.posZ()); + + initCCDB(col.bc().runNumber()); + + // clear particle vectors + vecProton.clear(); + vecAntiProton.clear(); + vecDeuteron.clear(); + vecAntiDeuteron.clear(); + vecLambda.clear(); + vecAntiLambda.clear(); + vecKaon.clear(); + vecAntiKaon.clear(); + vecPhi.clear(); + vecPion.clear(); + vecAntiPion.clear(); + vecRho.clear(); + // clear index vectors for all particles + idxProton.clear(); + idxAntiProton.clear(); + idxDeuteron.clear(); + idxAntiDeuteron.clear(); + idxKaon.clear(); + idxAntiKaon.clear(); + idxPion.clear(); + idxAntiPion.clear(); + // clear index vectors for daughters + idxLambdaDaughProton.clear(); + idxLambdaDaughPion.clear(); + idxAntiLambdaDaughProton.clear(); + idxAntiLambdaDaughPion.clear(); + idxPhiDaughPos.clear(); + idxPhiDaughNeg.clear(); + idxRhoDaughPos.clear(); + idxRhoDaughNeg.clear(); + + for (auto const& track : tracksWithItsPid) { + + // get paritcles + if (track.sign() > 0) { + registry.fill(HIST("TrackQA/Before/Particle/fPt"), track.pt()); + registry.fill(HIST("TrackQA/Before/Particle/fEta"), track.eta()); + registry.fill(HIST("TrackQA/Before/Particle/fPhi"), track.phi()); + registry.fill(HIST("TrackQA/Before/Particle/fMomCor"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + registry.fill(HIST("TrackQA/Before/Particle/fItsSignal"), track.p(), itsSignal(track)); + registry.fill(HIST("TrackQA/Before/Particle/fTpcSignal"), track.p(), track.tpcSignal()); + registry.fill(HIST("TrackQA/Before/Particle/fTofSignal"), track.p(), track.beta()); + + registry.fill(HIST("TrackQA/Before/Pion/fNsigmaITS"), track.p(), track.itsNSigmaPi()); + registry.fill(HIST("TrackQA/Before/Pion/fNsigmaTPC"), track.p(), track.tpcNSigmaPi()); + registry.fill(HIST("TrackQA/Before/Pion/fNsigmaTOF"), track.p(), track.tofNSigmaPi()); + registry.fill(HIST("TrackQA/Before/Pion/fNsigmaTPCTOF"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaPi(), track.tofNSigmaPi())); + + registry.fill(HIST("TrackQA/Before/Kaon/fNsigmaITS"), track.p(), track.itsNSigmaKa()); + registry.fill(HIST("TrackQA/Before/Kaon/fNsigmaTPC"), track.p(), track.tpcNSigmaKa()); + registry.fill(HIST("TrackQA/Before/Kaon/fNsigmaTOF"), track.p(), track.tofNSigmaKa()); + registry.fill(HIST("TrackQA/Before/Kaon/fNsigmaTPCTOF"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaKa(), track.tofNSigmaKa())); + + registry.fill(HIST("TrackQA/Before/Proton/fNsigmaITS"), track.p(), track.itsNSigmaPr()); + registry.fill(HIST("TrackQA/Before/Proton/fNsigmaTPC"), track.p(), track.tpcNSigmaPr()); + registry.fill(HIST("TrackQA/Before/Proton/fNsigmaTOF"), track.p(), track.tofNSigmaPr()); + registry.fill(HIST("TrackQA/Before/Proton/fNsigmaTPCTOF"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaPr(), track.tofNSigmaPr())); + + registry.fill(HIST("TrackQA/Before/Deuteron/fNsigmaITS"), track.p(), track.itsNSigmaDe()); + registry.fill(HIST("TrackQA/Before/Deuteron/fNsigmaTPC"), track.p(), track.tpcNSigmaDe()); + registry.fill(HIST("TrackQA/Before/Deuteron/fNsigmaTOF"), track.p(), track.tofNSigmaDe()); + registry.fill(HIST("TrackQA/Before/Deuteron/fNsigmaTPCTOF"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaDe(), track.tofNSigmaDe())); + + if (checkTrack(track, std::string("Pion")) && checkTrackPid(track, std::string("Pion"))) { + vecPion.emplace_back(track.pt(), track.eta(), track.phi(), o2::constants::physics::MassPionCharged); + idxPion.push_back(track.globalIndex()); + + registry.fill(HIST("TrackQA/After/Pion/fPt"), track.pt()); + registry.fill(HIST("TrackQA/After/Pion/fPTpc"), track.tpcInnerParam()); + registry.fill(HIST("TrackQA/After/Pion/fMomCor"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + registry.fill(HIST("TrackQA/After/Pion/fEta"), track.eta()); + registry.fill(HIST("TrackQA/After/Pion/fPhi"), track.phi()); + + registry.fill(HIST("TrackQA/After/Pion/fNsigmaIts"), track.p(), track.itsNSigmaPi()); + registry.fill(HIST("TrackQA/After/Pion/fNsigmaTpc"), track.p(), track.tpcNSigmaPi()); + registry.fill(HIST("TrackQA/After/Pion/fNsigmaTof"), track.p(), track.tofNSigmaPi()); + registry.fill(HIST("TrackQA/After/Pion/fNsigmaTpcTof"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaPi(), track.tofNSigmaPi())); + + registry.fill(HIST("TrackQA/After/Pion/fItsSignal"), track.p(), itsSignal(track)); + registry.fill(HIST("TrackQA/After/Pion/fTpcSignal"), track.p(), track.tpcSignal()); + registry.fill(HIST("TrackQA/After/Pion/fTofBeta"), track.p(), track.beta()); + + registry.fill(HIST("TrackQA/After/Pion/fDcaXy"), track.pt(), track.dcaXY()); + registry.fill(HIST("TrackQA/After/Pion/fDcaZ"), track.pt(), track.dcaZ()); + + registry.fill(HIST("TrackQA/After/Pion/fTpcClusters"), track.tpcNClsFound()); + registry.fill(HIST("TrackQA/After/Pion/fTpcCrossedRows"), track.tpcNClsCrossedRows()); + registry.fill(HIST("TrackQA/After/Pion/fTpcSharedClusters"), track.tpcNClsShared()); + registry.fill(HIST("TrackQA/After/Pion/fTpcSharedClusterOverClusterss"), track.tpcFractionSharedCls()); + registry.fill(HIST("TrackQA/After/Pion/fTpcFindableOverRows"), track.tpcCrossedRowsOverFindableCls()); + registry.fill(HIST("TrackQA/After/Pion/fTpcChi2OverCluster"), track.tpcChi2NCl()); + + registry.fill(HIST("TrackQA/After/Pion/fItsClusters"), track.itsNCls()); + registry.fill(HIST("TrackQA/After/Pion/fItsIbClusters"), track.itsNClsInnerBarrel()); + registry.fill(HIST("TrackQA/After/Pion/fItsChi2OverCluster"), track.itsChi2NCl()); } - registry.fill(HIST("TrackCuts/TracksBefore/fPtTrackBefore"), track.pt()); - registry.fill(HIST("TrackCuts/TracksBefore/fEtaTrackBefore"), track.eta()); - registry.fill(HIST("TrackCuts/TracksBefore/fPhiTrackBefore"), track.phi()); - - if (track.sign() > 0) { - // Fill PID info - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignal"), track.tpcInnerParam(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalP"), track.p(), track.tpcSignal()); - if (isSelectedTrack(track, CFTrigger::kProton)) { - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalALLCUTS"), track.tpcInnerParam(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalALLCUTSP"), track.p(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsPos"), track.p(), track.tpcInnerParam()); - } - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCvsPProtonBefore"), track.tpcInnerParam(), nTPCSigmaP[0]); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTOFvsPProtonBefore"), track.tpcInnerParam(), track.tofNSigmaPr()); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCTOFvsPProtonBefore"), track.tpcInnerParam(), std::sqrt(std::pow(nTPCSigmaP[0] - TPCTOFAvg[0], 2) + std::pow(track.tofNSigmaPr() - TPCTOFAvg[1], 2))); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaITSvsPProtonBefore"), track.p(), track.itsNSigmaPr()); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCvsPDeuteronBefore"), track.tpcInnerParam(), nTPCSigmaP[1]); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTOFvsPDeuteronBefore"), track.tpcInnerParam(), track.tofNSigmaDe()); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCTOFvsPDeuteronBefore"), track.tpcInnerParam(), std::sqrt(std::pow(nTPCSigmaP[1] - TPCTOFAvg[4], 2) + std::pow(track.tofNSigmaDe() - TPCTOFAvg[5], 2))); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaITSvsPDeuteronBefore"), track.p(), track.itsNSigmaDe()); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCvsPDeuteronBeforeP"), track.p(), nTPCSigmaP[1]); - registry.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationPos"), track.p(), track.tpcInnerParam()); + if (checkTrack(track, std::string("Kaon")) && checkTrackPid(track, std::string("Kaon"))) { + vecKaon.emplace_back(track.pt(), track.eta(), track.phi(), o2::constants::physics::MassKaonCharged); + idxKaon.push_back(track.globalIndex()); + + registry.fill(HIST("TrackQA/After/Kaon/fPt"), track.pt()); + registry.fill(HIST("TrackQA/After/Kaon/fPTpc"), track.tpcInnerParam()); + registry.fill(HIST("TrackQA/After/Kaon/fMomCor"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + registry.fill(HIST("TrackQA/After/Kaon/fEta"), track.eta()); + registry.fill(HIST("TrackQA/After/Kaon/fPhi"), track.phi()); + + registry.fill(HIST("TrackQA/After/Kaon/fNsigmaIts"), track.p(), track.itsNSigmaKa()); + registry.fill(HIST("TrackQA/After/Kaon/fNsigmaTpc"), track.p(), track.tpcNSigmaKa()); + registry.fill(HIST("TrackQA/After/Kaon/fNsigmaTof"), track.p(), track.tofNSigmaKa()); + registry.fill(HIST("TrackQA/After/Kaon/fNsigmaTpcTof"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaKa(), track.tofNSigmaKa())); + + registry.fill(HIST("TrackQA/After/Kaon/fItsSignal"), track.p(), itsSignal(track)); + registry.fill(HIST("TrackQA/After/Kaon/fTpcSignal"), track.p(), track.tpcSignal()); + registry.fill(HIST("TrackQA/After/Kaon/fTofBeta"), track.p(), track.beta()); + + registry.fill(HIST("TrackQA/After/Kaon/fDcaXy"), track.pt(), track.dcaXY()); + registry.fill(HIST("TrackQA/After/Kaon/fDcaZ"), track.pt(), track.dcaZ()); + + registry.fill(HIST("TrackQA/After/Kaon/fTpcClusters"), track.tpcNClsFound()); + registry.fill(HIST("TrackQA/After/Kaon/fTpcCrossedRows"), track.tpcNClsCrossedRows()); + registry.fill(HIST("TrackQA/After/Kaon/fTpcSharedClusters"), track.tpcNClsShared()); + registry.fill(HIST("TrackQA/After/Kaon/fTpcSharedClusterOverClusterss"), track.tpcFractionSharedCls()); + registry.fill(HIST("TrackQA/After/Kaon/fTpcFindableOverRows"), track.tpcCrossedRowsOverFindableCls()); + registry.fill(HIST("TrackQA/After/Kaon/fTpcChi2OverCluster"), track.tpcChi2NCl()); + + registry.fill(HIST("TrackQA/After/Kaon/fItsClusters"), track.itsNCls()); + registry.fill(HIST("TrackQA/After/Kaon/fItsIbClusters"), track.itsNClsInnerBarrel()); + registry.fill(HIST("TrackQA/After/Kaon/fItsChi2OverCluster"), track.itsChi2NCl()); } - if (track.sign() < 0) { - - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAnti"), track.tpcInnerParam(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiP"), track.p(), track.tpcSignal()); - if (isSelectedTrack(track, CFTrigger::kProton)) { - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiALLCUTS"), track.tpcInnerParam(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiALLCUTSP"), track.p(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsNeg"), track.p(), track.tpcInnerParam()); - } - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCvsPAntiProtonBefore"), track.tpcInnerParam(), nTPCSigmaN[0]); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTOFvsPAntiProtonBefore"), track.tpcInnerParam(), track.tofNSigmaPr()); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCTOFvsPAntiProtonBefore"), track.tpcInnerParam(), std::sqrt(std::pow(nTPCSigmaN[0] - TPCTOFAvg[2], 2) + std::pow(track.tofNSigmaPr() - TPCTOFAvg[3], 2))); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaITSvsPAntiProtonBefore"), track.p(), track.itsNSigmaPr()); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCvsPAntiDeuteronBefore"), track.tpcInnerParam(), nTPCSigmaN[1]); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTOFvsPAntiDeuteronBefore"), track.tpcInnerParam(), track.tofNSigmaDe()); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCTOFvsPAntiDeuteronBefore"), track.tpcInnerParam(), std::sqrt(std::pow(nTPCSigmaN[1] - TPCTOFAvg[6], 2) + std::pow(track.tofNSigmaDe() - TPCTOFAvg[7], 2))); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaITSvsPAntiDeuteronBefore"), track.p(), track.itsNSigmaDe()); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCvsPAntiDeuteronBeforeP"), track.p(), nTPCSigmaN[1]); - registry.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationNeg"), track.p(), track.tpcInnerParam()); + if (checkTrack(track, std::string("Proton")) && checkTrackPid(track, std::string("Proton"))) { + vecProton.emplace_back(track.pt(), track.eta(), track.phi(), o2::constants::physics::MassProton); + idxProton.push_back(track.globalIndex()); + + registry.fill(HIST("TrackQA/After/Proton/fPt"), track.pt()); + registry.fill(HIST("TrackQA/After/Proton/fPTpc"), track.tpcInnerParam()); + registry.fill(HIST("TrackQA/After/Proton/fMomCor"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + registry.fill(HIST("TrackQA/After/Proton/fEta"), track.eta()); + registry.fill(HIST("TrackQA/After/Proton/fPhi"), track.phi()); + + registry.fill(HIST("TrackQA/After/Proton/fNsigmaIts"), track.p(), track.itsNSigmaPr()); + registry.fill(HIST("TrackQA/After/Proton/fNsigmaTpc"), track.p(), track.tpcNSigmaPr()); + registry.fill(HIST("TrackQA/After/Proton/fNsigmaTof"), track.p(), track.tofNSigmaPr()); + registry.fill(HIST("TrackQA/After/Proton/fNsigmaTpcTof"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaPr(), track.tofNSigmaPr())); + + registry.fill(HIST("TrackQA/After/Proton/fItsSignal"), track.p(), itsSignal(track)); + registry.fill(HIST("TrackQA/After/Proton/fTpcSignal"), track.p(), track.tpcSignal()); + registry.fill(HIST("TrackQA/After/Proton/fTofBeta"), track.p(), track.beta()); + + registry.fill(HIST("TrackQA/After/Proton/fDcaXy"), track.pt(), track.dcaXY()); + registry.fill(HIST("TrackQA/After/Proton/fDcaZ"), track.pt(), track.dcaZ()); + + registry.fill(HIST("TrackQA/After/Proton/fTpcClusters"), track.tpcNClsFound()); + registry.fill(HIST("TrackQA/After/Proton/fTpcCrossedRows"), track.tpcNClsCrossedRows()); + registry.fill(HIST("TrackQA/After/Proton/fTpcSharedClusters"), track.tpcNClsShared()); + registry.fill(HIST("TrackQA/After/Proton/fTpcSharedClusterOverClusterss"), track.tpcFractionSharedCls()); + registry.fill(HIST("TrackQA/After/Proton/fTpcFindableOverRows"), track.tpcCrossedRowsOverFindableCls()); + registry.fill(HIST("TrackQA/After/Proton/fTpcChi2OverCluster"), track.tpcChi2NCl()); + + registry.fill(HIST("TrackQA/After/Proton/fItsClusters"), track.itsNCls()); + registry.fill(HIST("TrackQA/After/Proton/fItsIbClusters"), track.itsNClsInnerBarrel()); + registry.fill(HIST("TrackQA/After/Proton/fItsChi2OverCluster"), track.itsChi2NCl()); } - // get protons - if (isSelectedTrack(track, CFTrigger::kProton)) { - ROOT::Math::PtEtaPhiMVector temp(track.pt(), track.eta(), track.phi(), mMassProton); - if (track.sign() > 0 && isSelectedTrackPID(track, CFTrigger::kProton, false, nTPCSigmaP, 1)) { - protons.push_back(temp); - ProtonIndex.push_back(track.globalIndex()); - - registry.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsProton"), track.p(), track.tpcInnerParam()); - - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalProton"), track.tpcInnerParam(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/Proton/fPProton"), track.p()); - registry.fill(HIST("TrackCuts/Proton/fPTPCProton"), track.tpcInnerParam()); - registry.fill(HIST("TrackCuts/Proton/fPtProton"), track.pt()); - registry.fill(HIST("TrackCuts/Proton/fMomCorProtonDif"), track.p(), track.tpcInnerParam() - track.p()); - registry.fill(HIST("TrackCuts/Proton/fMomCorProtonRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - registry.fill(HIST("TrackCuts/Proton/fEtaProton"), track.eta()); - registry.fill(HIST("TrackCuts/Proton/fPhiProton"), track.phi()); - registry.fill(HIST("TrackCuts/Proton/fNsigmaTPCvsPProton"), track.tpcInnerParam(), nTPCSigmaP[0]); - registry.fill(HIST("TrackCuts/Proton/fNsigmaTOFvsPProton"), track.tpcInnerParam(), track.tofNSigmaPr()); - registry.fill(HIST("TrackCuts/Proton/fNsigmaTPCTOFvsPProton"), track.tpcInnerParam(), std::sqrt(std::pow(nTPCSigmaP[0] - TPCTOFAvg[0], 2) + std::pow(track.tofNSigmaPr() - TPCTOFAvg[1], 2))); - registry.fill(HIST("TrackCuts/Proton/fNsigmaITSvsPProton"), track.p(), track.itsNSigmaPr()); - - registry.fill(HIST("TrackCuts/Proton/fNsigmaTPCvsPProtonP"), track.p(), nTPCSigmaP[0]); - registry.fill(HIST("TrackCuts/Proton/fNsigmaTOFvsPProtonP"), track.p(), track.tofNSigmaPr()); - registry.fill(HIST("TrackCuts/Proton/fNsigmaTPCTOFvsPProtonP"), track.p(), std::sqrt(std::pow(nTPCSigmaP[0] - TPCTOFAvg[0], 2) + std::pow(track.tofNSigmaPr() - TPCTOFAvg[1], 2))); - - registry.fill(HIST("TrackCuts/Proton/fDCAxyProton"), track.dcaXY()); - registry.fill(HIST("TrackCuts/Proton/fDCAzProton"), track.dcaZ()); - registry.fill(HIST("TrackCuts/Proton/fTPCsClsProton"), track.tpcNClsShared()); - registry.fill(HIST("TrackCuts/Proton/fTPCcRowsProton"), track.tpcNClsCrossedRows()); - registry.fill(HIST("TrackCuts/Proton/fTrkTPCfClsProton"), track.tpcCrossedRowsOverFindableCls()); - registry.fill(HIST("TrackCuts/Proton/fTPCnclsProton"), track.tpcNClsFound()); - } - if (track.sign() < 0 && isSelectedTrackPID(track, CFTrigger::kProton, false, nTPCSigmaN, -1)) { - antiprotons.push_back(temp); - AntiProtonIndex.push_back(track.globalIndex()); - - registry.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiProton"), track.p(), track.tpcInnerParam()); - - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiProton"), track.tpcInnerParam(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/AntiProton/fPtAntiProton"), track.pt()); - registry.fill(HIST("TrackCuts/AntiProton/fMomCorAntiProtonDif"), track.p(), track.tpcInnerParam() - track.p()); - registry.fill(HIST("TrackCuts/AntiProton/fMomCorAntiProtonRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - registry.fill(HIST("TrackCuts/AntiProton/fEtaAntiProton"), track.eta()); - registry.fill(HIST("TrackCuts/AntiProton/fPhiAntiProton"), track.phi()); - registry.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCvsPAntiProton"), track.tpcInnerParam(), nTPCSigmaN[0]); - registry.fill(HIST("TrackCuts/AntiProton/fNsigmaTOFvsPAntiProton"), track.tpcInnerParam(), track.tofNSigmaPr()); - registry.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCTOFvsPAntiProton"), track.tpcInnerParam(), std::sqrt(std::pow(nTPCSigmaN[0] - TPCTOFAvg[2], 2) + std::pow(track.tofNSigmaPr() - TPCTOFAvg[3], 2))); - registry.fill(HIST("TrackCuts/AntiProton/fNsigmaITSvsPAntiProton"), track.p(), track.itsNSigmaPr()); - - registry.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCvsPAntiProtonP"), track.p(), nTPCSigmaN[0]); - registry.fill(HIST("TrackCuts/AntiProton/fNsigmaTOFvsPAntiProtonP"), track.p(), track.tofNSigmaPr()); - registry.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCTOFvsPAntiProtonP"), track.p(), std::sqrt(std::pow(nTPCSigmaN[0] - TPCTOFAvg[2], 2) + std::pow(track.tofNSigmaPr() - TPCTOFAvg[3], 2))); - - registry.fill(HIST("TrackCuts/AntiProton/fDCAxyAntiProton"), track.dcaXY()); - registry.fill(HIST("TrackCuts/AntiProton/fDCAzAntiProton"), track.dcaZ()); - registry.fill(HIST("TrackCuts/AntiProton/fTPCsClsAntiProton"), track.tpcNClsShared()); - registry.fill(HIST("TrackCuts/AntiProton/fTPCcRowsAntiProton"), track.tpcNClsCrossedRows()); - registry.fill(HIST("TrackCuts/AntiProton/fTrkTPCfClsAntiProton"), track.tpcCrossedRowsOverFindableCls()); - registry.fill(HIST("TrackCuts/AntiProton/fTPCnclsAntiProton"), track.tpcNClsFound()); - } - } - // get deuterons - if (isSelectedTrack(track, CFTrigger::kDeuteron)) { - ROOT::Math::PtEtaPhiMVector temp(track.pt(), track.eta(), track.phi(), mMassDeuteron); - if (track.sign() > 0 && isSelectedTrackPID(track, CFTrigger::kDeuteron, ConfRejectNOTDeuteron.value, nTPCSigmaP, 1)) { - deuterons.push_back(temp); - - registry.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsDeuteron"), track.p(), track.tpcInnerParam()); - - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalDeuteron"), track.tpcInnerParam(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/Deuteron/fPtDeuteron"), track.pt()); - registry.fill(HIST("TrackCuts/Deuteron/fMomCorDeuteronDif"), track.p(), track.tpcInnerParam() - track.p()); - registry.fill(HIST("TrackCuts/Deuteron/fMomCorDeuteronRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - registry.fill(HIST("TrackCuts/Deuteron/fEtaDeuteron"), track.eta()); - registry.fill(HIST("TrackCuts/Deuteron/fPhiDeuteron"), track.phi()); - registry.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCvsPDeuteron"), track.tpcInnerParam(), nTPCSigmaP[1]); - registry.fill(HIST("TrackCuts/Deuteron/fNsigmaTOFvsPDeuteron"), track.tpcInnerParam(), track.tofNSigmaDe()); - registry.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCTOFvsPDeuteron"), track.tpcInnerParam(), std::sqrt(std::pow(nTPCSigmaP[1] - TPCTOFAvg[4], 2) + std::pow(track.tofNSigmaDe() - TPCTOFAvg[5], 2))); - registry.fill(HIST("TrackCuts/Deuteron/fNsigmaITSvsPDeuteron"), track.p(), track.itsNSigmaDe()); - - registry.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCvsPDeuteronP"), track.p(), nTPCSigmaP[1]); - registry.fill(HIST("TrackCuts/Deuteron/fNsigmaTOFvsPDeuteronP"), track.p(), track.tofNSigmaDe()); - registry.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCTOFvsPDeuteronP"), track.p(), std::sqrt(std::pow(nTPCSigmaP[1] - TPCTOFAvg[4], 2) + std::pow(track.tofNSigmaDe() - TPCTOFAvg[5], 2))); - - registry.fill(HIST("TrackCuts/Deuteron/fDCAxyDeuteron"), track.dcaXY()); - registry.fill(HIST("TrackCuts/Deuteron/fDCAzDeuteron"), track.dcaZ()); - registry.fill(HIST("TrackCuts/Deuteron/fTPCsClsDeuteron"), track.tpcNClsShared()); - registry.fill(HIST("TrackCuts/Deuteron/fTPCcRowsDeuteron"), track.tpcNClsCrossedRows()); - registry.fill(HIST("TrackCuts/Deuteron/fTrkTPCfClsDeuteron"), track.tpcCrossedRowsOverFindableCls()); - registry.fill(HIST("TrackCuts/Deuteron/fTPCnclsDeuteron"), track.tpcNClsFound()); - } - if (track.sign() < 0 && isSelectedTrackPID(track, CFTrigger::kDeuteron, ConfRejectNOTDeuteron.value, nTPCSigmaN, -1)) { - antideuterons.push_back(temp); - - registry.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiDeuteron"), track.p(), track.tpcInnerParam()); - - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiDeuteron"), track.tpcInnerParam(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fPtAntiDeuteron"), track.pt()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fMomCorAntiDeuteronDif"), track.p(), track.tpcInnerParam() - track.p()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fMomCorAntiDeuteronRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fEtaAntiDeuteron"), track.eta()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fPhiAntiDeuteron"), track.phi()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCvsPAntiDeuteron"), track.tpcInnerParam(), nTPCSigmaN[1]); - registry.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTOFvsPAntiDeuteron"), track.tpcInnerParam(), track.tofNSigmaDe()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCTOFvsPAntiDeuteron"), track.tpcInnerParam(), std::sqrt(std::pow(nTPCSigmaN[1] - TPCTOFAvg[6], 2) + std::pow(track.tofNSigmaDe() - TPCTOFAvg[7], 2))); - registry.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaITSvsPAntiDeuteron"), track.p(), track.itsNSigmaDe()); - - registry.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCvsPAntiDeuteronP"), track.p(), nTPCSigmaN[1]); - registry.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTOFvsPAntiDeuteronP"), track.p(), track.tofNSigmaDe()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCTOFvsPAntiDeuteronP"), track.p(), std::sqrt(std::pow(nTPCSigmaN[1] - TPCTOFAvg[6], 2) + std::pow(track.tofNSigmaDe() - TPCTOFAvg[7], 2))); - - registry.fill(HIST("TrackCuts/AntiDeuteron/fDCAxyAntiDeuteron"), track.dcaXY()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fDCAzAntiDeuteron"), track.dcaZ()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fTPCsClsAntiDeuteron"), track.tpcNClsShared()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fTPCcRowsAntiDeuteron"), track.tpcNClsCrossedRows()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fTrkTPCfClsAntiDeuteron"), track.tpcCrossedRowsOverFindableCls()); - registry.fill(HIST("TrackCuts/AntiDeuteron/fTPCnclsAntiDeuteron"), track.tpcNClsFound()); - } - } - // get Kaons (Phi Daughters) - if (ConfTriggerSwitches->get("Switch", "ppPhi") > 0.) { - if (isSelectedTrackKaon(track)) { - ROOT::Math::PtEtaPhiMVector temp(track.pt(), track.eta(), track.phi(), mMassKaonPlus); - if (track.sign() > 0) { - temp.SetM(mMassKaonPlus); - kaons.push_back(temp); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fP"), track.p()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fPTPC"), track.tpcInnerParam()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fPt"), track.pt()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fMomCorDif"), track.p(), track.tpcInnerParam() - track.p()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fMomCorRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fEta"), track.eta()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fPhi"), track.phi()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fNsigmaTPCvsP"), track.tpcInnerParam(), track.tpcNSigmaKa()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fNsigmaTOFvsP"), track.tpcInnerParam(), track.tofNSigmaKa()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fNsigmaTPCTOFvsP"), track.tpcInnerParam(), std::abs(std::sqrt(track.tpcNSigmaKa() * track.tpcNSigmaKa() + track.tofNSigmaKa() * track.tofNSigmaKa()))); - - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fDCAxy"), track.dcaXY()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fDCAz"), track.dcaZ()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fTPCsCls"), track.tpcNClsShared()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fTPCcRows"), track.tpcNClsCrossedRows()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fTrkTPCfCls"), track.tpcCrossedRowsOverFindableCls()); - registry.fill(HIST("TrackCuts/Phi/Before/PosDaughter/fTPCncls"), track.tpcNClsFound()); - } - if (track.sign() < 0) { - temp.SetM(mMassKaonMinus); - antikaons.push_back(temp); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fP"), track.p()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fPTPC"), track.tpcInnerParam()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fPt"), track.pt()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fMomCorDif"), track.p(), track.tpcInnerParam() - track.p()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fMomCorRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fEta"), track.eta()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fPhi"), track.phi()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fNsigmaTPCvsP"), track.tpcInnerParam(), track.tpcNSigmaKa()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fNsigmaTOFvsP"), track.tpcInnerParam(), track.tofNSigmaKa()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fNsigmaTPCTOFvsP"), track.tpcInnerParam(), std::abs(std::sqrt(track.tpcNSigmaKa() * track.tpcNSigmaKa() + track.tofNSigmaKa() * track.tofNSigmaKa()))); - - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fDCAxy"), track.dcaXY()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fDCAz"), track.dcaZ()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fTPCsCls"), track.tpcNClsShared()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fTPCcRows"), track.tpcNClsCrossedRows()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fTrkTPCfCls"), track.tpcCrossedRowsOverFindableCls()); - registry.fill(HIST("TrackCuts/Phi/Before/NegDaughter/fTPCncls"), track.tpcNClsFound()); - } - } - } - // get pions - if (isSelectedTrack(track, CFTrigger::kPion)) { - ROOT::Math::PtEtaPhiMVector temp(track.pt(), track.eta(), track.phi(), mMassPion); - if (track.sign() > 0 && isSelectedTrackPID(track, CFTrigger::kPion, false, nTPCSigmaP, 1)) { - pions.push_back(temp); - - registry.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsPion"), track.p(), track.tpcInnerParam()); - - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalPion"), track.tpcInnerParam(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/Pion/fPPion"), track.p()); - registry.fill(HIST("TrackCuts/Pion/fPTPCPion"), track.tpcInnerParam()); - registry.fill(HIST("TrackCuts/Pion/fPtPion"), track.pt()); - registry.fill(HIST("TrackCuts/Pion/fMomCorPionDif"), track.p(), track.tpcInnerParam() - track.p()); - registry.fill(HIST("TrackCuts/Pion/fMomCorPionRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - registry.fill(HIST("TrackCuts/Pion/fEtaPion"), track.eta()); - registry.fill(HIST("TrackCuts/Pion/fPhiPion"), track.phi()); - registry.fill(HIST("TrackCuts/Pion/fNsigmaTPCvsPPion"), track.tpcInnerParam(), nTPCSigmaP[2]); - registry.fill(HIST("TrackCuts/Pion/fNsigmaTOFvsPPion"), track.tpcInnerParam(), track.tofNSigmaPi()); - registry.fill(HIST("TrackCuts/Pion/fNsigmaTPCTOFvsPPion"), track.tpcInnerParam(), std::sqrt(std::pow(nTPCSigmaP[2] - TPCTOFAvg[8], 2) + std::pow(track.tofNSigmaPi() - TPCTOFAvg[9], 2))); - - registry.fill(HIST("TrackCuts/Pion/fNsigmaTPCvsPPionP"), track.p(), nTPCSigmaP[2]); - registry.fill(HIST("TrackCuts/Pion/fNsigmaTOFvsPPionP"), track.p(), track.tofNSigmaPi()); - registry.fill(HIST("TrackCuts/Pion/fNsigmaTPCTOFvsPPionP"), track.p(), std::sqrt(std::pow(nTPCSigmaP[2] - TPCTOFAvg[8], 2) + std::pow(track.tofNSigmaPi() - TPCTOFAvg[9], 2))); - - registry.fill(HIST("TrackCuts/Pion/fDCAxyPion"), track.dcaXY()); - registry.fill(HIST("TrackCuts/Pion/fDCAzPion"), track.dcaZ()); - registry.fill(HIST("TrackCuts/Pion/fTPCsClsPion"), track.tpcNClsShared()); - registry.fill(HIST("TrackCuts/Pion/fTPCcRowsPion"), track.tpcNClsCrossedRows()); - registry.fill(HIST("TrackCuts/Pion/fTrkTPCfClsPion"), track.tpcCrossedRowsOverFindableCls()); - registry.fill(HIST("TrackCuts/Pion/fTPCnclsPion"), track.tpcNClsFound()); - } - if (track.sign() < 0 && isSelectedTrackPID(track, CFTrigger::kPion, false, nTPCSigmaN, -1)) { - antipions.push_back(temp); - - registry.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiPion"), track.p(), track.tpcInnerParam()); - - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiPion"), track.tpcInnerParam(), track.tpcSignal()); - registry.fill(HIST("TrackCuts/AntiPion/fPtAntiPion"), track.pt()); - registry.fill(HIST("TrackCuts/AntiPion/fMomCorAntiPionDif"), track.p(), track.tpcInnerParam() - track.p()); - registry.fill(HIST("TrackCuts/AntiPion/fMomCorAntiPionRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - registry.fill(HIST("TrackCuts/AntiPion/fEtaAntiPion"), track.eta()); - registry.fill(HIST("TrackCuts/AntiPion/fPhiAntiPion"), track.phi()); - registry.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPion"), track.tpcInnerParam(), nTPCSigmaN[2]); - registry.fill(HIST("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPion"), track.tpcInnerParam(), track.tofNSigmaPi()); - registry.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPion"), track.tpcInnerParam(), std::sqrt(std::pow(nTPCSigmaN[2] - TPCTOFAvg[10], 2) + std::pow(track.tofNSigmaPi() - TPCTOFAvg[11], 2))); - - registry.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPionP"), track.p(), nTPCSigmaN[2]); - registry.fill(HIST("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPionP"), track.p(), track.tofNSigmaPi()); - registry.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPionP"), track.p(), std::sqrt(std::pow(nTPCSigmaN[2] - TPCTOFAvg[10], 2) + std::pow(track.tofNSigmaPi() - TPCTOFAvg[11], 2))); - - registry.fill(HIST("TrackCuts/AntiPion/fDCAxyAntiPion"), track.dcaXY()); - registry.fill(HIST("TrackCuts/AntiPion/fDCAzAntiPion"), track.dcaZ()); - registry.fill(HIST("TrackCuts/AntiPion/fTPCsClsAntiPion"), track.tpcNClsShared()); - registry.fill(HIST("TrackCuts/AntiPion/fTPCcRowsAntiPion"), track.tpcNClsCrossedRows()); - registry.fill(HIST("TrackCuts/AntiPion/fTrkTPCfClsAntiPion"), track.tpcCrossedRowsOverFindableCls()); - registry.fill(HIST("TrackCuts/AntiPion/fTPCnclsAntiPion"), track.tpcNClsFound()); - } + if (checkTrack(track, std::string("Deuteron")) && checkTrackPid(track, std::string("Deuteron"))) { + vecDeuteron.emplace_back(track.pt(), track.eta(), track.phi(), o2::constants::physics::MassDeuteron); + idxDeuteron.push_back(track.globalIndex()); + + registry.fill(HIST("TrackQA/After/Deuteron/fPt"), track.pt()); + registry.fill(HIST("TrackQA/After/Deuteron/fPTpc"), track.tpcInnerParam()); + registry.fill(HIST("TrackQA/After/Deuteron/fMomCor"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + registry.fill(HIST("TrackQA/After/Deuteron/fEta"), track.eta()); + registry.fill(HIST("TrackQA/After/Deuteron/fPhi"), track.phi()); + + registry.fill(HIST("TrackQA/After/Deuteron/fNsigmaIts"), track.p(), track.itsNSigmaDe()); + registry.fill(HIST("TrackQA/After/Deuteron/fNsigmaTpc"), track.p(), track.tpcNSigmaDe()); + registry.fill(HIST("TrackQA/After/Deuteron/fNsigmaTof"), track.p(), track.tofNSigmaDe()); + registry.fill(HIST("TrackQA/After/Deuteron/fNsigmaTpcTof"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaDe(), track.tofNSigmaDe())); + + registry.fill(HIST("TrackQA/After/Deuteron/fItsSignal"), track.p(), itsSignal(track)); + registry.fill(HIST("TrackQA/After/Deuteron/fTpcSignal"), track.p(), track.tpcSignal()); + registry.fill(HIST("TrackQA/After/Deuteron/fTofBeta"), track.p(), track.beta()); + + registry.fill(HIST("TrackQA/After/Deuteron/fDcaXy"), track.pt(), track.dcaXY()); + registry.fill(HIST("TrackQA/After/Deuteron/fDcaZ"), track.pt(), track.dcaZ()); + + registry.fill(HIST("TrackQA/After/Deuteron/fTpcClusters"), track.tpcNClsFound()); + registry.fill(HIST("TrackQA/After/Deuteron/fTpcCrossedRows"), track.tpcNClsCrossedRows()); + registry.fill(HIST("TrackQA/After/Deuteron/fTpcSharedClusters"), track.tpcNClsShared()); + registry.fill(HIST("TrackQA/After/Deuteron/fTpcSharedClusterOverClusterss"), track.tpcFractionSharedCls()); + registry.fill(HIST("TrackQA/After/Deuteron/fTpcFindableOverRows"), track.tpcCrossedRowsOverFindableCls()); + registry.fill(HIST("TrackQA/After/Deuteron/fTpcChi2OverCluster"), track.tpcChi2NCl()); + + registry.fill(HIST("TrackQA/After/Deuteron/fItsClusters"), track.itsNCls()); + registry.fill(HIST("TrackQA/After/Deuteron/fItsIbClusters"), track.itsNClsInnerBarrel()); + registry.fill(HIST("TrackQA/After/Deuteron/fItsChi2OverCluster"), track.itsChi2NCl()); } } - // keep track of daugher indices to avoid selfcorrelations - std::vector LambdaPosDaughIndex = {}; - std::vector LambdaNegDaughIndex = {}; - std::vector AntiLambdaPosDaughIndex = {}; - std::vector AntiLambdaNegDaughIndex = {}; - - for (auto& v0 : fullV0s) { - - auto postrack = v0.template posTrack_as(); - auto negtrack = v0.template negTrack_as(); - double nTPCSigmaPos[2]{postrack.tpcNSigmaPr(), postrack.tpcNSigmaPi()}; - double nTPCSigmaNeg[2]{negtrack.tpcNSigmaPr(), negtrack.tpcNSigmaPi()}; - if (ConfUseManualPIDdaughterPion) { - auto bgScalingPion = 1 / mMassPion; // momentum scaling? - if (BBPion.size() == 6) - nTPCSigmaPos[1] = updatePID(postrack, bgScalingPion, BBPion); - if (BBAntipion.size() == 6) - nTPCSigmaNeg[1] = updatePID(negtrack, bgScalingPion, BBAntipion); + if (track.sign() < 0) { + registry.fill(HIST("TrackQA/Before/AntiParticle/fPt"), track.pt()); + registry.fill(HIST("TrackQA/Before/AntiParticle/fEta"), track.eta()); + registry.fill(HIST("TrackQA/Before/AntiParticle/fPhi"), track.phi()); + registry.fill(HIST("TrackQA/Before/AntiParticle/fMomCor"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + registry.fill(HIST("TrackQA/Before/AntiParticle/fItsSignal"), track.p(), itsSignal(track)); + registry.fill(HIST("TrackQA/Before/AntiParticle/fTpcSignal"), track.p(), track.tpcSignal()); + registry.fill(HIST("TrackQA/Before/AntiParticle/fTofSignal"), track.p(), track.beta()); + + registry.fill(HIST("TrackQA/Before/AntiPion/fNsigmaITS"), track.p(), track.itsNSigmaPi()); + registry.fill(HIST("TrackQA/Before/AntiPion/fNsigmaTPC"), track.p(), track.tpcNSigmaPi()); + registry.fill(HIST("TrackQA/Before/AntiPion/fNsigmaTOF"), track.p(), track.tofNSigmaPi()); + registry.fill(HIST("TrackQA/Before/AntiPion/fNsigmaTPCTOF"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaPi(), track.tofNSigmaPi())); + + registry.fill(HIST("TrackQA/Before/AntiKaon/fNsigmaITS"), track.p(), track.itsNSigmaKa()); + registry.fill(HIST("TrackQA/Before/AntiKaon/fNsigmaTPC"), track.p(), track.tpcNSigmaKa()); + registry.fill(HIST("TrackQA/Before/AntiKaon/fNsigmaTOF"), track.p(), track.tofNSigmaKa()); + registry.fill(HIST("TrackQA/Before/AntiKaon/fNsigmaTPCTOF"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaKa(), track.tofNSigmaKa())); + + registry.fill(HIST("TrackQA/Before/AntiProton/fNsigmaITS"), track.p(), track.itsNSigmaPr()); + registry.fill(HIST("TrackQA/Before/AntiProton/fNsigmaTPC"), track.p(), track.tpcNSigmaPr()); + registry.fill(HIST("TrackQA/Before/AntiProton/fNsigmaTOF"), track.p(), track.tofNSigmaPr()); + registry.fill(HIST("TrackQA/Before/AntiProton/fNsigmaTPCTOF"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaPr(), track.tofNSigmaPr())); + + registry.fill(HIST("TrackQA/Before/AntiDeuteron/fNsigmaITS"), track.p(), track.itsNSigmaDe()); + registry.fill(HIST("TrackQA/Before/AntiDeuteron/fNsigmaTPC"), track.p(), track.tpcNSigmaDe()); + registry.fill(HIST("TrackQA/Before/AntiDeuteron/fNsigmaTOF"), track.p(), track.tofNSigmaDe()); + registry.fill(HIST("TrackQA/Before/AntiDeuteron/fNsigmaTPCTOF"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaDe(), track.tofNSigmaDe())); + + if (checkTrack(track, std::string("Pion")) && checkTrackPid(track, std::string("Pion"))) { + vecAntiPion.emplace_back(track.pt(), track.eta(), track.phi(), o2::constants::physics::MassPionCharged); + idxAntiPion.push_back(track.globalIndex()); + + registry.fill(HIST("TrackQA/After/AntiPion/fPt"), track.pt()); + registry.fill(HIST("TrackQA/After/AntiPion/fPTpc"), track.tpcInnerParam()); + registry.fill(HIST("TrackQA/After/AntiPion/fMomCor"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + registry.fill(HIST("TrackQA/After/AntiPion/fEta"), track.eta()); + registry.fill(HIST("TrackQA/After/AntiPion/fPhi"), track.phi()); + + registry.fill(HIST("TrackQA/After/AntiPion/fNsigmaIts"), track.p(), track.itsNSigmaPi()); + registry.fill(HIST("TrackQA/After/AntiPion/fNsigmaTpc"), track.p(), track.tpcNSigmaPi()); + registry.fill(HIST("TrackQA/After/AntiPion/fNsigmaTof"), track.p(), track.tofNSigmaPi()); + registry.fill(HIST("TrackQA/After/AntiPion/fNsigmaTpcTof"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaPi(), track.tofNSigmaPi())); + + registry.fill(HIST("TrackQA/After/AntiPion/fItsSignal"), track.p(), itsSignal(track)); + registry.fill(HIST("TrackQA/After/AntiPion/fTpcSignal"), track.p(), track.tpcSignal()); + registry.fill(HIST("TrackQA/After/AntiPion/fTofBeta"), track.p(), track.beta()); + + registry.fill(HIST("TrackQA/After/AntiPion/fDcaXy"), track.pt(), track.dcaXY()); + registry.fill(HIST("TrackQA/After/AntiPion/fDcaZ"), track.pt(), track.dcaZ()); + + registry.fill(HIST("TrackQA/After/AntiPion/fTpcClusters"), track.tpcNClsFound()); + registry.fill(HIST("TrackQA/After/AntiPion/fTpcCrossedRows"), track.tpcNClsCrossedRows()); + registry.fill(HIST("TrackQA/After/AntiPion/fTpcSharedClusters"), track.tpcNClsShared()); + registry.fill(HIST("TrackQA/After/AntiPion/fTpcSharedClusterOverClusterss"), track.tpcFractionSharedCls()); + registry.fill(HIST("TrackQA/After/AntiPion/fTpcFindableOverRows"), track.tpcCrossedRowsOverFindableCls()); + registry.fill(HIST("TrackQA/After/AntiPion/fTpcChi2OverCluster"), track.tpcChi2NCl()); + + registry.fill(HIST("TrackQA/After/AntiPion/fItsClusters"), track.itsNCls()); + registry.fill(HIST("TrackQA/After/AntiPion/fItsIbClusters"), track.itsNClsInnerBarrel()); + registry.fill(HIST("TrackQA/After/AntiPion/fItsChi2OverCluster"), track.itsChi2NCl()); } - if (ConfUseManualPIDdaughterProton) { - auto bgScalingProton = 1 / mMassProton; // momentum scaling? - if (BBProton.size() == 6) - nTPCSigmaPos[0] = updatePID(postrack, bgScalingProton, BBProton); - if (BBAntiproton.size() == 6) - nTPCSigmaNeg[0] = updatePID(negtrack, bgScalingProton, BBAntiproton); + + if (checkTrack(track, std::string("Kaon")) && checkTrackPid(track, std::string("Kaon"))) { + vecAntiKaon.emplace_back(track.pt(), track.eta(), track.phi(), o2::constants::physics::MassKaonCharged); + idxAntiKaon.push_back(track.globalIndex()); + + registry.fill(HIST("TrackQA/After/AntiKaon/fPt"), track.pt()); + registry.fill(HIST("TrackQA/After/AntiKaon/fPTpc"), track.tpcInnerParam()); + registry.fill(HIST("TrackQA/After/AntiKaon/fMomCor"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + registry.fill(HIST("TrackQA/After/AntiKaon/fEta"), track.eta()); + registry.fill(HIST("TrackQA/After/AntiKaon/fPhi"), track.phi()); + + registry.fill(HIST("TrackQA/After/AntiKaon/fNsigmaIts"), track.p(), track.itsNSigmaKa()); + registry.fill(HIST("TrackQA/After/AntiKaon/fNsigmaTpc"), track.p(), track.tpcNSigmaKa()); + registry.fill(HIST("TrackQA/After/AntiKaon/fNsigmaTof"), track.p(), track.tofNSigmaKa()); + registry.fill(HIST("TrackQA/After/AntiKaon/fNsigmaTpcTof"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaKa(), track.tofNSigmaKa())); + + registry.fill(HIST("TrackQA/After/AntiKaon/fItsSignal"), track.p(), itsSignal(track)); + registry.fill(HIST("TrackQA/After/AntiKaon/fTpcSignal"), track.p(), track.tpcSignal()); + registry.fill(HIST("TrackQA/After/AntiKaon/fTofBeta"), track.p(), track.beta()); + + registry.fill(HIST("TrackQA/After/AntiKaon/fDcaXy"), track.pt(), track.dcaXY()); + registry.fill(HIST("TrackQA/After/AntiKaon/fDcaZ"), track.pt(), track.dcaZ()); + + registry.fill(HIST("TrackQA/After/AntiKaon/fTpcClusters"), track.tpcNClsFound()); + registry.fill(HIST("TrackQA/After/AntiKaon/fTpcCrossedRows"), track.tpcNClsCrossedRows()); + registry.fill(HIST("TrackQA/After/AntiKaon/fTpcSharedClusters"), track.tpcNClsShared()); + registry.fill(HIST("TrackQA/After/AntiKaon/fTpcSharedClusterOverClusterss"), track.tpcFractionSharedCls()); + registry.fill(HIST("TrackQA/After/AntiKaon/fTpcFindableOverRows"), track.tpcCrossedRowsOverFindableCls()); + registry.fill(HIST("TrackQA/After/AntiKaon/fTpcChi2OverCluster"), track.tpcChi2NCl()); + + registry.fill(HIST("TrackQA/After/AntiKaon/fItsClusters"), track.itsNCls()); + registry.fill(HIST("TrackQA/After/AntiKaon/fItsIbClusters"), track.itsNClsInnerBarrel()); + registry.fill(HIST("TrackQA/After/AntiKaon/fItsChi2OverCluster"), track.itsChi2NCl()); } - registry.fill(HIST("TrackCuts/V0Before/fPtLambdaBefore"), v0.pt()); - registry.fill(HIST("TrackCuts/V0Before/fInvMassLambdaBefore"), v0.mLambda()); - registry.fill(HIST("TrackCuts/V0Before/fInvMassAntiLambdaBefore"), v0.mAntiLambda()); - registry.fill(HIST("TrackCuts/V0Before/fInvMassLambdavsAntiLambda"), v0.mLambda(), v0.mAntiLambda()); - registry.fill(HIST("TrackCuts/V0Before/fInvMassV0BeforeKaonvsV0Before"), v0.mK0Short(), v0.mLambda()); - registry.fill(HIST("TrackCuts/V0Before/fV0DCADaugh"), v0.dcaV0daughters()); - registry.fill(HIST("TrackCuts/V0Before/fV0CPA"), v0.v0cosPA()); - registry.fill(HIST("TrackCuts/V0Before/fV0TranRad"), v0.v0radius()); - registry.fill(HIST("TrackCuts/V0Before/f0DecVtxX"), v0.x()); - registry.fill(HIST("TrackCuts/V0Before/f0DecVtxY"), v0.y()); - registry.fill(HIST("TrackCuts/V0Before/f0DecVtxZ"), v0.z()); - - registry.fill(HIST("TrackCuts/V0Before/PosDaughter/Eta"), postrack.eta()); - registry.fill(HIST("TrackCuts/V0Before/PosDaughter/DCAXY"), postrack.dcaXY()); - registry.fill(HIST("TrackCuts/V0Before/PosDaughter/fTPCncls"), postrack.tpcNClsFound()); - registry.fill(HIST("TrackCuts/V0Before/NegDaughter/Eta"), negtrack.eta()); - registry.fill(HIST("TrackCuts/V0Before/NegDaughter/DCAXY"), negtrack.dcaXY()); - registry.fill(HIST("TrackCuts/V0Before/NegDaughter/fTPCncls"), negtrack.tpcNClsFound()); - registry.fill(HIST("TrackCuts/V0Before/PosDaughter/fNsigmaTPCvsPProtonV0Daugh"), postrack.tpcInnerParam(), nTPCSigmaPos[0]); - registry.fill(HIST("TrackCuts/V0Before/NegDaughter/fNsigmaTPCvsPPionMinusV0Daugh"), negtrack.tpcInnerParam(), nTPCSigmaNeg[1]); - registry.fill(HIST("TrackCuts/V0Before/NegDaughter/fNsigmaTPCvsPAntiProtonV0Daugh"), negtrack.tpcInnerParam(), nTPCSigmaNeg[0]); - registry.fill(HIST("TrackCuts/V0Before/PosDaughter/fNsigmaTPCvsPPionPlusV0Daugh"), postrack.tpcInnerParam(), nTPCSigmaPos[1]); - - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCvsPProtonV0DaughBefore"), postrack.tpcInnerParam(), nTPCSigmaPos[0]); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCvsPPionPlusAntiV0DaughBefore"), postrack.tpcInnerParam(), nTPCSigmaNeg[1]); - - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCvsPPionMinusV0DaughBefore"), negtrack.tpcInnerParam(), nTPCSigmaNeg[1]); - registry.fill(HIST("TrackCuts/NSigmaBefore/fNsigmaTPCvsPAntiProtonAntiV0DaughBefore"), negtrack.tpcInnerParam(), nTPCSigmaNeg[0]); - - if (isSelectedMinimalV0(col, v0, postrack, negtrack, 1, nTPCSigmaPos, nTPCSigmaNeg)) { - ROOT::Math::PtEtaPhiMVector temp(v0.pt(), v0.eta(), v0.phi(), mMassLambda); - lambdas.push_back(temp); - LambdaPosDaughIndex.push_back(postrack.globalIndex()); - LambdaNegDaughIndex.push_back(negtrack.globalIndex()); - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalProtonPlusV0Daughter"), postrack.tpcInnerParam(), postrack.tpcSignal()); - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalPionMinusV0Daughter"), negtrack.tpcInnerParam(), negtrack.tpcSignal()); - registry.fill(HIST("TrackCuts/Lambda/fPtLambda"), v0.pt()); - registry.fill(HIST("TrackCuts/Lambda/fInvMassLambda"), v0.mLambda()); - registry.fill(HIST("TrackCuts/Lambda/fInvMassLambdaKaonvsLambda"), v0.mK0Short(), v0.mLambda()); - registry.fill(HIST("TrackCuts/Lambda/fV0DCADaugh"), v0.dcaV0daughters()); - registry.fill(HIST("TrackCuts/Lambda/fV0CPA"), v0.v0cosPA()); - registry.fill(HIST("TrackCuts/Lambda/fV0TranRad"), v0.v0radius()); - registry.fill(HIST("TrackCuts/Lambda/f0DecVtxX"), v0.x()); - registry.fill(HIST("TrackCuts/Lambda/f0DecVtxY"), v0.y()); - registry.fill(HIST("TrackCuts/Lambda/f0DecVtxZ"), v0.z()); - - registry.fill(HIST("TrackCuts/Lambda/PosDaughter/Eta"), postrack.eta()); - registry.fill(HIST("TrackCuts/Lambda/PosDaughter/DCAXY"), postrack.dcaXY()); - registry.fill(HIST("TrackCuts/Lambda/PosDaughter/fTPCncls"), postrack.tpcNClsFound()); - registry.fill(HIST("TrackCuts/Lambda/NegDaughter/Eta"), negtrack.eta()); - registry.fill(HIST("TrackCuts/Lambda/NegDaughter/DCAXY"), negtrack.dcaXY()); - registry.fill(HIST("TrackCuts/Lambda/NegDaughter/fTPCncls"), negtrack.tpcNClsFound()); - registry.fill(HIST("TrackCuts/Lambda/PosDaughter/fNsigmaTPCvsPProtonV0Daugh"), postrack.tpcInnerParam(), nTPCSigmaPos[0]); - registry.fill(HIST("TrackCuts/Lambda/NegDaughter/fNsigmaTPCvsPPionMinusV0Daugh"), negtrack.tpcInnerParam(), nTPCSigmaNeg[1]); + + if (checkTrack(track, std::string("Proton")) && checkTrackPid(track, std::string("Proton"))) { + vecAntiProton.emplace_back(track.pt(), track.eta(), track.phi(), o2::constants::physics::MassProton); + idxAntiProton.push_back(track.globalIndex()); + + registry.fill(HIST("TrackQA/After/AntiProton/fPt"), track.pt()); + registry.fill(HIST("TrackQA/After/AntiProton/fPTpc"), track.tpcInnerParam()); + registry.fill(HIST("TrackQA/After/AntiProton/fMomCor"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + registry.fill(HIST("TrackQA/After/AntiProton/fEta"), track.eta()); + registry.fill(HIST("TrackQA/After/AntiProton/fPhi"), track.phi()); + + registry.fill(HIST("TrackQA/After/AntiProton/fNsigmaIts"), track.p(), track.itsNSigmaPr()); + registry.fill(HIST("TrackQA/After/AntiProton/fNsigmaTpc"), track.p(), track.tpcNSigmaPr()); + registry.fill(HIST("TrackQA/After/AntiProton/fNsigmaTof"), track.p(), track.tofNSigmaPr()); + registry.fill(HIST("TrackQA/After/AntiProton/fNsigmaTpcTof"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaPr(), track.tofNSigmaPr())); + + registry.fill(HIST("TrackQA/After/AntiProton/fItsSignal"), track.p(), itsSignal(track)); + registry.fill(HIST("TrackQA/After/AntiProton/fTpcSignal"), track.p(), track.tpcSignal()); + registry.fill(HIST("TrackQA/After/AntiProton/fTofBeta"), track.p(), track.beta()); + + registry.fill(HIST("TrackQA/After/AntiProton/fDcaXy"), track.pt(), track.dcaXY()); + registry.fill(HIST("TrackQA/After/AntiProton/fDcaZ"), track.pt(), track.dcaZ()); + + registry.fill(HIST("TrackQA/After/AntiProton/fTpcClusters"), track.tpcNClsFound()); + registry.fill(HIST("TrackQA/After/AntiProton/fTpcCrossedRows"), track.tpcNClsCrossedRows()); + registry.fill(HIST("TrackQA/After/AntiProton/fTpcSharedClusters"), track.tpcNClsShared()); + registry.fill(HIST("TrackQA/After/AntiProton/fTpcSharedClusterOverClusterss"), track.tpcFractionSharedCls()); + registry.fill(HIST("TrackQA/After/AntiProton/fTpcFindableOverRows"), track.tpcCrossedRowsOverFindableCls()); + registry.fill(HIST("TrackQA/After/AntiProton/fTpcChi2OverCluster"), track.tpcChi2NCl()); + + registry.fill(HIST("TrackQA/After/AntiProton/fItsClusters"), track.itsNCls()); + registry.fill(HIST("TrackQA/After/AntiProton/fItsIbClusters"), track.itsNClsInnerBarrel()); + registry.fill(HIST("TrackQA/After/AntiProton/fItsChi2OverCluster"), track.itsChi2NCl()); } - if (isSelectedMinimalV0(col, v0, postrack, negtrack, -1, nTPCSigmaPos, nTPCSigmaNeg)) { - ROOT::Math::PtEtaPhiMVector temp(v0.pt(), v0.eta(), v0.phi(), mMassLambda); - antilambdas.push_back(temp); - AntiLambdaPosDaughIndex.push_back(postrack.globalIndex()); - AntiLambdaNegDaughIndex.push_back(negtrack.globalIndex()); - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalPionPlusV0Daughter"), postrack.tpcInnerParam(), postrack.tpcSignal()); - registry.fill(HIST("TrackCuts/TPCSignal/fTPCSignalProtonMinusV0Daughter"), negtrack.tpcInnerParam(), negtrack.tpcSignal()); - registry.fill(HIST("TrackCuts/AntiLambda/fPtAntiLambda"), v0.pt()); - registry.fill(HIST("TrackCuts/AntiLambda/fInvMassAntiLambda"), v0.mAntiLambda()); - registry.fill(HIST("TrackCuts/AntiLambda/fInvMassAntiLambdaKaonvsAntiLambda"), v0.mK0Short(), v0.mAntiLambda()); - registry.fill(HIST("TrackCuts/AntiLambda/fV0DCADaugh"), v0.dcaV0daughters()); - registry.fill(HIST("TrackCuts/AntiLambda/fV0CPA"), v0.v0cosPA()); - registry.fill(HIST("TrackCuts/AntiLambda/fV0TranRad"), v0.v0radius()); - registry.fill(HIST("TrackCuts/AntiLambda/f0DecVtxX"), v0.x()); - registry.fill(HIST("TrackCuts/AntiLambda/f0DecVtxY"), v0.y()); - registry.fill(HIST("TrackCuts/AntiLambda/f0DecVtxZ"), v0.z()); - - registry.fill(HIST("TrackCuts/AntiLambda/PosDaughter/Eta"), postrack.eta()); - registry.fill(HIST("TrackCuts/AntiLambda/PosDaughter/DCAXY"), postrack.dcaXY()); - registry.fill(HIST("TrackCuts/AntiLambda/PosDaughter/fTPCncls"), postrack.tpcNClsFound()); - registry.fill(HIST("TrackCuts/AntiLambda/NegDaughter/Eta"), negtrack.eta()); - registry.fill(HIST("TrackCuts/AntiLambda/NegDaughter/DCAXY"), negtrack.dcaXY()); - registry.fill(HIST("TrackCuts/AntiLambda/NegDaughter/fTPCncls"), negtrack.tpcNClsFound()); - registry.fill(HIST("TrackCuts/AntiLambda/NegDaughter/fNsigmaTPCvsPAntiProtonAntiV0Daugh"), negtrack.tpcInnerParam(), nTPCSigmaNeg[0]); - registry.fill(HIST("TrackCuts/AntiLambda/PosDaughter/fNsigmaTPCvsPPionPlusAntiV0Daugh"), postrack.tpcInnerParam(), nTPCSigmaPos[1]); + + if (checkTrack(track, std::string("Deuteron")) && checkTrackPid(track, std::string("Deuteron"))) { + vecAntiDeuteron.emplace_back(track.pt(), track.eta(), track.phi(), o2::constants::physics::MassDeuteron); + idxAntiDeuteron.push_back(track.globalIndex()); + + registry.fill(HIST("TrackQA/After/AntiDeuteron/fPt"), track.pt()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fPTpc"), track.tpcInnerParam()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fMomCor"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fEta"), track.eta()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fPhi"), track.phi()); + + registry.fill(HIST("TrackQA/After/AntiDeuteron/fNsigmaIts"), track.p(), track.itsNSigmaDe()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fNsigmaTpc"), track.p(), track.tpcNSigmaDe()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fNsigmaTof"), track.p(), track.tofNSigmaDe()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fNsigmaTpcTof"), track.p(), RecoDecay::sqrtSumOfSquares(track.tpcNSigmaDe(), track.tofNSigmaDe())); + + registry.fill(HIST("TrackQA/After/AntiDeuteron/fItsSignal"), track.p(), itsSignal(track)); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fTpcSignal"), track.p(), track.tpcSignal()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fTofBeta"), track.p(), track.beta()); + + registry.fill(HIST("TrackQA/After/AntiDeuteron/fDcaXy"), track.pt(), track.dcaXY()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fDcaZ"), track.pt(), track.dcaZ()); + + registry.fill(HIST("TrackQA/After/AntiDeuteron/fTpcClusters"), track.tpcNClsFound()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fTpcCrossedRows"), track.tpcNClsCrossedRows()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fTpcSharedClusters"), track.tpcNClsShared()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fTpcSharedClusterOverClusterss"), track.tpcFractionSharedCls()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fTpcFindableOverRows"), track.tpcCrossedRowsOverFindableCls()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fTpcChi2OverCluster"), track.tpcChi2NCl()); + + registry.fill(HIST("TrackQA/After/AntiDeuteron/fItsClusters"), track.itsNCls()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fItsIbClusters"), track.itsNClsInnerBarrel()); + registry.fill(HIST("TrackQA/After/AntiDeuteron/fItsChi2OverCluster"), track.itsChi2NCl()); } } + } - if (ConfTriggerSwitches->get("Switch", "ppPhi") > 0.) { + // loop over and build v0s + for (auto const& v0 : v0s) { - for (const auto& postrack : kaons) { - for (const auto& negtrack : antikaons) { + auto posTrack = v0.posTrack_as(); + auto negTrack = v0.negTrack_as(); - ROOT::Math::PtEtaPhiMVector temp = postrack + negtrack; + auto posTrackPar = getTrackParCov(posTrack); + auto negTrackPar = getTrackParCov(negTrack); - registry.fill(HIST("TrackCuts/Phi/Before/fInvMass"), temp.M()); - registry.fill(HIST("TrackCuts/Phi/Before/fPt"), temp.pt()); - registry.fill(HIST("TrackCuts/Phi/Before/fEta"), temp.eta()); - registry.fill(HIST("TrackCuts/Phi/Before/fPhi"), translatePhi(temp.phi())); + if (!mStraHelper.buildV0Candidate(v0.collisionId(), col.posX(), col.posY(), col.posZ(), posTrack, negTrack, posTrackPar, negTrackPar, false, false, false)) { + continue; + } - if ((temp.M() >= PPPhi.ConfResoInvMassLowLimit.value) && (temp.M() <= PPPhi.ConfResoInvMassUpLimit.value)) { + float lambdaPt = RecoDecay::sqrtSumOfSquares(mStraHelper.v0.momentum[0], mStraHelper.v0.momentum[1]); + float lambdaPos = std::hypot(mStraHelper.v0.position[0] - col.posX(), mStraHelper.v0.position[1] - col.posY(), mStraHelper.v0.position[2] - col.posZ()); + float lambdaRadius = std::hypot(mStraHelper.v0.position[0], mStraHelper.v0.position[1]); + float lambdaEta = RecoDecay::eta(std::array{mStraHelper.v0.momentum[0], mStraHelper.v0.momentum[1], mStraHelper.v0.momentum[2]}); + float lambdaPhi = RecoDecay::phi(mStraHelper.v0.momentum[0], mStraHelper.v0.momentum[1]); + float lambdaCpa = std::cos(mStraHelper.v0.pointingAngle); + float lambdaDauDca = mStraHelper.v0.daughterDCA; + float lambdaMass = mStraHelper.v0.massLambda; + float antiLambdaMass = mStraHelper.v0.massAntiLambda; + float kaonMass = mStraHelper.v0.massK0Short; + + float posTrackEta = RecoDecay::eta(std::array{mStraHelper.v0.positiveMomentum[0], mStraHelper.v0.positiveMomentum[1], mStraHelper.v0.positiveMomentum[2]}); + float posTrackDca = mStraHelper.v0.positiveDCAxy; + float negTrackEta = RecoDecay::eta(std::array{mStraHelper.v0.negativeMomentum[0], mStraHelper.v0.negativeMomentum[1], mStraHelper.v0.negativeMomentum[2]}); + float negTrackDca = mStraHelper.v0.negativeDCAxy; + + registry.fill(HIST("LambdaQA/Before/fPt"), lambdaPt); + registry.fill(HIST("LambdaQA/Before/fEta"), lambdaEta); + registry.fill(HIST("LambdaQA/Before/fPhi"), lambdaPhi); + registry.fill(HIST("LambdaQA/Before/fInvMassLambda"), lambdaMass); + registry.fill(HIST("LambdaQA/Before/fInvMassAntiLambda"), antiLambdaMass); + registry.fill(HIST("LambdaQA/Before/fInvMassLambdaVsAntiLambda"), lambdaMass, antiLambdaMass); + registry.fill(HIST("LambdaQA/Before/fInvMassLambdaVsKaon"), lambdaMass, kaonMass); + registry.fill(HIST("LambdaQA/Before/fInvMassAntiLambdaVsKaon"), antiLambdaMass, kaonMass); + registry.fill(HIST("LambdaQA/Before/fDcaDaugh"), lambdaDauDca); + registry.fill(HIST("LambdaQA/Before/fCpa"), lambdaCpa); + registry.fill(HIST("LambdaQA/Before/fTranRad"), lambdaRadius); + registry.fill(HIST("LambdaQA/Before/fDecVtx"), lambdaPos); + + registry.fill(HIST("LambdaQA/Before/PosDaughter/fPt"), posTrack.pt()); + registry.fill(HIST("LambdaQA/Before/PosDaughter/fEta"), posTrackEta); + registry.fill(HIST("LambdaQA/Before/PosDaughter/fPhi"), posTrack.phi()); + registry.fill(HIST("LambdaQA/Before/PosDaughter/fDcaXy"), posTrack.pt(), posTrackDca); + registry.fill(HIST("LambdaQA/Before/PosDaughter/fTpcClusters"), posTrack.tpcNClsFound()); + registry.fill(HIST("LambdaQA/Before/PosDaughter/fNsigmaTpcProton"), posTrack.p(), posTrack.tpcNSigmaPr()); + registry.fill(HIST("LambdaQA/Before/PosDaughter/fNsigmaTpcPion"), posTrack.p(), posTrack.tpcNSigmaPi()); + + registry.fill(HIST("LambdaQA/Before/NegDaughter/fPt"), negTrack.pt()); + registry.fill(HIST("LambdaQA/Before/NegDaughter/fEta"), negTrackEta); + registry.fill(HIST("LambdaQA/Before/NegDaughter/fPhi"), negTrack.phi()); + registry.fill(HIST("LambdaQA/Before/NegDaughter/fDcaXy"), negTrack.pt(), negTrackDca); + registry.fill(HIST("LambdaQA/Before/NegDaughter/fTpcClusters"), negTrack.tpcNClsFound()); + registry.fill(HIST("LambdaQA/Before/NegDaughter/fNsigmaTpcProton"), negTrack.p(), negTrack.tpcNSigmaPr()); + registry.fill(HIST("LambdaQA/Before/NegDaughter/fNsigmaTpcPion"), negTrack.p(), negTrack.tpcNSigmaPi()); + + if (checkLambda(lambdaPt, lambdaDauDca, lambdaCpa, lambdaRadius, lambdaPos, kaonMass, lambdaMass) && checkLambdaDaughter(posTrack, posTrackEta, posTrackDca, posTrack.tpcNSigmaPr()) && checkLambdaDaughter(negTrack, negTrackEta, negTrackDca, negTrack.tpcNSigmaPi())) { + vecLambda.emplace_back(lambdaPt, lambdaEta, lambdaPhi, o2::constants::physics::MassLambda0); + idxLambdaDaughProton.push_back(posTrack.globalIndex()); + idxLambdaDaughPion.push_back(negTrack.globalIndex()); + + registry.fill(HIST("LambdaQA/After/Lambda/fPt"), lambdaPt); + registry.fill(HIST("LambdaQA/After/Lambda/fEta"), lambdaEta); + registry.fill(HIST("LambdaQA/After/Lambda/fPhi"), lambdaPhi); + registry.fill(HIST("LambdaQA/After/Lambda/fInvMass"), lambdaMass); + registry.fill(HIST("LambdaQA/After/Lambda/fInvMassLambdaVsAntiLambda"), lambdaMass, antiLambdaMass); + registry.fill(HIST("LambdaQA/After/Lambda/fInvMassLambdaVsKaon"), lambdaMass, kaonMass); + registry.fill(HIST("LambdaQA/After/Lambda/fDcaDaugh"), lambdaDauDca); + registry.fill(HIST("LambdaQA/After/Lambda/fCpa"), lambdaCpa); + registry.fill(HIST("LambdaQA/After/Lambda/fTranRad"), lambdaRadius); + registry.fill(HIST("LambdaQA/After/Lambda/fDecVtx"), lambdaPos); + + registry.fill(HIST("LambdaQA/After/Lambda/PosDaughter/fPt"), posTrack.pt()); + registry.fill(HIST("LambdaQA/After/Lambda/PosDaughter/fEta"), posTrackEta); + registry.fill(HIST("LambdaQA/After/Lambda/PosDaughter/fPhi"), posTrack.phi()); + registry.fill(HIST("LambdaQA/After/Lambda/PosDaughter/fDcaXy"), posTrack.pt(), posTrackDca); + registry.fill(HIST("LambdaQA/After/Lambda/PosDaughter/fTpcClusters"), posTrack.tpcNClsFound()); + registry.fill(HIST("LambdaQA/After/Lambda/PosDaughter/fNsigmaTpc"), posTrack.p(), posTrack.tpcNSigmaPr()); + + registry.fill(HIST("LambdaQA/After/Lambda/NegDaughter/fPt"), negTrack.pt()); + registry.fill(HIST("LambdaQA/After/Lambda/NegDaughter/fEta"), negTrackEta); + registry.fill(HIST("LambdaQA/After/Lambda/NegDaughter/fPhi"), negTrack.phi()); + registry.fill(HIST("LambdaQA/After/Lambda/NegDaughter/fDcaXy"), negTrack.pt(), negTrackDca); + registry.fill(HIST("LambdaQA/After/Lambda/NegDaughter/fTpcClusters"), negTrack.tpcNClsFound()); + registry.fill(HIST("LambdaQA/After/Lambda/NegDaughter/fNsigmaTpc"), negTrack.p(), negTrack.tpcNSigmaPi()); + } - phi.push_back(temp); + if (checkLambda(lambdaPt, lambdaDauDca, lambdaCpa, lambdaRadius, lambdaPos, kaonMass, antiLambdaMass) && checkLambdaDaughter(posTrack, posTrackEta, posTrackDca, posTrack.tpcNSigmaPi()) && checkLambdaDaughter(negTrack, negTrackEta, negTrackDca, negTrack.tpcNSigmaPr())) { + vecAntiLambda.emplace_back(lambdaPt, lambdaEta, lambdaPhi, o2::constants::physics::MassLambda0); + + idxAntiLambdaDaughProton.push_back(negTrack.globalIndex()); + idxAntiLambdaDaughPion.push_back(posTrack.globalIndex()); + + registry.fill(HIST("LambdaQA/After/AntiLambda/fPt"), lambdaPt); + registry.fill(HIST("LambdaQA/After/AntiLambda/fEta"), lambdaEta); + registry.fill(HIST("LambdaQA/After/AntiLambda/fPhi"), lambdaPhi); + registry.fill(HIST("LambdaQA/After/AntiLambda/fInvMass"), antiLambdaMass); + registry.fill(HIST("LambdaQA/After/AntiLambda/fInvMassAntiLambdaVsLambda"), antiLambdaMass, lambdaMass); + registry.fill(HIST("LambdaQA/After/AntiLambda/fInvMassAntiLambdaVsKaon"), antiLambdaMass, kaonMass); + registry.fill(HIST("LambdaQA/After/AntiLambda/fDcaDaugh"), lambdaDauDca); + registry.fill(HIST("LambdaQA/After/AntiLambda/fCpa"), lambdaCpa); + registry.fill(HIST("LambdaQA/After/AntiLambda/fTranRad"), lambdaRadius); + registry.fill(HIST("LambdaQA/After/AntiLambda/fDecVtx"), lambdaPos); + + registry.fill(HIST("LambdaQA/After/AntiLambda/PosDaughter/fPt"), posTrack.pt()); + registry.fill(HIST("LambdaQA/After/AntiLambda/PosDaughter/fEta"), posTrackEta); + registry.fill(HIST("LambdaQA/After/AntiLambda/PosDaughter/fPhi"), posTrack.phi()); + registry.fill(HIST("LambdaQA/After/AntiLambda/PosDaughter/fDcaXy"), posTrack.pt(), posTrackDca); + registry.fill(HIST("LambdaQA/After/AntiLambda/PosDaughter/fTpcClusters"), posTrack.tpcNClsFound()); + registry.fill(HIST("LambdaQA/After/AntiLambda/PosDaughter/fNsigmaTpc"), posTrack.p(), posTrack.tpcNSigmaPr()); + + registry.fill(HIST("LambdaQA/After/AntiLambda/NegDaughter/fPt"), negTrack.pt()); + registry.fill(HIST("LambdaQA/After/AntiLambda/NegDaughter/fEta"), negTrackEta); + registry.fill(HIST("LambdaQA/After/AntiLambda/NegDaughter/fPhi"), negTrack.phi()); + registry.fill(HIST("LambdaQA/After/AntiLambda/NegDaughter/fDcaXy"), negTrack.pt(), negTrackDca); + registry.fill(HIST("LambdaQA/After/AntiLambda/NegDaughter/fTpcClusters"), negTrack.tpcNClsFound()); + registry.fill(HIST("LambdaQA/After/AntiLambda/NegDaughter/fNsigmaTpc"), negTrack.p(), negTrack.tpcNSigmaPi()); + } + } - registry.fill(HIST("TrackCuts/Phi/After/fInvMass"), temp.M()); - registry.fill(HIST("TrackCuts/Phi/After/fPt"), temp.pt()); - registry.fill(HIST("TrackCuts/Phi/After/fEta"), temp.eta()); - registry.fill(HIST("TrackCuts/Phi/After/fPhi"), translatePhi(temp.phi())); + // build phi candidates + for (size_t k1 = 0; k1 < vecKaon.size(); k1++) { + for (size_t k2 = 0; k2 < vecAntiKaon.size(); k2++) { + ROOT::Math::PtEtaPhiMVector phi = vecKaon.at(k1) + vecAntiKaon.at(k2); + + registry.fill(HIST("PhiQA/Before/fInvMass"), phi.M()); + registry.fill(HIST("PhiQA/Before/fPt"), phi.Pt()); + registry.fill(HIST("PhiQA/Before/fEta"), phi.Eta()); + registry.fill(HIST("PhiQA/Before/fPhi"), RecoDecay::constrainAngle(phi.Phi())); + + if ((phi.M() >= PhiSelections.invMassLow.value) && + (phi.M() <= PhiSelections.invMassUp.value)) { + vecPhi.push_back(phi); + idxPhiDaughPos.push_back(idxKaon.at(k1)); + idxPhiDaughNeg.push_back(idxAntiKaon.at(k2)); + + registry.fill(HIST("PhiQA/After/fInvMass"), phi.M()); + registry.fill(HIST("PhiQA/After/fPt"), phi.Pt()); + registry.fill(HIST("PhiQA/After/fEta"), phi.Eta()); + registry.fill(HIST("PhiQA/After/fPhi"), RecoDecay::constrainAngle(phi.Phi())); + } + } + } - registry.fill(HIST("TrackCuts/Phi/After/PosDaughter/fPt"), postrack.pt()); - registry.fill(HIST("TrackCuts/Phi/After/PosDaughter/fEta"), postrack.eta()); - registry.fill(HIST("TrackCuts/Phi/After/PosDaughter/fPhi"), translatePhi(postrack.phi())); + // build rho candidates + for (size_t p1 = 0; p1 < vecPion.size(); p1++) { + for (size_t p2 = 0; p2 < vecAntiPion.size(); p2++) { + ROOT::Math::PtEtaPhiMVector rho = vecPion.at(p1) + vecAntiPion.at(p2); + + registry.fill(HIST("RhoQA/Before/fInvMass"), rho.M()); + registry.fill(HIST("RhoQA/Before/fPt"), rho.Pt()); + registry.fill(HIST("RhoQA/Before/fEta"), rho.Eta()); + registry.fill(HIST("RhoQA/Before/fPhi"), RecoDecay::constrainAngle(rho.Phi())); + + if (((rho.M() >= RhoSelections.invMassLow.value) && (rho.M() <= RhoSelections.invMassUp.value)) && (rho.Pt() >= RhoSelections.ptLow)) { + vecRho.push_back(rho); + idxRhoDaughPos.push_back(idxPion.at(p1)); + idxRhoDaughNeg.push_back(idxAntiPion.at(p2)); + + registry.fill(HIST("RhoQA/After/fInvMass"), rho.M()); + registry.fill(HIST("RhoQA/After/fPt"), rho.Pt()); + registry.fill(HIST("RhoQA/After/fEta"), rho.Eta()); + registry.fill(HIST("RhoQA/After/fPhi"), RecoDecay::constrainAngle(rho.Phi())); + } + } + } - registry.fill(HIST("TrackCuts/Phi/After/NegDaughter/fPt"), negtrack.pt()); - registry.fill(HIST("TrackCuts/Phi/After/NegDaughter/fEta"), negtrack.eta()); - registry.fill(HIST("TrackCuts/Phi/After/NegDaughter/fPhi"), translatePhi(negtrack.phi())); + // reset all arrays + keepEventTightLimit.fill(false); + keepEventLooseLimit.fill(false); + signalTightLimit.fill(0); + signalLooseLimit.fill(0); + + float q3 = 999.f, kstar = 999.f; + + // PPP + if (TriggerSelections.filterSwitches->get("Switch", "PPP") > 0) { + for (size_t p1 = 0; p1 < vecProton.size(); p1++) { + for (size_t p2 = p1 + 1; p2 < vecProton.size(); p2++) { + for (size_t p3 = p2 + 1; p3 < vecProton.size(); p3++) { + q3 = getQ3(vecProton.at(p1), vecProton.at(p2), vecProton.at(p3)); + registry.fill(HIST("PPP/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PPP/fZvtx"), col.posZ()); + registry.fill(HIST("PPP/fSE_particle"), q3); + registry.fill(HIST("PPP/fProtonPtVsQ3"), vecProton.at(p1).Pt(), q3); + registry.fill(HIST("PPP/fProtonPtVsQ3"), vecProton.at(p2).Pt(), q3); + registry.fill(HIST("PPP/fProtonPtVsQ3"), vecProton.at(p3).Pt(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "PPP")) { + signalLooseLimit[cf_trigger::kPPP] += 1; + if (q3 < TriggerSelections.limits->get("Tight Limit", "PPP")) { + signalTightLimit[cf_trigger::kPPP] += 1; + } } } } } - - // construct rho cand - if (ConfTriggerSwitches->get("Switch", "ppRho") > 0.) { // here we could select on extra pion properties important for the Rho0Cands - - for (const auto& postrack : pions) { - for (const auto& negtrack : antipions) { - - ROOT::Math::PtEtaPhiMVector temp = postrack + negtrack; - - registry.fill(HIST("TrackCuts/Rho/Before/fInvMass"), temp.M()); - registry.fill(HIST("TrackCuts/Rho/Before/fPt"), temp.pt()); - registry.fill(HIST("TrackCuts/Rho/Before/fEta"), temp.eta()); - registry.fill(HIST("TrackCuts/Rho/Before/fPhi"), translatePhi(temp.phi())); - - registry.fill(HIST("TrackCuts/Rho/Before/PosDaughter/fInvMass"), postrack.M()); - registry.fill(HIST("TrackCuts/Rho/Before/PosDaughter/fPt"), postrack.pt()); - registry.fill(HIST("TrackCuts/Rho/Before/PosDaughter/fEta"), postrack.eta()); - registry.fill(HIST("TrackCuts/Rho/Before/PosDaughter/fPhi"), translatePhi(postrack.phi())); - - registry.fill(HIST("TrackCuts/Rho/Before/PosDaughter/fInvMass"), negtrack.M()); - registry.fill(HIST("TrackCuts/Rho/Before/NegDaughter/fPt"), negtrack.pt()); - registry.fill(HIST("TrackCuts/Rho/Before/NegDaughter/fEta"), negtrack.eta()); - registry.fill(HIST("TrackCuts/Rho/Before/NegDaughter/fPhi"), translatePhi(negtrack.phi())); - - if ((temp.M() >= PPRho.ConfResoRho0InvMassLowLimit.value) && (temp.M() <= PPRho.ConfResoRho0InvMassUpLimit.value) && (temp.pt() >= PPRho.ConfTrkPtRho0CandLowLimit.value) && (temp.pt() <= PPRho.ConfTrkPtRho0CandUpLimit.value)) { - - rho.push_back(temp); - - registry.fill(HIST("TrackCuts/Rho/After/fInvMass"), temp.M()); - registry.fill(HIST("TrackCuts/Rho/After/fPt"), temp.pt()); - registry.fill(HIST("TrackCuts/Rho/After/fEta"), temp.eta()); - registry.fill(HIST("TrackCuts/Rho/After/fPhi"), translatePhi(temp.phi())); - - registry.fill(HIST("TrackCuts/Rho/After/PosDaughter/fPt"), postrack.pt()); - registry.fill(HIST("TrackCuts/Rho/After/PosDaughter/fEta"), postrack.eta()); - registry.fill(HIST("TrackCuts/Rho/After/PosDaughter/fPhi"), translatePhi(postrack.phi())); - - registry.fill(HIST("TrackCuts/Rho/After/NegDaughter/fPt"), negtrack.pt()); - registry.fill(HIST("TrackCuts/Rho/After/NegDaughter/fEta"), negtrack.eta()); - registry.fill(HIST("TrackCuts/Rho/After/NegDaughter/fPhi"), translatePhi(negtrack.phi())); + for (size_t p1 = 0; p1 < vecAntiProton.size(); p1++) { + for (size_t p2 = p1 + 1; p2 < vecAntiProton.size(); p2++) { + for (size_t p3 = p2 + 1; p3 < vecAntiProton.size(); p3++) { + q3 = getQ3(vecAntiProton.at(p1), vecAntiProton.at(p2), vecAntiProton.at(p3)); + registry.fill(HIST("PPP/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PPP/fZvtx"), col.posZ()); + registry.fill(HIST("PPP/fSE_antiparticle"), q3); + registry.fill(HIST("PPP/fAntiProtonPtVsQ3"), vecAntiProton.at(p1).Pt(), q3); + registry.fill(HIST("PPP/fAntiProtonPtVsQ3"), vecAntiProton.at(p2).Pt(), q3); + registry.fill(HIST("PPP/fAntiProtonPtVsQ3"), vecAntiProton.at(p3).Pt(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "PPP")) { + signalLooseLimit[cf_trigger::kPPP] += 1; + if (q3 < TriggerSelections.limits->get("Tight Limit", "PPP")) { + signalTightLimit[cf_trigger::kPPP] += 1; + } } } } } - - float Q3 = 999.f, kstar = 999.f; - if (ConfTriggerSwitches->get("Switch", "ppp") > 0.) { - // ppp trigger - for (auto iProton1 = protons.begin(); iProton1 != protons.end(); ++iProton1) { - auto iProton2 = iProton1 + 1; - for (; iProton2 != protons.end(); ++iProton2) { - auto iProton3 = iProton2 + 1; - for (; iProton3 != protons.end(); ++iProton3) { - Q3 = getQ3(*iProton1, *iProton2, *iProton3); - registry.fill(HIST("ppp/fSE_particle"), Q3); - registry.fill(HIST("ppp/fProtonPtVsQ3"), Q3, (*iProton1).Pt()); - registry.fill(HIST("ppp/fProtonPtVsQ3"), Q3, (*iProton2).Pt()); - registry.fill(HIST("ppp/fProtonPtVsQ3"), Q3, (*iProton3).Pt()); - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kPPP)) { - if (ConfDownsample->get("Switch", "PPP") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "PPP")) { - registry.fill(HIST("ppp/fSE_particle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kPPP] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kPPP] += 1; - } + } + // PPL + if (TriggerSelections.filterSwitches->get("Switch", "PPL") > 0) { + for (size_t p1 = 0; p1 < vecProton.size(); p1++) { + for (size_t p2 = p1 + 1; p2 < vecProton.size(); p2++) { + for (size_t l1 = 0; l1 < vecLambda.size(); l1++) { + if (idxProton.at(p1) == idxLambdaDaughProton.at(l1) || idxProton.at(p2) == idxLambdaDaughProton.at(l1)) { + continue; + } + q3 = getQ3(vecProton.at(p1), vecProton.at(p2), vecLambda.at(l1)); + registry.fill(HIST("PPL/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PPL/fZvtx"), col.posZ()); + registry.fill(HIST("PPL/fSE_particle"), q3); + registry.fill(HIST("PPL/fProtonPtVsQ3"), vecProton.at(p1).Pt(), q3); + registry.fill(HIST("PPL/fProtonPtVsQ3"), vecProton.at(p2).Pt(), q3); + registry.fill(HIST("PPL/fLambdaPtVsQ3"), vecLambda.at(l1).Pt(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "PPL")) { + signalLooseLimit[cf_trigger::kPPL] += 1; + if (q3 < TriggerSelections.limits->get("Tight Limit", "PPL")) { + signalTightLimit[cf_trigger::kPPL] += 1; } } } } - for (auto iAntiProton1 = antiprotons.begin(); iAntiProton1 != antiprotons.end(); ++iAntiProton1) { - auto iAntiProton2 = iAntiProton1 + 1; - for (; iAntiProton2 != antiprotons.end(); ++iAntiProton2) { - auto iAntiProton3 = iAntiProton2 + 1; - for (; iAntiProton3 != antiprotons.end(); ++iAntiProton3) { - Q3 = getQ3(*iAntiProton1, *iAntiProton2, *iAntiProton3); - registry.fill(HIST("ppp/fSE_antiparticle"), Q3); - registry.fill(HIST("ppp/fAntiProtonPtVsQ3"), Q3, (*iAntiProton1).Pt()); - registry.fill(HIST("ppp/fAntiProtonPtVsQ3"), Q3, (*iAntiProton2).Pt()); - registry.fill(HIST("ppp/fAntiProtonPtVsQ3"), Q3, (*iAntiProton3).Pt()); - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kPPP)) { - if (ConfDownsample->get("Switch", "aPaPaP") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "aPaPaP")) { - registry.fill(HIST("ppp/fSE_antiparticle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kPPP] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kPPP] += 1; - } + } + for (size_t p1 = 0; p1 < vecAntiProton.size(); p1++) { + for (size_t p2 = p1 + 1; p2 < vecAntiProton.size(); p2++) { + for (size_t l1 = 0; l1 < vecAntiLambda.size(); l1++) { + if (idxAntiProton.at(p1) == idxAntiLambdaDaughProton.at(l1) || idxAntiProton.at(p2) == idxAntiLambdaDaughProton.at(l1)) { + continue; + } + q3 = getQ3(vecAntiProton.at(p1), vecAntiProton.at(p2), vecAntiLambda.at(l1)); + registry.fill(HIST("PPL/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PPL/fZvtx"), col.posZ()); + registry.fill(HIST("PPL/fSE_particle"), q3); + registry.fill(HIST("PPL/fAntiProtonPtVsQ3"), vecAntiProton.at(p1).Pt(), q3); + registry.fill(HIST("PPL/fAntiProtonPtVsQ3"), vecAntiProton.at(p2).Pt(), q3); + registry.fill(HIST("PPL/fAntiLambdaPtVsQ3"), vecAntiLambda.at(l1).Pt(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "PPL")) { + signalLooseLimit[cf_trigger::kPPL] += 1; + if (q3 < TriggerSelections.limits->get("Tight Limit", "PPL")) { + signalTightLimit[cf_trigger::kPPL] += 1; } } } } } - if (ConfTriggerSwitches->get("Switch", "ppL") > 0.) { - // ppl trigger - for (auto iProton1 = protons.begin(); iProton1 != protons.end(); ++iProton1) { - auto iProton2 = iProton1 + 1; - auto i1 = std::distance(protons.begin(), iProton1); - for (; iProton2 != protons.end(); ++iProton2) { - auto i2 = std::distance(protons.begin(), iProton2); - for (auto iLambda1 = lambdas.begin(); iLambda1 != lambdas.end(); ++iLambda1) { - auto i3 = std::distance(lambdas.begin(), iLambda1); - if (ConfAutocorRejection.value && - (ProtonIndex.at(i1) == LambdaPosDaughIndex.at(i3) || - ProtonIndex.at(i2) == LambdaPosDaughIndex.at(i3))) { - continue; - } - Q3 = getQ3(*iProton1, *iProton2, *iLambda1); - registry.fill(HIST("ppl/fSE_particle"), Q3); - registry.fill(HIST("ppl/fProtonPtVsQ3"), Q3, (*iProton1).Pt()); - registry.fill(HIST("ppl/fProtonPtVsQ3"), Q3, (*iProton2).Pt()); - registry.fill(HIST("ppl/fLambdaPtVsQ3"), Q3, (*iLambda1).Pt()); - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kPPL)) { - if (ConfDownsample->get("Switch", "PPL") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "PPL")) { - registry.fill(HIST("ppl/fSE_particle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kPPL] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kPPL] += 1; - } + } + // PLL + if (TriggerSelections.filterSwitches->get("Switch", "PLL") > 0) { + for (size_t l1 = 0; l1 < vecLambda.size(); l1++) { + for (size_t l2 = l1 + 1; l2 < vecLambda.size(); l2++) { + for (size_t p1 = 0; p1 < vecProton.size(); p1++) { + if (idxProton.at(p1) == idxLambdaDaughProton.at(l1) || idxProton.at(p1) == idxLambdaDaughProton.at(l2)) { + continue; + } + if (idxLambdaDaughProton.at(l1) == idxLambdaDaughProton.at(l2) || idxLambdaDaughPion.at(l1) == idxLambdaDaughPion.at(l2)) { + continue; + } + q3 = getQ3(vecLambda.at(l1), vecLambda.at(l2), vecProton.at(p1)); + registry.fill(HIST("PLL/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PLL/fZvtx"), col.posZ()); + registry.fill(HIST("PLL/fSE_particle"), q3); + registry.fill(HIST("PLL/fLambdaPtVsQ3"), vecLambda.at(l1).Pt(), q3); + registry.fill(HIST("PLL/fLambdaPtVsQ3"), vecLambda.at(l2).Pt(), q3); + registry.fill(HIST("PLL/fProtonPtVsQ3"), vecProton.at(p1).Pt(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "PLL")) { + signalLooseLimit[cf_trigger::kPLL] += 1; + if (q3 < TriggerSelections.limits->get("Tight Limit", "PLL")) { + signalTightLimit[cf_trigger::kPLL] += 1; } } } } - for (auto iAntiProton1 = antiprotons.begin(); iAntiProton1 != antiprotons.end(); ++iAntiProton1) { - auto iAntiProton2 = iAntiProton1 + 1; - auto i1 = std::distance(antiprotons.begin(), iAntiProton1); - for (; iAntiProton2 != antiprotons.end(); ++iAntiProton2) { - auto i2 = std::distance(antiprotons.begin(), iAntiProton2); - for (auto iAntiLambda1 = antilambdas.begin(); iAntiLambda1 != antilambdas.end(); ++iAntiLambda1) { - auto i3 = std::distance(antilambdas.begin(), iAntiLambda1); - if (ConfAutocorRejection.value && - (AntiProtonIndex.at(i1) == AntiLambdaNegDaughIndex.at(i3) || - AntiProtonIndex.at(i2) == AntiLambdaNegDaughIndex.at(i3))) { - continue; - } - Q3 = getQ3(*iAntiProton1, *iAntiProton2, *iAntiLambda1); - registry.fill(HIST("ppl/fSE_antiparticle"), Q3); - registry.fill(HIST("ppl/fAntiProtonPtVsQ3"), Q3, (*iAntiProton1).Pt()); - registry.fill(HIST("ppl/fAntiProtonPtVsQ3"), Q3, (*iAntiProton2).Pt()); - registry.fill(HIST("ppl/fAntiLambdaPtVsQ3"), Q3, (*iAntiLambda1).Pt()); - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kPPL)) { - if (ConfDownsample->get("Switch", "aPaPaL") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "aPaPaL")) { - registry.fill(HIST("ppl/fSE_antiparticle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kPPL] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kPPL] += 1; - } + } + for (size_t l1 = 0; l1 < vecAntiLambda.size(); l1++) { + for (size_t l2 = l1 + 1; l2 < vecAntiLambda.size(); l2++) { + for (size_t p1 = 0; p1 < vecAntiProton.size(); p1++) { + if (idxAntiProton.at(p1) == idxAntiLambdaDaughProton.at(l1) || idxAntiProton.at(p1) == idxAntiLambdaDaughProton.at(l2)) { + continue; + } + if (idxAntiLambdaDaughProton.at(l1) == idxAntiLambdaDaughProton.at(l2) || idxAntiLambdaDaughPion.at(l1) == idxAntiLambdaDaughPion.at(l2)) { + continue; + } + q3 = getQ3(vecAntiLambda.at(l1), vecAntiLambda.at(l2), vecAntiProton.at(p1)); + registry.fill(HIST("PLL/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PLL/fZvtx"), col.posZ()); + registry.fill(HIST("PLL/fSE_antiparticle"), q3); + registry.fill(HIST("PLL/fAntiLambdaPtVsQ3"), vecAntiLambda.at(l1).Pt(), q3); + registry.fill(HIST("PLL/fAntiLambdaPtVsQ3"), vecAntiLambda.at(l2).Pt(), q3); + registry.fill(HIST("PLL/fAntiProtonPtVsQ3"), vecAntiProton.at(p1).Pt(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "PLL")) { + signalLooseLimit[cf_trigger::kPLL] += 1; + if (q3 < TriggerSelections.limits->get("Tight Limit", "PLL")) { + signalTightLimit[cf_trigger::kPLL] += 1; } } } } } - if (ConfTriggerSwitches->get("Switch", "pLL") > 0.) { - // pll trigger - for (auto iLambda1 = lambdas.begin(); iLambda1 != lambdas.end(); ++iLambda1) { - auto iLambda2 = iLambda1 + 1; - auto i1 = std::distance(lambdas.begin(), iLambda1); - for (; iLambda2 != lambdas.end(); ++iLambda2) { - auto i2 = std::distance(lambdas.begin(), iLambda2); - if (ConfAutocorRejection.value && - (LambdaPosDaughIndex.at(i1) == LambdaPosDaughIndex.at(i2) || - LambdaNegDaughIndex.at(i1) == LambdaNegDaughIndex.at(i2))) { + } + // LLL + if (TriggerSelections.filterSwitches->get("Switch", "LLL") > 0) { + for (size_t l1 = 0; l1 < vecLambda.size(); l1++) { + for (size_t l2 = l1 + 1; l2 < vecLambda.size(); l2++) { + for (size_t l3 = l2 + 1; l3 < vecLambda.size(); l3++) { + if (idxLambdaDaughProton.at(l1) == idxLambdaDaughProton.at(l2) || idxLambdaDaughPion.at(l1) == idxLambdaDaughPion.at(l2) || + idxLambdaDaughProton.at(l2) == idxLambdaDaughProton.at(l3) || idxLambdaDaughPion.at(l2) == idxLambdaDaughPion.at(l3) || + idxLambdaDaughProton.at(l3) == idxLambdaDaughProton.at(l1) || idxLambdaDaughPion.at(l3) == idxLambdaDaughPion.at(l1)) { continue; } - for (auto iProton1 = protons.begin(); iProton1 != protons.end(); ++iProton1) { - auto i3 = std::distance(protons.begin(), iProton1); - if (ConfAutocorRejection.value && - (LambdaPosDaughIndex.at(i1) == ProtonIndex.at(i3) || - LambdaPosDaughIndex.at(i2) == ProtonIndex.at(i3))) { - continue; - } - Q3 = getQ3(*iLambda1, *iLambda2, *iProton1); - registry.fill(HIST("pll/fSE_particle"), Q3); - registry.fill(HIST("pll/fProtonPtVsQ3"), Q3, (*iProton1).Pt()); - registry.fill(HIST("pll/fLambdaPtVsQ3"), Q3, (*iLambda1).Pt()); - registry.fill(HIST("pll/fLambdaPtVsQ3"), Q3, (*iLambda2).Pt()); - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kPLL)) { - if (ConfDownsample->get("Switch", "PLL") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "PLL")) { - registry.fill(HIST("pll/fSE_particle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kPLL] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kPLL] += 1; - } + q3 = getQ3(vecLambda.at(l1), vecLambda.at(l2), vecLambda.at(l3)); + registry.fill(HIST("PLL/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PLL/fZvtx"), col.posZ()); + registry.fill(HIST("PLL/fSE_particle"), q3); + registry.fill(HIST("PLL/fLambdaPtVsQ3"), vecLambda.at(l1).Pt(), q3); + registry.fill(HIST("PLL/fLambdaPtVsQ3"), vecLambda.at(l2).Pt(), q3); + registry.fill(HIST("PLL/fLambdaPtVsQ3"), vecLambda.at(l3).Pt(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "LLL")) { + signalLooseLimit[cf_trigger::kLLL] += 1; + if (q3 < TriggerSelections.limits->get("Tight Limit", "LLL")) { + signalTightLimit[cf_trigger::kLLL] += 1; } } } } - for (auto iAntiLambda1 = antilambdas.begin(); iAntiLambda1 != antilambdas.end(); ++iAntiLambda1) { - auto iAntiLambda2 = iAntiLambda1 + 1; - auto i1 = std::distance(antilambdas.begin(), iAntiLambda1); - for (; iAntiLambda2 != antilambdas.end(); ++iAntiLambda2) { - auto i2 = std::distance(antilambdas.begin(), iAntiLambda2); - if (ConfAutocorRejection.value && - (AntiLambdaPosDaughIndex.at(i1) == AntiLambdaPosDaughIndex.at(i2) || - AntiLambdaNegDaughIndex.at(i1) == AntiLambdaNegDaughIndex.at(i2))) { + } + for (size_t l1 = 0; l1 < vecAntiLambda.size(); l1++) { + for (size_t l2 = l1 + 1; l2 < vecAntiLambda.size(); l2++) { + for (size_t l3 = l2 + 1; l3 < vecAntiLambda.size(); l3++) { + if (idxAntiLambdaDaughProton.at(l1) == idxAntiLambdaDaughProton.at(l2) || idxAntiLambdaDaughPion.at(l1) == idxAntiLambdaDaughPion.at(l2) || + idxAntiLambdaDaughProton.at(l2) == idxAntiLambdaDaughProton.at(l3) || idxAntiLambdaDaughPion.at(l2) == idxAntiLambdaDaughPion.at(l3) || + idxAntiLambdaDaughProton.at(l3) == idxAntiLambdaDaughProton.at(l1) || idxAntiLambdaDaughPion.at(l3) == idxAntiLambdaDaughPion.at(l1)) { continue; } - for (auto iAntiProton1 = antiprotons.begin(); iAntiProton1 != antiprotons.end(); ++iAntiProton1) { - auto i3 = std::distance(antiprotons.begin(), iAntiProton1); - if (ConfAutocorRejection.value && - (AntiLambdaNegDaughIndex.at(i1) == AntiProtonIndex.at(i3) || - AntiLambdaNegDaughIndex.at(i2) == AntiProtonIndex.at(i3))) { - continue; - } - Q3 = getQ3(*iAntiLambda1, *iAntiLambda2, *iAntiProton1); - registry.fill(HIST("pll/fSE_antiparticle"), Q3); - registry.fill(HIST("pll/fAntiProtonPtVsQ3"), Q3, (*iAntiProton1).Pt()); - registry.fill(HIST("pll/fAntiLambdaPtVsQ3"), Q3, (*iAntiLambda1).Pt()); - registry.fill(HIST("pll/fAntiLambdaPtVsQ3"), Q3, (*iAntiLambda2).Pt()); - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kPLL)) { - if (ConfDownsample->get("Switch", "aPaLaL") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "aPaLaL")) { - registry.fill(HIST("pll/fSE_antiparticle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kPLL] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kPLL] += 1; - } + q3 = getQ3(vecAntiLambda.at(l1), vecAntiLambda.at(l2), vecAntiLambda.at(l3)); + registry.fill(HIST("PLL/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PLL/fZvtx"), col.posZ()); + registry.fill(HIST("PLL/fSE_particle"), q3); + registry.fill(HIST("PLL/fLambdaPtVsQ3"), vecAntiLambda.at(l1).Pt(), q3); + registry.fill(HIST("PLL/fLambdaPtVsQ3"), vecAntiLambda.at(l2).Pt(), q3); + registry.fill(HIST("PLL/fLambdaPtVsQ3"), vecAntiLambda.at(l3).Pt(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "LLL")) { + signalLooseLimit[cf_trigger::kLLL] += 1; + if (q3 < TriggerSelections.limits->get("Tight Limit", "LLL")) { + signalTightLimit[cf_trigger::kLLL] += 1; } } } } } - if (ConfTriggerSwitches->get("Switch", "LLL") > 0.) { - // lll trigger - for (auto iLambda1 = lambdas.begin(); iLambda1 != lambdas.end(); ++iLambda1) { - auto iLambda2 = iLambda1 + 1; - auto i1 = std::distance(lambdas.begin(), iLambda1); - for (; iLambda2 != lambdas.end(); ++iLambda2) { - auto i2 = std::distance(lambdas.begin(), iLambda2); - if (ConfAutocorRejection.value && - (LambdaPosDaughIndex.at(i1) == LambdaPosDaughIndex.at(i2) || - LambdaNegDaughIndex.at(i1) == LambdaNegDaughIndex.at(i2))) { + } + // PPPhi + if (TriggerSelections.filterSwitches->get("Switch", "PPPhi") > 0) { + for (size_t p1 = 0; p1 < vecProton.size(); p1++) { + for (size_t p2 = p1 + 1; p2 < vecProton.size(); p2++) { + for (size_t phi1 = 0; phi1 < vecPhi.size(); phi1++) { + if (idxProton.at(p1) == idxPhiDaughPos.at(phi1) || idxProton.at(p2) == idxPhiDaughPos.at(phi1)) { continue; } - auto iLambda3 = iLambda2 + 1; - for (; iLambda3 != lambdas.end(); ++iLambda3) { - auto i3 = std::distance(lambdas.begin(), iLambda3); - if (ConfAutocorRejection.value && - (LambdaPosDaughIndex.at(i1) == LambdaPosDaughIndex.at(i3) || - LambdaNegDaughIndex.at(i1) == LambdaNegDaughIndex.at(i3) || - LambdaPosDaughIndex.at(i2) == LambdaPosDaughIndex.at(i3) || - LambdaNegDaughIndex.at(i2) == LambdaNegDaughIndex.at(i3))) { - continue; - } - Q3 = getQ3(*iLambda1, *iLambda2, *iLambda3); - registry.fill(HIST("lll/fSE_particle"), Q3); - registry.fill(HIST("lll/fLambdaPtVsQ3"), Q3, (*iLambda1).Pt()); - registry.fill(HIST("lll/fLambdaPtVsQ3"), Q3, (*iLambda2).Pt()); - registry.fill(HIST("lll/fLambdaPtVsQ3"), Q3, (*iLambda3).Pt()); - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kLLL)) { - if (ConfDownsample->get("Switch", "LLL") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "LLL")) { - registry.fill(HIST("lll/fSE_particle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kLLL] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kLLL] += 1; - } + q3 = getQ3(vecProton.at(p1), vecProton.at(p2), vecPhi.at(phi1)); + registry.fill(HIST("PPPhi/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PPPhi/fZvtx"), col.posZ()); + registry.fill(HIST("PPPhi/fSE_particle"), q3); + registry.fill(HIST("PPPhi/fProtonPtVsQ3"), vecProton.at(p1).Pt(), q3); + registry.fill(HIST("PPPhi/fProtonPtVsQ3"), vecProton.at(p2).Pt(), q3); + registry.fill(HIST("PPPhi/fPhiPtVsQ3"), vecPhi.at(phi1).Pt(), q3); + registry.fill(HIST("PPPhi/fPhiInvMassVsQ3"), vecPhi.at(phi1).M(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "PPPhi")) { + if (q3 < TriggerSelections.limits->get("Tight Limit", "PPPhi") && + vecPhi.at(phi1).M() > PhiSelections.tightInvMassLow.value && vecPhi.at(phi1).M() < PhiSelections.tightInvMassUp.value) { + signalTightLimit[cf_trigger::kPPPhi] += 1; } } } } - for (auto iAntiLambda1 = antilambdas.begin(); iAntiLambda1 != antilambdas.end(); ++iAntiLambda1) { - auto iAntiLambda2 = iAntiLambda1 + 1; - auto i1 = std::distance(antilambdas.begin(), iAntiLambda1); - for (; iAntiLambda2 != antilambdas.end(); ++iAntiLambda2) { - auto i2 = std::distance(antilambdas.begin(), iAntiLambda2); - if (ConfAutocorRejection.value && - (AntiLambdaPosDaughIndex.at(i1) == AntiLambdaPosDaughIndex.at(i2) || - AntiLambdaNegDaughIndex.at(i1) == AntiLambdaNegDaughIndex.at(i2))) { + } + for (size_t p1 = 0; p1 < vecAntiProton.size(); p1++) { + for (size_t p2 = p1 + 1; p2 < vecAntiProton.size(); p2++) { + for (size_t phi1 = 0; phi1 < vecPhi.size(); phi1++) { + if (idxAntiProton.at(p1) == idxPhiDaughNeg.at(phi1) || idxAntiProton.at(p2) == idxPhiDaughNeg.at(phi1)) { continue; } - auto iAntiLambda3 = iAntiLambda2 + 1; - for (; iAntiLambda3 != antilambdas.end(); ++iAntiLambda3) { - auto i3 = std::distance(antilambdas.begin(), iAntiLambda3); - if (ConfAutocorRejection.value && - (AntiLambdaPosDaughIndex.at(i1) == AntiLambdaPosDaughIndex.at(i3) || - AntiLambdaNegDaughIndex.at(i1) == AntiLambdaNegDaughIndex.at(i3) || - AntiLambdaPosDaughIndex.at(i2) == AntiLambdaPosDaughIndex.at(i3) || - AntiLambdaNegDaughIndex.at(i2) == AntiLambdaNegDaughIndex.at(i3))) { - continue; - } - Q3 = getQ3(*iAntiLambda1, *iAntiLambda2, *iAntiLambda3); - registry.fill(HIST("lll/fSE_antiparticle"), Q3); - registry.fill(HIST("lll/fAntiLambdaPtVsQ3"), Q3, (*iAntiLambda1).Pt()); - registry.fill(HIST("lll/fAntiLambdaPtVsQ3"), Q3, (*iAntiLambda2).Pt()); - registry.fill(HIST("lll/fAntiLambdaPtVsQ3"), Q3, (*iAntiLambda3).Pt()); - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kLLL)) { - if (ConfDownsample->get("Switch", "aLaLaL") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "aLaLaL")) { - registry.fill(HIST("lll/fSE_antiparticle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kLLL] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kLLL] += 1; - } + q3 = getQ3(vecAntiProton.at(p1), vecAntiProton.at(p2), vecPhi.at(phi1)); + registry.fill(HIST("PPPhi/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PPPhi/fZvtx"), col.posZ()); + registry.fill(HIST("PPPhi/fSE_particle"), q3); + registry.fill(HIST("PPPhi/fAntiProtonPtVsQ3"), vecAntiProton.at(p1).Pt(), q3); + registry.fill(HIST("PPPhi/fAntiProtonPtVsQ3"), vecAntiProton.at(p2).Pt(), q3); + registry.fill(HIST("PPPhi/fPhiPtVsQ3"), vecPhi.at(phi1).Pt(), q3); + registry.fill(HIST("PPPhi/fPhiInvMassVsQ3"), vecPhi.at(phi1).M(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "PPPhi")) { + if (q3 < TriggerSelections.limits->get("Tight Limit", "PPPhi") && + vecPhi.at(phi1).M() > PhiSelections.tightInvMassLow.value && vecPhi.at(phi1).M() < PhiSelections.tightInvMassUp.value) { + signalTightLimit[cf_trigger::kPPPhi] += 1; } } } } } - if (ConfTriggerSwitches->get("Switch", "ppPhi") > 0.) { - // ppphi trigger - for (auto iProton1 = protons.begin(); iProton1 != protons.end(); ++iProton1) { - auto iProton2 = iProton1 + 1; - for (; iProton2 != protons.end(); ++iProton2) { - for (auto iPhi1 = phi.begin(); iPhi1 != phi.end(); ++iPhi1) { - Q3 = getQ3(*iProton1, *iProton2, *iPhi1); - registry.fill(HIST("ppphi/fSE_particle"), Q3); - registry.fill(HIST("ppphi/fProtonPtVsQ3"), Q3, (*iProton1).Pt()); - registry.fill(HIST("ppphi/fProtonPtVsQ3"), Q3, (*iProton2).Pt()); - registry.fill(HIST("ppphi/fPhiPtVsQ3"), Q3, (*iPhi1).Pt()); - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kPPPhi)) { - if (ConfDownsample->get("Switch", "PPPhi") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "PPPhi")) { - registry.fill(HIST("ppphi/fSE_particle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kPPPhi] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kPPPhi] += 1; - } + } + // PPRho + if (TriggerSelections.filterSwitches->get("Switch", "PPRho") > 0) { + for (size_t p1 = 0; p1 < vecProton.size(); p1++) { + for (size_t p2 = p1 + 1; p2 < vecProton.size(); p2++) { + for (size_t r1 = 0; r1 < vecRho.size(); r1++) { + if (idxProton.at(p1) == idxRhoDaughPos.at(r1) || idxProton.at(p2) == idxRhoDaughPos.at(r1)) { + continue; + } + q3 = getQ3(vecProton.at(p1), vecProton.at(p2), vecRho.at(r1)); + registry.fill(HIST("PPRho/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PPRho/fZvtx"), col.posZ()); + registry.fill(HIST("PPRho/fSE_particle"), q3); + registry.fill(HIST("PPRho/fProtonPtVsQ3"), vecProton.at(p1).Pt(), q3); + registry.fill(HIST("PPRho/fProtonPtVsQ3"), vecProton.at(p2).Pt(), q3); + registry.fill(HIST("PPRho/fRhoPtVsQ3"), vecRho.at(r1).Pt(), q3); + registry.fill(HIST("PPRho/fRhoInvMassVsQ3"), vecRho.at(r1).M(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "PPRho")) { + if (q3 < TriggerSelections.limits->get("Tight Limit", "PPRho") && + vecRho.at(r1).M() > RhoSelections.tightInvMassLow.value && vecRho.at(r1).M() < RhoSelections.tightInvMassUp.value) { + signalTightLimit[cf_trigger::kPPRho] += 1; } } } } - // apapphi trigger - for (auto iAntiProton1 = antiprotons.begin(); iAntiProton1 != antiprotons.end(); ++iAntiProton1) { - auto iAntiProton2 = iAntiProton1 + 1; - for (; iAntiProton2 != antiprotons.end(); ++iAntiProton2) { - for (auto iPhi1 = phi.begin(); iPhi1 != phi.end(); ++iPhi1) { - Q3 = getQ3(*iAntiProton1, *iAntiProton2, *iPhi1); - registry.fill(HIST("ppphi/fSE_antiparticle"), Q3); - registry.fill(HIST("ppphi/fAntiProtonPtVsQ3"), Q3, (*iAntiProton1).Pt()); - registry.fill(HIST("ppphi/fAntiProtonPtVsQ3"), Q3, (*iAntiProton2).Pt()); - registry.fill(HIST("ppphi/fAntiPhiPtVsQ3"), Q3, (*iPhi1).Pt()); - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kPPPhi)) { - if (ConfDownsample->get("Switch", "aPaPPhi") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "aPaPPhi")) { - registry.fill(HIST("ppphi/fSE_antiparticle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kPPPhi] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kPPPhi] += 1; - } + } + for (size_t p1 = 0; p1 < vecAntiProton.size(); p1++) { + for (size_t p2 = p1 + 1; p2 < vecAntiProton.size(); p2++) { + for (size_t r1 = 0; r1 < vecRho.size(); r1++) { + if (idxAntiProton.at(p1) == idxRhoDaughNeg.at(r1) || idxAntiProton.at(p2) == idxRhoDaughNeg.at(r1)) { + continue; + } + q3 = getQ3(vecAntiProton.at(p1), vecAntiProton.at(p2), vecRho.at(r1)); + registry.fill(HIST("PPRho/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PPRho/fZvtx"), col.posZ()); + registry.fill(HIST("PPRho/fSE_antiparticle"), q3); + registry.fill(HIST("PPRho/fAntiProtonPtVsQ3"), vecAntiProton.at(p1).Pt(), q3); + registry.fill(HIST("PPRho/fAntiProtonPtVsQ3"), vecAntiProton.at(p2).Pt(), q3); + registry.fill(HIST("PPRho/fRhoPtVsQ3"), vecRho.at(r1).Pt(), q3); + registry.fill(HIST("PPRho/fRhoInvMassVsQ3"), vecRho.at(r1).M(), q3); + if (q3 < TriggerSelections.limits->get("Loose Limit", "PPRho")) { + if (q3 < TriggerSelections.limits->get("Tight Limit", "PPRho") && + vecRho.at(r1).M() > RhoSelections.tightInvMassLow.value && vecRho.at(r1).M() < RhoSelections.tightInvMassUp.value) { + signalTightLimit[cf_trigger::kPPRho] += 1; } } } } } - if (ConfTriggerSwitches->get("Switch", "ppRho") > 0.) { - // ppRho trigger - for (size_t i = 0; i < protons.size(); ++i) { - for (size_t j = i + 1; j < protons.size(); ++j) { - for (const auto& rhoParticle : rho) { - const auto& Proton1 = protons[i]; - const auto& Proton2 = protons[j]; - - Q3 = getQ3(Proton1, Proton2, rhoParticle); - - registry.fill(HIST("ppRho/fSE_particle"), Q3); - registry.fill(HIST("ppRho/fProtonPtVsQ3"), Q3, Proton1.Pt()); - registry.fill(HIST("ppRho/fProtonPtVsQ3"), Q3, Proton2.Pt()); - registry.fill(HIST("ppRho/fRhoCandPtVsQ3"), Q3, rhoParticle.Pt()); - - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kPPRho)) { - if (ConfDownsample->get("Switch", "PPRho") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "PPRho")) { - registry.fill(HIST("ppRho/fSE_particle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kPPRho] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kPPRho] += 1; - } - } + } + // PD + if (TriggerSelections.filterSwitches->get("Switch", "PD") > 0) { + for (size_t p1 = 0; p1 < vecProton.size(); p1++) { + for (size_t d1 = 0; d1 < vecDeuteron.size(); d1++) { + if (idxProton.at(p1) == idxDeuteron.at(d1)) { + continue; + } + kstar = getkstar(vecProton.at(p1), vecDeuteron.at(d1)); + registry.fill(HIST("PD/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PD/fZvtx"), col.posZ()); + registry.fill(HIST("PD/fSE_particle"), kstar); + registry.fill(HIST("PD/fProtonPtVskstar"), vecProton.at(p1).Pt(), kstar); + registry.fill(HIST("PD/fDeuteronPtVskstar"), vecDeuteron.at(d1).Pt(), kstar); + if (kstar < TriggerSelections.limits->get("Loose Limit", "PD")) { + signalLooseLimit[cf_trigger::kPD] += 1; + if (kstar < TriggerSelections.limits->get("Tight Limit", "PD")) { + signalTightLimit[cf_trigger::kPD] += 1; } } } - // apapRho trigger - for (size_t i = 0; i < antiprotons.size(); ++i) { - for (size_t j = i + 1; j < antiprotons.size(); ++j) { - for (const auto& rhoParticle : rho) { - const auto& antiProton1 = antiprotons[i]; - const auto& antiProton2 = antiprotons[j]; - - Q3 = getQ3(antiProton1, antiProton2, rhoParticle); - - registry.fill(HIST("ppRho/fSE_antiparticle"), Q3); - registry.fill(HIST("ppRho/fAntiProtonPtVsQ3"), Q3, antiProton1.Pt()); - registry.fill(HIST("ppRho/fAntiProtonPtVsQ3"), Q3, antiProton2.Pt()); - registry.fill(HIST("ppRho/fRhoCandPtVsQ3"), Q3, rhoParticle.Pt()); - - if (Q3 < ConfQ3Limits->get(static_cast(0), CFTrigger::kPPRho)) { - if (ConfDownsample->get("Switch", "aPaPRho") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "aPaPRho")) { - registry.fill(HIST("ppRho/fSE_antiparticle_downsample"), Q3); - lowQ3Triplets[CFTrigger::kPPRho] += 1; - } - } else { - lowQ3Triplets[CFTrigger::kPPRho] += 1; - } - } + } + for (size_t p1 = 0; p1 < vecAntiProton.size(); p1++) { + for (size_t d1 = 0; d1 < vecAntiDeuteron.size(); d1++) { + if (idxAntiProton.at(p1) == idxAntiDeuteron.at(d1)) { + continue; + } + kstar = getkstar(vecAntiProton.at(p1), vecAntiDeuteron.at(d1)); + registry.fill(HIST("PD/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PD/fZvtx"), col.posZ()); + registry.fill(HIST("PD/fSE_antiparticle"), kstar); + registry.fill(HIST("PD/fAntiProtonPtVskstar"), vecAntiProton.at(p1).Pt(), kstar); + registry.fill(HIST("PD/fAntiDeuteronPtVskstar"), vecAntiDeuteron.at(d1).Pt(), kstar); + if (kstar < TriggerSelections.limits->get("Loose Limit", "PD")) { + signalLooseLimit[cf_trigger::kPD] += 1; + if (kstar < TriggerSelections.limits->get("Tight Limit", "PD")) { + signalTightLimit[cf_trigger::kPD] += 1; } } } } - - if (ConfTriggerSwitches->get("Switch", "pd") > 0.) { - // pd trigger - for (auto iProton = protons.begin(); iProton != protons.end(); ++iProton) { - for (auto iDeuteron = deuterons.begin(); iDeuteron != deuterons.end(); ++iDeuteron) { - kstar = getkstar(*iProton, *iDeuteron); - registry.fill(HIST("pd/fSE_particle"), kstar); - registry.fill(HIST("pd/fProtonPtVskstar"), kstar, (*iProton).Pt()); - registry.fill(HIST("pd/fDeuteronPtVskstar"), kstar, (*iDeuteron).Pt()); - if (kstar < ConfKstarLimits->get(static_cast(0), CFTrigger::kPD)) { - if (ConfDownsample->get("Switch", "PD") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "PD")) { - registry.fill(HIST("pd/fSE_particle_downsample"), kstar); - lowKstarPairs[CFTrigger::kPD] += 1; - } - } else { - lowKstarPairs[CFTrigger::kPD] += 1; - } + } + // LD + if (TriggerSelections.filterSwitches->get("Switch", "LD") > 0) { + for (size_t l1 = 0; l1 < vecLambda.size(); l1++) { + for (size_t d1 = 0; d1 < vecDeuteron.size(); d1++) { + if (idxLambdaDaughProton.at(l1) == idxDeuteron.at(d1)) { + continue; + } + kstar = getkstar(vecLambda.at(l1), vecDeuteron.at(d1)); + registry.fill(HIST("LD/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("LD/fZvtx"), col.posZ()); + registry.fill(HIST("LD/fSE_particle"), kstar); + registry.fill(HIST("LD/fLambdaPtVskstar"), vecLambda.at(l1).Pt(), kstar); + registry.fill(HIST("LD/fDeuteronPtVskstar"), vecDeuteron.at(d1).Pt(), kstar); + if (kstar < TriggerSelections.limits->get("Loose Limit", "LD")) { + signalLooseLimit[cf_trigger::kLD] += 1; + if (kstar < TriggerSelections.limits->get("Tight Limit", "LD")) { + signalTightLimit[cf_trigger::kLD] += 1; } } } - - for (auto iAntiProton = antiprotons.begin(); iAntiProton != antiprotons.end(); ++iAntiProton) { - for (auto iAntiDeuteron = antideuterons.begin(); iAntiDeuteron != antideuterons.end(); ++iAntiDeuteron) { - kstar = getkstar(*iAntiProton, *iAntiDeuteron); - registry.fill(HIST("pd/fSE_antiparticle"), kstar); - registry.fill(HIST("pd/fAntiProtonPtVskstar"), kstar, (*iAntiProton).Pt()); - registry.fill(HIST("pd/fAntiDeuteronPtVskstar"), kstar, (*iAntiDeuteron).Pt()); - if (kstar < ConfKstarLimits->get(static_cast(0), CFTrigger::kPD)) { - if (ConfDownsample->get("Switch", "aPaD") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "aPaD")) { - registry.fill(HIST("pd/fSE_antiparticle_downsample"), kstar); - lowKstarPairs[CFTrigger::kPD] += 1; - } - } else { - lowKstarPairs[CFTrigger::kPD] += 1; - } + } + for (size_t l1 = 0; l1 < vecAntiLambda.size(); l1++) { + for (size_t d1 = 0; d1 < vecAntiDeuteron.size(); d1++) { + if (idxAntiLambdaDaughProton.at(l1) == idxAntiDeuteron.at(d1)) { + continue; + } + kstar = getkstar(vecAntiLambda.at(l1), vecAntiDeuteron.at(d1)); + registry.fill(HIST("LD/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("LD/fZvtx"), col.posZ()); + registry.fill(HIST("LD/fSE_antiparticle"), kstar); + registry.fill(HIST("LD/fAntiLambdaPtVskstar"), vecAntiLambda.at(l1).Pt(), kstar); + registry.fill(HIST("LD/fAntiDeuteronPtVskstar"), vecAntiDeuteron.at(d1).Pt(), kstar); + if (kstar < TriggerSelections.limits->get("Loose Limit", "LD")) { + signalLooseLimit[cf_trigger::kLD] += 1; + if (kstar < TriggerSelections.limits->get("Tight Limit", "LD")) { + signalTightLimit[cf_trigger::kLD] += 1; } } } } - if (ConfTriggerSwitches->get("Switch", "Ld") > 0.) { - // ld trigger - for (auto iDeuteron = deuterons.begin(); iDeuteron != deuterons.end(); ++iDeuteron) { - for (auto iLambda = lambdas.begin(); iLambda != lambdas.end(); ++iLambda) { - kstar = getkstar(*iDeuteron, *iLambda); - registry.fill(HIST("ld/fSE_particle"), kstar); - registry.fill(HIST("ld/fDeuteronPtVskstar"), kstar, (*iDeuteron).Pt()); - registry.fill(HIST("ld/fLambdaPtVskstar"), kstar, (*iLambda).Pt()); - if (kstar < ConfKstarLimits->get(static_cast(0), CFTrigger::kLD)) { - if (ConfDownsample->get("Switch", "LD") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "LD")) { - registry.fill(HIST("ld/fSE_particle_downsample"), kstar); - lowKstarPairs[CFTrigger::kLD] += 1; - } - } else { - lowKstarPairs[CFTrigger::kLD] += 1; - } + } + // PhiD + if (TriggerSelections.filterSwitches->get("Switch", "PhiD") > 0) { + for (size_t phi1 = 0; phi1 < vecPhi.size(); phi1++) { + for (size_t d1 = 0; d1 < vecDeuteron.size(); d1++) { + if (idxPhiDaughPos.at(phi1) == idxDeuteron.at(d1)) { + continue; + } + kstar = getkstar(vecPhi.at(phi1), vecDeuteron.at(d1)); + registry.fill(HIST("PhiD/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PhiD/fZvtx"), col.posZ()); + registry.fill(HIST("PhiD/fSE_particle"), kstar); + registry.fill(HIST("PhiD/fPhiPtVskstar"), vecPhi.at(phi1).Pt(), kstar); + registry.fill(HIST("PhiD/fDeuteronPtVskstar"), vecDeuteron.at(d1).Pt(), kstar); + registry.fill(HIST("PhiD/fPhiInvMassVskstar"), vecPhi.at(phi1).M(), kstar); + if (kstar < TriggerSelections.limits->get("Loose Limit", "PhiD")) { + signalLooseLimit[cf_trigger::kPhiD] += 1; + if (kstar < TriggerSelections.limits->get("Tight Limit", "PhiD") && + vecPhi.at(phi1).M() > PhiSelections.tightInvMassLow.value && vecPhi.at(phi1).M() < PhiSelections.tightInvMassUp.value) { + signalTightLimit[cf_trigger::kPhiD] += 1; } } } - for (auto iAntiDeuteron = antideuterons.begin(); iAntiDeuteron != antideuterons.end(); ++iAntiDeuteron) { - for (auto iAntiLambda = antilambdas.begin(); iAntiLambda != antilambdas.end(); ++iAntiLambda) { - kstar = getkstar(*iAntiDeuteron, *iAntiLambda); - registry.fill(HIST("ld/fSE_antiparticle"), kstar); - registry.fill(HIST("ld/fAntiDeuteronPtVskstar"), kstar, (*iAntiDeuteron).Pt()); - registry.fill(HIST("ld/fAntiLambdaPtVskstar"), kstar, (*iAntiLambda).Pt()); - if (kstar < ConfKstarLimits->get(static_cast(0), CFTrigger::kLD)) { - if (ConfDownsample->get("Switch", "aLaD") > 0) { - if (rng->Uniform(0., 1.) < ConfDownsample->get("Factor", "aLaD")) { - registry.fill(HIST("ld/fSE_antiparticle_downsample"), kstar); - lowKstarPairs[CFTrigger::kLD] += 1; - } - } else { - lowKstarPairs[CFTrigger::kLD] += 1; - } + } + for (size_t phi1 = 0; phi1 < vecPhi.size(); phi1++) { + for (size_t d1 = 0; d1 < vecAntiDeuteron.size(); d1++) { + if (idxPhiDaughNeg.at(phi1) == idxAntiDeuteron.at(d1)) { + continue; + } + kstar = getkstar(vecPhi.at(phi1), vecAntiDeuteron.at(d1)); + registry.fill(HIST("PhiD/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("PhiD/fZvtx"), col.posZ()); + registry.fill(HIST("PhiD/fSE_antiparticle"), kstar); + registry.fill(HIST("PhiD/fPhiPtVskstar"), vecPhi.at(phi1).Pt(), kstar); + registry.fill(HIST("PhiD/fAntiDeuteronPtVskstar"), vecAntiDeuteron.at(d1).Pt(), kstar); + registry.fill(HIST("PhiD/fPhiInvMassVskstar"), vecPhi.at(phi1).M(), kstar); + if (kstar < TriggerSelections.limits->get("Loose Limit", "PhiD")) { + signalLooseLimit[cf_trigger::kPhiD] += 1; + if (kstar < TriggerSelections.limits->get("Tight Limit", "PhiD") && + vecPhi.at(phi1).M() > PhiSelections.tightInvMassLow.value && vecPhi.at(phi1).M() < PhiSelections.tightInvMassUp.value) { + signalTightLimit[cf_trigger::kPhiD] += 1; } } } } - } // if(isSelectedEvent) - - // create tags for three body triggers - if (lowQ3Triplets[CFTrigger::kPPP] > 0) { - keepEvent3N[CFTrigger::kPPP] = true; - registry.fill(HIST("fProcessedEvents"), 2); - registry.fill(HIST("ppp/fMultiplicity"), col.multNTracksPV()); - registry.fill(HIST("ppp/fZvtx"), col.posZ()); - } - if (lowQ3Triplets[CFTrigger::kPPL] > 0) { - keepEvent3N[CFTrigger::kPPL] = true; - registry.fill(HIST("fProcessedEvents"), 3); - registry.fill(HIST("ppl/fMultiplicity"), col.multNTracksPV()); - registry.fill(HIST("ppl/fZvtx"), col.posZ()); } - if (lowQ3Triplets[CFTrigger::kPLL] > 0) { - keepEvent3N[CFTrigger::kPLL] = true; - registry.fill(HIST("fProcessedEvents"), 4); - registry.fill(HIST("pll/fMultiplicity"), col.multNTracksPV()); - registry.fill(HIST("pll/fZvtx"), col.posZ()); - } - if (lowQ3Triplets[CFTrigger::kLLL] > 0) { - keepEvent3N[CFTrigger::kLLL] = true; - registry.fill(HIST("fProcessedEvents"), 5); - registry.fill(HIST("lll/fMultiplicity"), col.multNTracksPV()); - registry.fill(HIST("lll/fZvtx"), col.posZ()); - } - if (lowQ3Triplets[CFTrigger::kPPPhi] > 0) { - keepEvent3N[CFTrigger::kPPPhi] = true; - registry.fill(HIST("fProcessedEvents"), 6); - registry.fill(HIST("ppphi/fMultiplicity"), col.multNTracksPV()); - registry.fill(HIST("ppphi/fZvtx"), col.posZ()); - } - if (lowQ3Triplets[CFTrigger::kPPRho] > 0) { - keepEvent3N[CFTrigger::kPPRho] = true; - registry.fill(HIST("fProcessedEvents"), 7); - registry.fill(HIST("ppRho/fMultiplicity"), col.multNTracksPV()); - registry.fill(HIST("ppRho/fZvtx"), col.posZ()); + // RhoD + if (TriggerSelections.filterSwitches->get("Switch", "RhoD") > 0) { + for (size_t r1 = 0; r1 < vecRho.size(); r1++) { + for (size_t d1 = 0; d1 < vecDeuteron.size(); d1++) { + if (idxRhoDaughPos.at(r1) == idxDeuteron.at(d1)) { + continue; + } + kstar = getkstar(vecRho.at(r1), vecDeuteron.at(d1)); + registry.fill(HIST("RhoD/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("RhoD/fZvtx"), col.posZ()); + registry.fill(HIST("RhoD/fSE_particle"), kstar); + registry.fill(HIST("RhoD/fRhoPtVskstar"), vecRho.at(r1).Pt(), kstar); + registry.fill(HIST("RhoD/fDeuteronPtVskstar"), vecDeuteron.at(d1).Pt(), kstar); + registry.fill(HIST("RhoD/fRhoInvMassVskstar"), vecRho.at(r1).M(), kstar); + if (kstar < TriggerSelections.limits->get("Loose Limit", "RhoD")) { + signalLooseLimit[cf_trigger::kRhoD] += 1; + if (kstar < TriggerSelections.limits->get("Tight Limit", "RhoD") && + vecRho.at(r1).M() > RhoSelections.tightInvMassLow.value && vecRho.at(r1).M() < RhoSelections.tightInvMassUp.value) { + signalTightLimit[cf_trigger::kRhoD] += 1; + } + } + } + } + for (size_t r1 = 0; r1 < vecRho.size(); r1++) { + for (size_t d1 = 0; d1 < vecAntiDeuteron.size(); d1++) { + if (idxRhoDaughNeg.at(r1) == idxAntiDeuteron.at(d1)) { + continue; + } + kstar = getkstar(vecRho.at(r1), vecAntiDeuteron.at(d1)); + registry.fill(HIST("RhoD/fMultiplicity"), col.multNTracksPV()); + registry.fill(HIST("RhoD/fZvtx"), col.posZ()); + registry.fill(HIST("RhoD/fSE_antiparticle"), kstar); + registry.fill(HIST("RhoD/fRhoPtVskstar"), vecRho.at(r1).Pt(), kstar); + registry.fill(HIST("RhoD/fAntiDeuteronPtVskstar"), vecAntiDeuteron.at(d1).Pt(), kstar); + registry.fill(HIST("RhoD/fRhoInvMassVskstar"), vecRho.at(r1).M(), kstar); + if (kstar < TriggerSelections.limits->get("Loose Limit", "RhoD")) { + signalLooseLimit[cf_trigger::kRhoD] += 1; + if (kstar < TriggerSelections.limits->get("Tight Limit", "RhoD") && + vecRho.at(r1).M() > RhoSelections.tightInvMassLow.value && vecRho.at(r1).M() < RhoSelections.tightInvMassUp.value) { + signalTightLimit[cf_trigger::kRhoD] += 1; + } + } + } + } } - // create tags for two body triggers - if (lowKstarPairs[CFTrigger::kPD] > 0) { - keepEvent2N[CFTrigger::kPD] = true; - registry.fill(HIST("fProcessedEvents"), 8); - registry.fill(HIST("pd/fMultiplicity"), col.multNTracksPV()); - registry.fill(HIST("pd/fZvtx"), col.posZ()); - } - if (lowKstarPairs[CFTrigger::kLD] > 0) { - keepEvent2N[CFTrigger::kLD] = true; - registry.fill(HIST("fProcessedEvents"), 9); - registry.fill(HIST("ld/fMultiplicity"), col.multNTracksPV()); - registry.fill(HIST("ld/fZvtx"), col.posZ()); + for (int i = 0; i < cf_trigger::kNTriggers; i++) { + if (signalLooseLimit[i] > 0) { + registry.fill(HIST("fProcessedEvents"), 3 + 2 * i); // need offset for filling + keepEventLooseLimit[i] = true; + } + if (signalTightLimit[i] > 0) { + registry.fill(HIST("fProcessedEvents"), 3 + 2 * i + 1); // need offset for filling + keepEventTightLimit[i] = true; + } + for (int j = i; j < cf_trigger::kNTriggers; j++) { + if (signalLooseLimit[i] > 0 && signalLooseLimit[j]) { + registry.fill(HIST("fTriggerCorrelations"), 2 * i, 2 * j); + } + if (signalLooseLimit[i] > 0 && signalTightLimit[j]) { // only one combination needed, fill only entries above diagonal + registry.fill(HIST("fTriggerCorrelations"), 2 * i, 2 * j + 1); + } + if (signalTightLimit[i] > 0 && signalTightLimit[j]) { + registry.fill(HIST("fTriggerCorrelations"), 2 * i + 1, 2 * j + 1); + } + } } - tags(keepEvent3N[CFTrigger::kPPP], - keepEvent3N[CFTrigger::kPPL], - keepEvent3N[CFTrigger::kPLL], - keepEvent3N[CFTrigger::kLLL], - keepEvent3N[CFTrigger::kPPPhi], - // keepEvent3N[CFTrigger::kPPRho], //To be changed once trigger is integrated - keepEvent2N[CFTrigger::kPD], - keepEvent2N[CFTrigger::kLD]); - - if (!keepEvent3N[CFTrigger::kPPP] && !keepEvent3N[CFTrigger::kPPL] && !keepEvent3N[CFTrigger::kPLL] && !keepEvent3N[CFTrigger::kLLL] && !keepEvent3N[CFTrigger::kPPPhi] && !keepEvent3N[CFTrigger::kPPRho] && - !keepEvent2N[CFTrigger::kPD] && !keepEvent2N[CFTrigger::kLD]) { + if (keepEventLooseLimit[cf_trigger::kPPP] || + keepEventLooseLimit[cf_trigger::kPPL] || + keepEventLooseLimit[cf_trigger::kPLL] || + keepEventLooseLimit[cf_trigger::kLLL] || + keepEventLooseLimit[cf_trigger::kPPPhi] || + keepEventLooseLimit[cf_trigger::kPPRho] || + keepEventLooseLimit[cf_trigger::kPD] || + keepEventLooseLimit[cf_trigger::kLD] || + keepEventLooseLimit[cf_trigger::kPhiD] || + keepEventLooseLimit[cf_trigger::kRhoD]) { registry.fill(HIST("fProcessedEvents"), 1); } - } + + if (keepEventTightLimit[cf_trigger::kPPP] || + keepEventTightLimit[cf_trigger::kPPL] || + keepEventTightLimit[cf_trigger::kPLL] || + keepEventTightLimit[cf_trigger::kLLL] || + keepEventTightLimit[cf_trigger::kPPPhi] || + keepEventTightLimit[cf_trigger::kPPRho] || + keepEventTightLimit[cf_trigger::kPD] || + keepEventTightLimit[cf_trigger::kLD] || + keepEventTightLimit[cf_trigger::kPhiD] || + keepEventTightLimit[cf_trigger::kRhoD]) { + registry.fill(HIST("fProcessedEvents"), 2); + } + + tags(keepEventTightLimit[cf_trigger::kPPP], keepEventLooseLimit[cf_trigger::kPPP], + keepEventTightLimit[cf_trigger::kPPL], keepEventLooseLimit[cf_trigger::kPPL], + keepEventTightLimit[cf_trigger::kPLL], keepEventLooseLimit[cf_trigger::kPLL], + keepEventTightLimit[cf_trigger::kLLL], keepEventLooseLimit[cf_trigger::kLLL], + keepEventTightLimit[cf_trigger::kPPPhi], keepEventLooseLimit[cf_trigger::kPPPhi], + keepEventTightLimit[cf_trigger::kPPRho], keepEventLooseLimit[cf_trigger::kPPRho], + keepEventTightLimit[cf_trigger::kPD], keepEventLooseLimit[cf_trigger::kPD], + keepEventTightLimit[cf_trigger::kLD], keepEventLooseLimit[cf_trigger::kLD], + keepEventTightLimit[cf_trigger::kPhiD], keepEventLooseLimit[cf_trigger::kPhiD], + keepEventTightLimit[cf_trigger::kRhoD], keepEventLooseLimit[cf_trigger::kRhoD]); + }; }; WorkflowSpec defineDataProcessing(ConfigContext const& cfg) { - return WorkflowSpec{adaptAnalysisTask(cfg)}; + return WorkflowSpec{adaptAnalysisTask(cfg)}; } diff --git a/EventFiltering/PWGEM/HeavyNeutralMesonFilter.cxx b/EventFiltering/PWGEM/HeavyNeutralMesonFilter.cxx index a2941317ec6..5d8fd72ba39 100644 --- a/EventFiltering/PWGEM/HeavyNeutralMesonFilter.cxx +++ b/EventFiltering/PWGEM/HeavyNeutralMesonFilter.cxx @@ -11,13 +11,12 @@ /// /// \file HeavyNeutralMesonFilter.cxx /// -/// \brief This code loops over collisions to filter events contaning heavy mesons (omega or eta') using EMCal clusters and V0s (PCM) +/// \brief This code loops over collisions to filter events contaning heavy neutral mesons (omega or eta') using EMCal clusters and V0s (PCM) /// -/// \author Nicolas Strangmann (nicolas.strangmann@cern.ch) - Goethe University Frankfurt; Maximilian Korwieser (maximilian.korwieser@cern.ch) - Technical University Munich +/// \author Nicolas Strangmann (nicolas.strangmann@cern.ch) - Goethe University Frankfurt; Maximilian Korwieser (maximilian.korwieser@cern.ch) - Technical University Munich /// #include -#include #include #include @@ -27,6 +26,7 @@ #include "TRandom3.h" #include "PWGEM/PhotonMeson/Utils/HNMUtilities.h" +#include "PWGJE/DataModel/EMCALMatchedCollisions.h" #include "Common/DataModel/PIDResponse.h" #include "Common/DataModel/PIDResponseITS.h" @@ -51,16 +51,16 @@ using namespace o2::aod::pwgem::photonmeson; namespace o2::aod { using MyBCs = soa::Join; -using MyCollisions = soa::Join; +using MyCollisions = soa::Join; using MyCollision = MyCollisions::iterator; using SelectedTracks = soa::Join; } // namespace o2::aod -namespace CFTrigger +namespace hnmtrigger { -enum CFFemtoTriggers { +enum FemtoTriggers { kPPOmega, kPPEtaPrime, kOmegaD, @@ -70,7 +70,7 @@ enum CFFemtoTriggers { kNFemtoTriggers }; -enum FemtoPartners { +enum TracksPID { kProton, kDeuteron, kPion, @@ -84,13 +84,10 @@ enum PIDLimits { kTPCMin, kITSmax, kNPIDLimits }; -const std::vector SpeciesName{"proton", "Deuteron", "pion"}; // ToDo include charged pions - -const std::vector PtCutsName{"Pt min", "Pt max", "P TOF thres"}; - -const std::vector PidCutsName{"TPC min", "TPC max", "TPCTOF max", "ITS min", "ITS max"}; - -const std::vector FemtoFilterNames{"PPOmega", "PPEtaPrime", "Omegad", "EtaPrimed", "OmegaP", "EtaPrimeP"}; +const std::vector speciesName{"proton", "Deuteron", "pion"}; +const std::vector pTCutsName{"Pt min", "Pt max", "P TOF thres"}; +const std::vector pidCutsName{"TPC min", "TPC max", "TPCTOF max", "ITS min", "ITS max"}; +const std::vector femtoFilterNames{"PPOmega", "PPEtaPrime", "Omegad", "EtaPrimed", "OmegaP", "EtaPrimeP"}; // configs for tracks const float pidcutsTable[kNFemtoPartners][kNPIDLimits]{ @@ -103,165 +100,117 @@ const float ptcutsTable[kNFemtoPartners][3]{ {0.55f, 2.f, 1.2f}, {0.35f, 6.f, 0.75f}}; -const float TPCNClustersMin[1][kNFemtoPartners]{ - {80.0f, 80.0f, 80.0f}}; -const float ITSNClustersMin[1][kNFemtoPartners]{ - {4, 4, 4}}; +const float nClusterMinTPC[1][kNFemtoPartners]{{80.0f, 80.0f, 80.0f}}; +const float nClusterMinITS[1][kNFemtoPartners]{{4, 4, 4}}; -static const float triggerSwitches[1][kNFemtoTriggers]{ - {1, 1, 1, 1, 1, 1}}; -const float TriggerLimits[1][kNFemtoTriggers]{ - {1.f, 1.f, 1.f, 1.f, 1.f, 1.f}}; -} // namespace CFTrigger +static const float triggerSwitches[1][kNFemtoTriggers]{{1, 1, 1, 1, 1, 1}}; +const float triggerLimits[1][kNFemtoTriggers]{{1.f, 1.f, 1.f, 1.f, 1.f, 1.f}}; +} // namespace hnmtrigger struct HeavyNeutralMesonFilter { + Produces tags; + + // --------------------------------> Configurables <------------------------------------ + // - Event selection cuts + // - Track selection cuts + // - Cluster shifts + // - HNM mass selection windows + // - HNM min pTs / k*'s + // ------------------------------------------------------------------------------------- + // ---> Event selection + Configurable confEvtSelectZvtx{"confEvtSelectZvtx", true, "Event selection includes max. z-Vertex"}; + Configurable confEvtZvtx{"confEvtZvtx", 10.f, "Evt sel: Max. z-Vertex (cm)"}; + Configurable confEvtRequireSel8{"confEvtRequireSel8", false, "Evt sel: check for offline selection (sel8)"}; + + // ---> Track selection + Configurable> cfgPtCuts{"cfgPtCuts", {hnmtrigger::ptcutsTable[0], hnmtrigger::kNFemtoPartners, 3, hnmtrigger::speciesName, hnmtrigger::pTCutsName}, "Track pT selections"}; + Configurable cfgTrkEta{"cfgTrkEta", 0.9, "Eta"}; + Configurable> cfgTPCNClustersMin{"cfgTPCNClustersMin", {hnmtrigger::nClusterMinTPC[0], 1, hnmtrigger::kNFemtoPartners, std::vector{"TPCNClusMin"}, hnmtrigger::speciesName}, "Mininum of TPC Clusters"}; + Configurable cfgTrkTPCfCls{"cfgTrkTPCfCls", 0.83, "Minimum fraction of crossed rows over findable clusters"}; + Configurable cfgTrkTPCcRowsMin{"cfgTrkTPCcRowsMin", 70, "Minimum number of crossed TPC rows"}; + Configurable cfgTrkTPCsClsSharedFrac{"cfgTrkTPCsClsSharedFrac", 1.f, "Fraction of shared TPC clusters"}; + Configurable> cfgTrkITSnclsMin{"cfgTrkITSnclsMin", {hnmtrigger::nClusterMinITS[0], 1, hnmtrigger::kNFemtoPartners, std::vector{"Cut"}, hnmtrigger::speciesName}, "Minimum number of ITS clusters"}; + Configurable cfgTrkDCAxyMax{"cfgTrkDCAxyMax", 0.15, "Maximum DCA_xy"}; + Configurable cfgTrkDCAzMax{"cfgTrkDCAzMax", 0.3, "Maximum DCA_z"}; + Configurable cfgTrkMaxChi2PerClusterTPC{"cfgTrkMaxChi2PerClusterTPC", 4.0f, "Minimal track selection: max allowed chi2 per TPC cluster"}; // 4.0 is default of global tracks on 20.01.2023 + Configurable cfgTrkMaxChi2PerClusterITS{"cfgTrkMaxChi2PerClusterITS", 36.0f, "Minimal track selection: max allowed chi2 per ITS cluster"}; // 36.0 is default of global tracks on 20.01.2023 + + Configurable> cfgPIDCuts{"cfgPIDCuts", {hnmtrigger::pidcutsTable[0], hnmtrigger::kNFemtoPartners, hnmtrigger::kNPIDLimits, hnmtrigger::speciesName, hnmtrigger::pidCutsName}, "Femtopartner PID nsigma selections"}; // PID selections + + // ---> Configurables to allow for a shift in eta/phi of EMCal clusters to better align with extrapolated TPC tracks + Configurable cfgDoEMCShift{"cfgDoEMCShift", false, "Apply SM-wise shift in eta and phi to EMCal clusters to align with TPC tracks"}; + Configurable> cfgEMCEtaShift{"cfgEMCEtaShift", {0.f}, "values for SM-wise shift in eta to be added to EMCal clusters to align with TPC tracks"}; + Configurable> cfgEMCPhiShift{"cfgEMCPhiShift", {0.f}, "values for SM-wise shift in phi to be added to EMCal clusters to align with TPC tracks"}; + static const int nSMs = 20; + std::array emcEtaShift = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + std::array emcPhiShift = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + + // ---> Shift the omega/eta' mass based on the difference of the reconstructed mass of the pi0/eta to its PDG mass to reduce smearing caused by EMCal/PCM in photon measurement + Configurable cfgHNMMassCorrection{"cfgHNMMassCorrection", 1, "Use GG PDG mass to correct HNM mass (0 = off, 1 = subDeltaPi0, 2 = subLambda)"}; + + // ---> Mass windows for the selection of heavy neutral mesons (also based on mass of their light neutral meson decay daughter) + static constexpr float DefaultMassWindows[2][4] = {{0., 0.4, 0.6, 1.}, {0.4, 0.8, 0.8, 1.2}}; + Configurable> cfgMassWindowOmega{"cfgMassWindowOmega", {DefaultMassWindows[0], 4, {"pi0_min", "pi0_max", "omega_min", "omega_max"}}, "Mass window for selected omegas and their decay pi0"}; + Configurable> cfgMassWindowEtaPrime{"cfgMassWindowEtaPrime", {DefaultMassWindows[1], 4, {"eta_min", "eta_max", "etaprime_min", "etaprime_max"}}, "Mass window for selected eta' and their decay eta"}; - Configurable> ConfTriggerSwitches{ - "ConfTriggerSwitches", - {CFTrigger::triggerSwitches[0], 1, CFTrigger::kNFemtoTriggers, std::vector{"Switch"}, CFTrigger::FemtoFilterNames}, - "Turn on specific trigger"}; - - Configurable ConfKeepTwoBody{ - "ConfKeepTwoBody", - true, - "Turn on specific trigger selection"}; - - // PID selections - Configurable> - ConfPIDCuts{ - "ConfPIDCuts", - {CFTrigger::pidcutsTable[0], CFTrigger::kNFemtoPartners, CFTrigger::kNPIDLimits, CFTrigger::SpeciesName, CFTrigger::PidCutsName}, - "Femtopartner PID nsigma selections"}; - - Configurable> ConfPtCuts{ - "ConfPtCuts", - {CFTrigger::ptcutsTable[0], CFTrigger::kNFemtoPartners, 3, CFTrigger::SpeciesName, CFTrigger::PtCutsName}, - "Femtopartner pT selections"}; - - Configurable ConfTrkEta{ - "ConfTrkEta", - 0.9, - "Eta"}; - - Configurable> ConfTPCNClustersMin{ - "ConfTPCNClustersMin", - {CFTrigger::TPCNClustersMin[0], 1, CFTrigger::kNFemtoPartners, std::vector{"TPCNClusMin"}, CFTrigger::SpeciesName}, - "Mininum of TPC Clusters"}; - - Configurable ConfTrkTPCfCls{ - "ConfTrkTPCfCls", - 0.83, - "Minimum fraction of crossed rows over findable clusters"}; - Configurable ConfTrkTPCcRowsMin{ - "ConfTrkTPCcRowsMin", - 70, - "Minimum number of crossed TPC rows"}; - Configurable ConfTrkTPCsClsSharedFrac{ - "ConfTrkTPCsClsSharedFrac", - 1.f, - "Fraction of shared TPC clusters"}; - - Configurable> ConfTrkITSnclsMin{ - "ConfTrkITSnclsMin", - {CFTrigger::ITSNClustersMin[0], 1, CFTrigger::kNFemtoPartners, std::vector{"Cut"}, CFTrigger::SpeciesName}, - "Minimum number of ITS clusters"}; - - Configurable ConfTrkDCAxyMax{ - "ConfTrkDCAxyMax", - 0.15, - "Maximum DCA_xy"}; - Configurable ConfTrkDCAzMax{ - "ConfTrkDCAzMax", - 0.3, - "Maximum DCA_z"}; - - Configurable - ConfTrkMaxChi2PerClusterTPC{ - "ConfTrkMaxChi2PerClusterTPC", - 4.0f, - "Minimal track selection: max allowed chi2 per TPC cluster"}; // 4.0 is default of - // global tracks - // on 20.01.2023 - Configurable - ConfTrkMaxChi2PerClusterITS{ - "ConfTrkMaxChi2PerClusterITS", - 36.0f, - "Minimal track selection: max allowed chi2 per ITS cluster"}; // 36.0 is default of - // global tracks - // on 20.01.2023 - - Configurable> ConfKinematicLimits{ - "ConfKstarLimits", - {CFTrigger::TriggerLimits[0], 1, CFTrigger::kNFemtoTriggers, std::vector{"Limit"}, CFTrigger::FemtoFilterNames}, - "hypermomentum limit for two body trigger"}; - - // Configs for events - Configurable ConfEvtSelectZvtx{ - "ConfEvtSelectZvtx", - true, - "Event selection includes max. z-Vertex"}; - Configurable ConfEvtZvtx{"ConfEvtZvtx", - 10.f, - "Evt sel: Max. z-Vertex (cm)"}; - Configurable ConfEvtOfflineCheck{ - "ConfEvtOfflineCheck", - false, - "Evt sel: check for offline selection"}; - - Configurable ConfDoEMCShift{"ConfDoEMCShift", false, "Apply SM-wise shift in eta and phi to EMCal clusters to align with TPC tracks"}; - Configurable> ConfEMCEtaShift{"ConfEMCEtaShift", {0.f}, "values for SM-wise shift in eta to be added to EMCal clusters to align with TPC tracks"}; - Configurable> ConfEMCPhiShift{"ConfEMCPhiShift", {0.f}, "values for SM-wise shift in phi to be added to EMCal clusters to align with TPC tracks"}; - std::array EMCEtaShift = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; - std::array EMCPhiShift = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + // ---> Minimum pT values for the trigger decisions of the spectra and femto trigger. The femto triggers additionally require a given k*/Q3 + static constexpr float DefaultSpectraMinPts[4] = {1.8, 1.8, 2.6, 2.6}; + static constexpr float DefaultFemtoMinPts[4] = {1.8, 1.8, 2.6, 2.6}; + Configurable> cfgMinHNMPtsSpectrumTrigger{"cfgMinHNMPtsSpectrumTrigger", {DefaultSpectraMinPts, 4, {"PCM_omega", "PCM_etaprime", "EMC_omega", "EMC_etaprime"}}, "Minimum pT values for the spetra trigger decisions (GeV/c)"}; + Configurable> cfgMinHNMPtsFemtoTrigger{"cfgMinHNMPtsFemtoTrigger", {DefaultFemtoMinPts, 4, {"PCM_omega", "PCM_etaprime", "EMC_omega", "EMC_etaprime"}}, "Minimum pT values for the femto trigger decisions (GeV/c)"}; + Configurable> cfgKinematicLimits{"cfgKinematicLimits", {hnmtrigger::triggerLimits[0], 1, hnmtrigger::kNFemtoTriggers, std::vector{"Limit"}, hnmtrigger::femtoFilterNames}, "Maximum K* (Q_3) for two (three) body femto trigger"}; + + Configurable> cfgTriggerSwitches{"cfgTriggerSwitches", {hnmtrigger::triggerSwitches[0], 1, hnmtrigger::kNFemtoTriggers, std::vector{"Switch"}, hnmtrigger::femtoFilterNames}, "Turn on specific trigger"}; + + HistogramRegistry mHistManager{"HeavyNeutralMesonFilterHistograms", {}, OutputObjHandlingPolicy::AnalysisObject}; + + // Prepare vectors for different species + std::vector vGGs; + std::vector vHNMs; + std::vector etaPrimeEMC, etaPrimePCM, omegaEMC, omegaPCM, proton, antiproton, deuteron, antideuteron, pion, antipion; + float mMassProton = constants::physics::MassProton; + float mMassDeuteron = constants::physics::MassDeuteron; + float mMassOmega = 0.782; + float mMassEtaPrime = 0.957; + float mMassPionCharged = constants::physics::MassPionCharged; + + Preslice perCollisionPCM = aod::v0photonkf::collisionId; + Preslice perCollisionEMC = aod::skimmedcluster::collisionId; + + bool colContainsPCMOmega, colContainsEMCOmega, colContainsPCMEtaPrime, colContainsEMCEtaPrime = false; template - bool isSelectedTrack(T const& track, CFTrigger::FemtoPartners partSpecies) + bool isSelectedTrack(T const& track, hnmtrigger::TracksPID partSpecies) { - const auto pT = track.pt(); - const auto eta = track.eta(); - const auto tpcNClsF = track.tpcNClsFound(); - const auto tpcRClsC = track.tpcCrossedRowsOverFindableCls(); - const auto tpcNClsC = track.tpcNClsCrossedRows(); - const auto tpcNClsSFrac = track.tpcFractionSharedCls(); - const auto itsNCls = track.itsNCls(); - const auto dcaXY = track.dcaXY(); - const auto dcaZ = track.dcaZ(); - - if (pT < ConfPtCuts->get(partSpecies, "Pt min")) { + if (track.pt() < cfgPtCuts->get(partSpecies, "Pt min")) return false; - } - if (pT > ConfPtCuts->get(partSpecies, "Pt max")) { + if (track.pt() > cfgPtCuts->get(partSpecies, "Pt max")) return false; - } - if (std::abs(eta) > ConfTrkEta) { + if (std::abs(track.eta()) > cfgTrkEta) return false; - } - if (tpcNClsF < ConfTPCNClustersMin->get("TPCNClusMin", partSpecies)) { + if (track.tpcNClsFound() < cfgTPCNClustersMin->get("TPCNClusMin", partSpecies)) return false; - } - if (tpcRClsC < ConfTrkTPCfCls) { + if (track.tpcCrossedRowsOverFindableCls() < cfgTrkTPCfCls) return false; - } - if (tpcNClsC < ConfTrkTPCcRowsMin) { + if (track.tpcNClsCrossedRows() < cfgTrkTPCcRowsMin) return false; - } - if (tpcNClsSFrac > ConfTrkTPCsClsSharedFrac) { + if (track.tpcFractionSharedCls() > cfgTrkTPCsClsSharedFrac) return false; - } - if (itsNCls < ConfTrkITSnclsMin->get(static_cast(0), partSpecies)) { + if (track.itsNCls() < cfgTrkITSnclsMin->get(static_cast(0), partSpecies)) return false; - } - if (std::abs(dcaXY) > ConfTrkDCAxyMax) { + if (std::abs(track.dcaXY()) > cfgTrkDCAxyMax) return false; - } - if (std::abs(dcaZ) > ConfTrkDCAzMax) { + if (std::abs(track.dcaZ()) > cfgTrkDCAzMax) + return false; + if (track.tpcChi2NCl() > cfgTrkMaxChi2PerClusterTPC) + return false; + if (track.itsChi2NCl() > cfgTrkMaxChi2PerClusterITS) return false; - } return true; } template - bool isSelectedTrackPID(T const& track, CFTrigger::FemtoPartners partSpecies) + bool isSelectedTrackPID(T const& track, hnmtrigger::TracksPID partSpecies) { // nSigma should have entries [proton, deuteron, pion] bool isSelected = false; @@ -270,20 +219,18 @@ struct HeavyNeutralMesonFilter { float nSigmaTrackTOF = -999.f; float nSigmaTrackITS = -999.f; - float nSigmaTrackTPCTOF = -999.f; - switch (partSpecies) { - case CFTrigger::kProton: + case hnmtrigger::kProton: nSigmaTrackTPC = track.tpcNSigmaPr(); nSigmaTrackTOF = track.tofNSigmaPr(); nSigmaTrackITS = track.itsNSigmaPr(); break; - case CFTrigger::kDeuteron: + case hnmtrigger::kDeuteron: nSigmaTrackTPC = track.tpcNSigmaDe(); nSigmaTrackTOF = track.tofNSigmaDe(); nSigmaTrackITS = track.itsNSigmaDe(); break; - case CFTrigger::kPion: + case hnmtrigger::kPion: nSigmaTrackTPC = track.tpcNSigmaPi(); nSigmaTrackTOF = track.tofNSigmaPi(); nSigmaTrackITS = track.itsNSigmaPi(); @@ -292,24 +239,17 @@ struct HeavyNeutralMesonFilter { LOG(fatal) << "Particle species not known"; } - nSigmaTrackTPCTOF = std::sqrt(std::pow(nSigmaTrackTPC, 2) + std::pow(nSigmaTrackTOF, 2)); - - // check if track is selected - auto TPCmin = ConfPIDCuts->get(partSpecies, CFTrigger::kTPCMin); - auto TPCmax = ConfPIDCuts->get(partSpecies, CFTrigger::kTPCMax); - auto TPCTOFmax = ConfPIDCuts->get(partSpecies, CFTrigger::kTPCTOF); - auto ITSmin = ConfPIDCuts->get(partSpecies, CFTrigger::kITSmin); - auto ITSmax = ConfPIDCuts->get(partSpecies, CFTrigger::kITSmax); + float nSigmaTrackTPCTOF = std::sqrt(std::pow(nSigmaTrackTPC, 2) + std::pow(nSigmaTrackTOF, 2)); - if (track.p() <= ConfPtCuts->get(partSpecies, "P TOF thres")) { - if (nSigmaTrackTPC > TPCmin && - nSigmaTrackTPC < TPCmax && - nSigmaTrackITS > ITSmin && - nSigmaTrackITS < ITSmax) { + if (track.p() <= cfgPtCuts->get(partSpecies, "P TOF thres")) { + if (nSigmaTrackTPC > cfgPIDCuts->get(partSpecies, hnmtrigger::kTPCMin) && + nSigmaTrackTPC < cfgPIDCuts->get(partSpecies, hnmtrigger::kTPCMax) && + nSigmaTrackITS > cfgPIDCuts->get(partSpecies, hnmtrigger::kITSmin) && + nSigmaTrackITS < cfgPIDCuts->get(partSpecies, hnmtrigger::kITSmax)) { isSelected = true; } } else { - if (nSigmaTrackTPCTOF < TPCTOFmax) { + if (nSigmaTrackTPCTOF < cfgPIDCuts->get(partSpecies, hnmtrigger::kTPCTOF)) { isSelected = true; } } @@ -319,12 +259,10 @@ struct HeavyNeutralMesonFilter { template bool isSelectedEvent(T const& col) { - if (ConfEvtSelectZvtx && std::abs(col.posZ()) > ConfEvtZvtx) { + if (confEvtSelectZvtx && std::abs(col.posZ()) > confEvtZvtx) return false; - } - if (ConfEvtOfflineCheck && !col.sel8()) { + if (confEvtRequireSel8 && !col.sel8()) return false; - } return true; } @@ -333,18 +271,15 @@ struct HeavyNeutralMesonFilter { { const ROOT::Math::PtEtaPhiMVector trackSum = part1 + part2; const float beta = trackSum.Beta(); - const float betax = - beta * std::cos(trackSum.Phi()) * std::sin(trackSum.Theta()); - const float betay = - beta * std::sin(trackSum.Phi()) * std::sin(trackSum.Theta()); + const float betax = beta * std::cos(trackSum.Phi()) * std::sin(trackSum.Theta()); + const float betay = beta * std::sin(trackSum.Phi()) * std::sin(trackSum.Theta()); const float betaz = beta * std::cos(trackSum.Theta()); - ROOT::Math::PxPyPzMVector PartOneCMS(part1); - ROOT::Math::PxPyPzMVector PartTwoCMS(part2); - const ROOT::Math::Boost boostPRF = - ROOT::Math::Boost(-betax, -betay, -betaz); - PartOneCMS = boostPRF(PartOneCMS); - PartTwoCMS = boostPRF(PartTwoCMS); - const ROOT::Math::PxPyPzMVector trackRelK = PartOneCMS - PartTwoCMS; + ROOT::Math::PxPyPzMVector partOneCMS(part1); + ROOT::Math::PxPyPzMVector partTwoCMS(part2); + const ROOT::Math::Boost boostPRF = ROOT::Math::Boost(-betax, -betay, -betaz); + partOneCMS = boostPRF(partOneCMS); + partTwoCMS = boostPRF(partTwoCMS); + const ROOT::Math::PxPyPzMVector trackRelK = partOneCMS - partTwoCMS; return 0.5 * trackRelK.P(); } @@ -365,447 +300,169 @@ struct HeavyNeutralMesonFilter { ROOT::Math::PxPyPzEVector q12 = getqij(part1, part2); ROOT::Math::PxPyPzEVector q23 = getqij(part2, part3); ROOT::Math::PxPyPzEVector q31 = getqij(part3, part1); - float Q32 = q12.M2() + q23.M2() + q31.M2(); - return sqrt(-Q32); - } - - // Circumvent missing of different phi mappings, enforce [0, 2 * M_PI] - // Tracks have domain [0, 2 * M_PI] - // TLorentVectors have domain [-M_PI, M_PI] - double translatePhi(double phi) - { - if (phi < 0) { - phi += 2 * M_PI; // Add 2 pi to make it positive - } - return phi; + float q32 = q12.M2() + q23.M2() + q31.M2(); + return std::sqrt(-q32); } - Produces tags; - - HistogramRegistry mHistManager{"HeavyNeutralMesonFilterHistograms", {}, OutputObjHandlingPolicy::AnalysisObject}; - - Configurable cfgHNMMassCorrection{"cfgHNMMassCorrection", 1, "Use GG PDG mass to correct HNM mass (0 = off, 1 = subDeltaPi0, 2 = subLambda)"}; - static constexpr float defaultMassWindows[2][4] = {{0., 0.4, 0.6, 1.}, {0.4, 0.8, 0.8, 1.2}}; - Configurable> massWindowOmega{"massWindowOmega", {defaultMassWindows[0], 4, {"pi0_min", "pi0_max", "omega_min", "omega_max"}}, "Mass window for selected omegas and their decay pi0"}; - Configurable> massWindowEtaPrime{"massWindowEtaPrime", {defaultMassWindows[1], 4, {"eta_min", "eta_max", "etaprime_min", "etaprime_max"}}, "Mass window for selected eta' and their decay eta"}; - - static constexpr float defaultMinPts[4] = {1.8, 1.8, 2.6, 2.6}; - static constexpr float defaultFemtoMinPts[4] = {1.8, 1.8, 2.6, 2.6}; - - Configurable> minHNMPts{"minHNMPts", {defaultMinPts, 4, {"PCM_omega", "PCM_etaprime", "EMC_omega", "EMC_etaprime"}}, "Minimum pT values for the trigger decisions (GeV/c)"}; - - Configurable> minFemtoHNMPts{"minFemtoHNMPts", {defaultFemtoMinPts, 4, {"PCM_omega", "PCM_etaprime", "EMC_omega", "EMC_etaprime"}}, "Minimum pT values for the femto trigger decisions (GeV/c)"}; - - std::vector vGGs; - std::vector vHNMs; - - bool colContainsPCMOmega, colContainsEMCOmega, colContainsPCMEtaPrime, colContainsEMCEtaPrime = false; - - emcal::Geometry* emcalGeom; - - // Femto - // Prepare vectors for different species - std::vector etaPrimeEMC, etaPrimePCM, omegaEMC, omegaPCM, proton, antiproton, deuteron, antideuteron, pion, antipion; - float mMassProton = o2::constants::physics::MassProton; - float mMassDeuteron = o2::constants::physics::MassDeuteron; - float mMassOmega = 0.782; - float mMassEtaPrime = 0.957; - float mMassPionCharged = o2::constants::physics::MassPionCharged; - void init(InitContext const&) { - emcalGeom = emcal::Geometry::GetInstanceFromRunNumber(300000); - auto hCollisionCounter = mHistManager.add("Event/hCollisionCounter", "Number of collisions;;#bf{#it{N}_{Coll}}", HistType::kTH1F, {{6, -0.5, 5.5}}); - hCollisionCounter->GetXaxis()->SetBinLabel(1, "all"); - hCollisionCounter->GetXaxis()->SetBinLabel(2, "kTVXinEMC"); - hCollisionCounter->GetXaxis()->SetBinLabel(3, "PCM #omega"); - hCollisionCounter->GetXaxis()->SetBinLabel(4, "EMC #omega"); - hCollisionCounter->GetXaxis()->SetBinLabel(5, "PCM #eta'"); - hCollisionCounter->GetXaxis()->SetBinLabel(6, "EMC #eta'"); - - mHistManager.add("Event/nGGs", "Number of (selected) #gamma#gamma paris;#bf{#it{N}_{#gamma#gamma}};#bf{#it{N}_{#gamma#gamma}^{selected}}", HistType::kTH2F, {{51, -0.5, 50.5}, {51, -0.5, 50.5}}); - mHistManager.add("Event/nTracks", "Number of tracks;#bf{N_{tracks}};#bf{#it{N}_{Coll}}", HistType::kTH1F, {{51, -0.5, 50.5}}); - mHistManager.add("Event/nHeavyNeutralMesons", "Number of (selected) HNM candidates;#bf{#it{N}_{HNM}};#bf{#it{N}_{HNM}^{selected}}", HistType::kTH2F, {{51, -0.5, 50.5}, {51, -0.5, 50.5}}); - mHistManager.add("Event/nClustersVsV0s", "Number of clusters and V0s in the collision;#bf{#it{N}_{clusters}};#bf{#it{N}_{V0s}}", HistType::kTH2F, {{26, -0.5, 25.5}, {26, -0.5, 25.5}}); - - mHistManager.add("GG/invMassVsPt_PCM", "Invariant mass and pT of gg candidates;#bf{#it{M}_{#gamma#gamma}};#bf{#it{pT}_{#gamma#gamma}}", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}}); - mHistManager.add("GG/invMassVsPt_PCMEMC", "Invariant mass and pT of gg candidates;#bf{#it{M}_{#gamma#gamma}};#bf{#it{pT}_{#gamma#gamma}}", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}}); - mHistManager.add("GG/invMassVsPt_EMC", "Invariant mass and pT of gg candidates;#bf{#it{M}_{#gamma#gamma}};#bf{#it{pT}_{#gamma#gamma}}", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}}); - - mHistManager.add("Omega/invMassVsPt_PCM", "Invariant mass and pT of omega meson candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.6, 1.}, {250, 0., 25.}}); - mHistManager.add("Omega/invMassVsPt_PCMEMC", "Invariant mass and pT of omega meson candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.6, 1.}, {250, 0., 25.}}); - mHistManager.add("Omega/invMassVsPt_EMC", "Invariant mass and pT of omega meson candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.6, 1.}, {250, 0., 25.}}); - - mHistManager.add("EtaPrime/invMassVsPt_PCM", "Invariant mass and pT of eta' candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.8, 1.2}, {250, 0., 25.}}); - mHistManager.add("EtaPrime/invMassVsPt_PCMEMC", "Invariant mass and pT of eta' candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.8, 1.2}, {250, 0., 25.}}); - mHistManager.add("EtaPrime/invMassVsPt_EMC", "Invariant mass and pT of eta' candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.8, 1.2}, {250, 0., 25.}}); - - // include all femto histograms - mHistManager.add("fProcessedEvents", "CF - event filtered;;Events", HistType::kTH1F, {{15, -0.5, 14.5}}); - std::vector eventTitles = {"all", "rejected", "PPOmega", "PPEtaPrime", "Omegad", "EtaPrimed", "OmegaP", "EtaPrimeP", "kTVXinEMC", "PCM #omega", "EMC #omega", "PCM #eta'", "EMC #eta'"}; - for (size_t iBin = 0; iBin < eventTitles.size(); iBin++) { - mHistManager.get(HIST("fProcessedEvents"))->GetXaxis()->SetBinLabel(iBin + 1, eventTitles[iBin].data()); - } - - // event cuts - mHistManager.add("EventCuts/fMultiplicityBefore", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - mHistManager.add("EventCuts/fMultiplicityAfter", "Multiplicity after event cuts;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - mHistManager.add("EventCuts/fZvtxBefore", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - mHistManager.add("EventCuts/fZvtxAfter", "Zvtx after event cuts;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - - // mom correlations p vs pTPC - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationPos", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationNeg", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); + mHistManager.add("Event/nGGs", "Number of (selected) #gamma#gamma paris;#bf{#it{N}^{#gamma#gamma}};#bf{#it{N}_{selected}^{#gamma#gamma}}", HistType::kTH2F, {{51, -0.5, 50.5}, {51, -0.5, 50.5}}); + mHistManager.add("Event/nHeavyNeutralMesons", "Number of (selected) HNM candidates;#bf{#it{N}^{HNM}};#bf{#it{N}_{selected}^{HNM}}", HistType::kTH2F, {{51, -0.5, 50.5}, {51, -0.5, 50.5}}); + mHistManager.add("Event/nClustersVsV0s", "Number of clusters and V0s in the collision;#bf{#it{N}^{clusters}};#bf{#it{N}^{V0s}}", HistType::kTH2F, {{26, -0.5, 25.5}, {26, -0.5, 25.5}}); + mHistManager.add("Event/nEMCalEvents", "Number of collisions with a certain combination of EMCal triggers;;#bf{#it{N}_{collisions}}", HistType::kTH1F, {{5, -0.5, 4.5}}); + std::vector nEventTitles = {"Cells & kTVXinEMC", "Cells & L0", "Cells & !kTVXinEMC & !L0", "!Cells & kTVXinEMC", "!Cells & L0"}; + for (size_t iBin = 0; iBin < nEventTitles.size(); iBin++) + mHistManager.get(HIST("Event/nEMCalEvents"))->GetXaxis()->SetBinLabel(iBin + 1, nEventTitles[iBin].data()); + mHistManager.add("Event/fMultiplicityBefore", "Multiplicity of all processed events;#bf{#it{N}_{tracks}};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, 0, 500}}); + mHistManager.add("Event/fMultiplicityAfter", "Multiplicity after event cuts;#bf{#it{N}_{tracks}};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, 0, 500}}); + mHistManager.add("Event/fZvtxBefore", "Zvtx of all processed events;#bf{z_{vtx} (cm)};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, -15, 15}}); + mHistManager.add("Event/fZvtxAfter", "Zvtx after event cuts;#bf{z_{vtx} (cm)};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, -15, 15}}); + mHistManager.add("fProcessedEvents", "CF - event filtered;;Events", HistType::kTH1F, {{12, -0.5, 11.5}}); + std::vector pEventTitles = {"all", "rejected", "PCM #omega", "EMC #omega", "PCM #eta'", "EMC #eta'", "PPOmega", "PPEtaPrime", "Omegad", "EtaPrimed", "OmegaP", "EtaPrimeP"}; + for (size_t iBin = 0; iBin < pEventTitles.size(); iBin++) + mHistManager.get(HIST("fProcessedEvents"))->GetXaxis()->SetBinLabel(iBin + 1, pEventTitles[iBin].data()); + + mHistManager.add("GG/invMassVsPt_PCM", "Invariant mass and pT of gg candidates;#bf{#it{M}^{#gamma#gamma} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#gamma#gamma} (GeV/#it{c})}", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}}); + mHistManager.add("GG/invMassVsPt_PCMEMC", "Invariant mass and pT of gg candidates;#bf{#it{M}^{#gamma#gamma} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#gamma#gamma} (GeV/#it{c})}", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}}); + mHistManager.add("GG/invMassVsPt_EMC", "Invariant mass and pT of gg candidates;#bf{#it{M}^{#gamma#gamma} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#gamma#gamma} (GeV/#it{c})}", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}}); + + // Momentum correlations p vs p_TPC + mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationPos", "fMomCorrelation;#bf{#it{p} (GeV/#it{c})};#bf{#it{p}_{TPC} (GeV/#it{c})}", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); + mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationNeg", "fMomCorrelation;#bf{#it{p} (GeV/#it{c})};#bf{#it{p}_{TPC} (GeV/#it{c})}", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); + + // All tracks + mHistManager.add("TrackCuts/TracksBefore/fPtTrackBefore", "Transverse momentum of all processed tracks;#bf{#it{p}_{T} (GeV/#it{c})};#bf{#it{N}_{tracks}}", HistType::kTH1F, {{500, 0, 10}}); + mHistManager.add("TrackCuts/TracksBefore/fEtaTrackBefore", "Pseudorapidity of all processed tracks;#eta;#bf{#it{N}_{tracks}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("TrackCuts/TracksBefore/fPhiTrackBefore", "Azimuthal angle of all processed tracks;#phi;#bf{#it{N}_{tracks}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsProton", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiProton", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsDeuteron", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiDeuteron", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); + // TPC signal + mHistManager.add("TrackCuts/TPCSignal/fTPCSignalTPCP", "TPCSignal;#bf{#it{p}_{TPC} (GeV/#it{c})};#bf{TPC d#it{E}/d#it{x}}", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); + mHistManager.add("TrackCuts/TPCSignal/fTPCSignal", "TPCSignalP;#bf{#it{p} (GeV/#it{c})};#bf{TPC d#it{E}/d#it{x}}", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); + // TPC signal antiparticles (negative charge) + mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAntiTPCP", "TPCSignal;#bf{#it{p}_{TPC} (GeV/#it{c})};#bf{TPC d#it{E}/d#it{x}}", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); + mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAnti", "TPCSignalP;#bf{#it{p} (GeV/#it{c})};#bf{TPC d#it{E}/d#it{x}}", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); + + const int nTrackSpecies = 2 * hnmtrigger::kNFemtoPartners; // x2 because of anti particles + const char* particleSpecies[nTrackSpecies] = {"Proton", "AntiProton", "Deuteron", "AntiDeuteron", "Pion", "AntiPion"}; + const char* particleSpeciesLatex[nTrackSpecies] = {"p", "#bar{p}", "d", "#bar{d}", "#pi^{+}", "#pi^{-}"}; + + for (int iParticle = 0; iParticle < nTrackSpecies; iParticle++) { + mHistManager.add(Form("TrackCuts/TracksBefore/fMomCorrelationAfterCuts%s", particleSpecies[iParticle]), Form("%s momentum correlation;#bf{#it{p} (GeV/#it{c})};#bf{#it{p}_{TPC} (GeV/#it{c})}", particleSpecies[iParticle]), {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); + mHistManager.add(Form("TrackCuts/TPCSignal/fTPCSignal%s", particleSpecies[iParticle]), Form("%s TPC energy loss;#bf{#it{p}_{TPC}^{%s} (GeV/#it{c})};#bf{TPC d#it{E}/d#it{x}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); + + mHistManager.add(Form("TrackCuts/%s/fP", particleSpecies[iParticle]), Form("%s momentum at PV;#bf{#it{p}^{%s} (GeV/#it{c})};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, 0, 10}}); + mHistManager.add(Form("TrackCuts/%s/fPt", particleSpecies[iParticle]), Form("%s transverse momentum;#bf{#it{p}_{T}^{%s} (GeV/#it{c})};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, 0, 10}}); + mHistManager.add(Form("TrackCuts/%s/fMomCorDif", particleSpecies[iParticle]), Form("Momentum correlation;#bf{#it{p}^{%s} (GeV/#it{c})};#bf{#it{p}_{TPC}^{%s} - #it{p}^{%s} (GeV/#it{c})}", particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); + mHistManager.add(Form("TrackCuts/%s/fMomCorRatio", particleSpecies[iParticle]), Form("Relative momentum correlation;#bf{#it{p}^{%s} (GeV/#it{c})};#bf{#it{p}_{TPC}^{%s} - #it{p}^{%s} / #it{p}^{%s}}", particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); + mHistManager.add(Form("TrackCuts/%s/fEta", particleSpecies[iParticle]), Form("%s pseudorapidity distribution;#eta;#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add(Form("TrackCuts/%s/fPhi", particleSpecies[iParticle]), Form("%s azimuthal angle distribution;#phi;#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + + mHistManager.add(Form("TrackCuts/%s/fNsigmaTPCvsTPCP", particleSpecies[iParticle]), Form("NSigmaTPC %s;#bf{#it{p}_{TPC}^{%s} (GeV/#it{c})};#bf{n#sigma_{TPC}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaTOFvsTPCP", particleSpecies[iParticle]), Form("NSigmaTOF %s;#bf{#it{p}_{TPC}^{%s} (GeV/#it{c})};#bf{n#sigma_{TOF}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaTPCTOFvsTPCP", particleSpecies[iParticle]), Form("NSigmaTPCTOF %s;#bf{#it{p}_{TPC}^{%s} (GeV/#it{c})};n#sigma_{comb}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaITSvsP", particleSpecies[iParticle]), Form("NSigmaITS %s;#bf{#it{p}^{%s} (GeV/#it{c})};#bf{n#sigma_{ITS}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaTPCvsP", particleSpecies[iParticle]), Form("NSigmaTPC %s P;#bf{#it{p}^{%s} (GeV/#it{c})};#bf{n#sigma_{TPC}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaTOFvsP", particleSpecies[iParticle]), Form("NSigmaTOF %s P;#bf{#it{p}^{%s} (GeV/#it{c})};#bf{n#sigma_{TOF}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaTPCTOFvsP", particleSpecies[iParticle]), Form("NSigmaTPCTOF %s P;#bf{#it{p}^{%s} (GeV/#it{c})};#bf{n#sigma_{comb}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); + + mHistManager.add(Form("TrackCuts/%s/fDCAxy", particleSpecies[iParticle]), Form("fDCAxy %s;#bf{DCA_{xy}};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, -0.5f, 0.5f}}); + mHistManager.add(Form("TrackCuts/%s/fDCAz", particleSpecies[iParticle]), Form("fDCAz %s;#bf{DCA_{z}};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, -0.5f, 0.5f}}); + mHistManager.add(Form("TrackCuts/%s/fTPCsCls", particleSpecies[iParticle]), Form("fTPCsCls %s;#bf{TPC Shared Clusters};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{163, -1.0f, 162.0f}}); + mHistManager.add(Form("TrackCuts/%s/fTPCcRows", particleSpecies[iParticle]), Form("fTPCcRows %s;#bf{TPC Crossed Rows};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{163, -1.0f, 162.0f}}); + mHistManager.add(Form("TrackCuts/%s/fTrkTPCfCls", particleSpecies[iParticle]), Form("fTrkTPCfCls %s;#bf{TPC Findable/CrossedRows};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, 0.0f, 3.0f}}); + mHistManager.add(Form("TrackCuts/%s/fTPCncls", particleSpecies[iParticle]), Form("fTPCncls %s;#bf{TPC Clusters};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{163, -1.0f, 162.0f}}); + } - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsPion", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{1000, 0.0f, 20.0f}, {1000, 0.0f, 20.0f}}}); - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiPion", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{1000, 0.0f, 20.0f}, {1000, 0.0f, 20.0f}}}); + // --> HNM QA + // pi+ daughter + mHistManager.add("HNM/Before/PosDaughter/fInvMass", "Invariant mass HMN Pos Daugh;#bf{#it{M}^{#pi^{+}} (GeV/#it{c}^{2})};#bf{#it{N}^{#pi^{+}}}", HistType::kTH1F, {{200, 0, 0.2}}); + mHistManager.add("HNM/Before/PosDaughter/fPt", "Transverse momentum HMN Pos Daugh tracks;#bf{#it{p}_{T} (GeV/#it{c})};#bf{#it{N}^{#pi^{+}}}", HistType::kTH1F, {{500, 0, 10}}); + mHistManager.add("HNM/Before/PosDaughter/fEta", "HMN Pos Daugh Eta;#eta;#bf{#it{N}^{#pi^{+}}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("HNM/Before/PosDaughter/fPhi", "Azimuthal angle of HMN Pos Daugh tracks;#phi;#bf{#it{N}^{#pi^{+}}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + // pi- daughter + mHistManager.add("HNM/Before/NegDaughter/fInvMass", "Invariant mass HMN Neg Daugh;#bf{#it{M}^{#pi^{-}} (GeV/#it{c}^{2})};#bf{#it{N}^{#pi^{-}}}", HistType::kTH1F, {{200, 0, 0.2}}); + mHistManager.add("HNM/Before/NegDaughter/fPt", "Transverse momentum HMN Neg Daugh tracks;#bf{#it{p}_{T} (GeV/#it{c})};#bf{#it{N}^{#pi^{-}}}", HistType::kTH1F, {{500, 0, 10}}); + mHistManager.add("HNM/Before/NegDaughter/fEta", "HMN Neg Daugh Eta;#eta;#bf{#it{N}^{#pi^{-}}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("HNM/Before/NegDaughter/fPhi", "Azimuthal angle of HMN Neg Daugh tracks;#phi;#bf{#it{N}^{#pi^{-}}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + // Properties of the pi+pi- pair + mHistManager.add("HNM/Before/PiPlPiMi/fInvMassVsPt", "Invariant mass and pT of #pi^+pi^- pairs;#bf{#it{M}^{#pi^{+}#pi^{-}} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#pi^{+}#pi^{-}} (GeV/#it{c})}", HistType::kTH2F, {{400, 0.2, 1.}, {250, 0., 25.}}); + mHistManager.add("HNM/Before/PiPlPiMi/fEta", "Pseudorapidity of HMNCand;#eta;#bf{#it{N}^{#pi^{+}#pi^{-}}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("HNM/Before/PiPlPiMi/fPhi", "Azimuthal angle of HMNCand;#phi;#bf{#it{N}^{#pi^{+}#pi^{-}}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + + for (const auto& BeforeAfterString : {"Before", "After"}) { + for (const auto& iHNM : {"Omega", "EtaPrime"}) { + for (const auto& MethodString : {"PCM", "EMC"}) { + mHistManager.add(Form("HNM/%s/%s/%s/fInvMassVsPt", BeforeAfterString, iHNM, MethodString), "Invariant mass and pT of heavy neutral meson candidates;#bf{#it{M}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c})}", HistType::kTH2F, {{600, 0.6, 1.2}, {250, 0., 25.}}); + mHistManager.add(Form("HNM/%s/%s/%s/fEta", BeforeAfterString, iHNM, MethodString), "Pseudorapidity of HNM candidate;#eta;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add(Form("HNM/%s/%s/%s/fPhi", BeforeAfterString, iHNM, MethodString), "Azimuthal angle of HNM candidate;#phi;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + } + } + } + mHistManager.add("HNM/Before/Omega/PCMEMC/fInvMassVsPt", "Invariant mass and pT of omega meson candidates;#bf{#it{M}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c})}", HistType::kTH2F, {{600, 0.6, 1.2}, {250, 0., 25.}}); + mHistManager.add("HNM/Before/Omega/PCMEMC/fEta", "Pseudorapidity of HMNCand;#eta;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("HNM/Before/Omega/PCMEMC/fPhi", "Azimuthal angle of HMNCand;#phi;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + mHistManager.add("HNM/Before/EtaPrime/PCMEMC/fInvMassVsPt", "Invariant mass and pT of eta' meson candidates;#bf{#it{M}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c})}", HistType::kTH2F, {{600, 0.8, 1.2}, {250, 0., 25.}}); + mHistManager.add("HNM/Before/EtaPrime/PCMEMC/fEta", "Pseudorapidity of HMNCand;#eta;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("HNM/Before/EtaPrime/PCMEMC/fPhi", "Azimuthal angle of HMNCand;#phi;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + + // --> Two body femto histograms + for (const auto& iFemtoPartner : {"p", "d"}) { + for (const auto& iHNM : {"omega", "etaprime"}) { + mHistManager.add(Form("%s%s/fMultiplicity", iHNM, iFemtoPartner), "Multiplicity of all processed events;#bf{#it{N}_{tracks}};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, 0, 500}}); + mHistManager.add(Form("%s%s/fZvtx", iHNM, iFemtoPartner), "Zvtx of all processed events;#bf{z_{vtx} (cm)};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, -15, 15}}); + for (const auto& iEMCPCM : {"PCM", "EMC"}) { + mHistManager.add(Form("%s%s/fSE_particle_%s", iHNM, iFemtoPartner, iEMCPCM), Form("Same Event distribution;#bf{#it{K}^{*} (GeV/#it{c})};#bf{#it{N}^{%s}}", iFemtoPartner), HistType::kTH1F, {{8000, 0, 8}}); + mHistManager.add(Form("%s%s/fSE_Antiparticle_%s", iHNM, iFemtoPartner, iEMCPCM), Form("Same Event distribution;#bf{#it{K}^{*} (GeV/#it{c})};#bf{#it{N}^{#bar{%s}}}", iFemtoPartner), HistType::kTH1F, {{8000, 0, 8}}); + mHistManager.add(Form("%s%s/f%sPtVskstar_%s", iHNM, iFemtoPartner, iHNM, iEMCPCM), Form("K* vs %s pt;#bf{#it{K}^{*} (GeV/#it{c})};#bf{#it{p}_{T}^{%s} (GeV/#it{c})}", iHNM, iHNM), HistType::kTH2F, {{{150, 0, 1.5}, {500, 0, 10}}}); + mHistManager.add(Form("%s%s/f%sPtVskstar_%s", iHNM, iFemtoPartner, iFemtoPartner, iEMCPCM), Form("K* vs %s pt;#bf{#it{K}^{*} (GeV/#it{c})};#bf{#it{p}_{T}^{%s} (GeV/#it{c})}", iFemtoPartner, iFemtoPartner), HistType::kTH2F, {{{150, 0, 1.5}, {500, 0, 10}}}); + mHistManager.add(Form("%s%s/fAnti%sPtVskstar_%s", iHNM, iFemtoPartner, iFemtoPartner, iEMCPCM), Form("K* vs #bar{%s} pt;#bf{#it{K}^{*} (GeV/#it{c})};#bf{#it{p}_{T}^{#bar{%s}} (GeV/#it{c})}", iFemtoPartner, iFemtoPartner), HistType::kTH2F, {{{150, 0, 1.5}, {500, 0, 10}}}); + } + } + } - // all tracks - mHistManager.add("TrackCuts/TracksBefore/fPtTrackBefore", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/TracksBefore/fEtaTrackBefore", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/TracksBefore/fPhiTrackBefore", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); + // --> Three body femto histograms + for (const auto& iHNM : {"omega", "etaprime"}) { + mHistManager.add(Form("pp%s/fMultiplicity", iHNM), "Multiplicity of all processed events;#bf{#it{N}_{tracks}};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, 0, 500}}); + mHistManager.add(Form("pp%s/fZvtx", iHNM), "Zvtx of all processed events;#bf{z_{vtx} (cm)};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, -15, 15}}); + for (const auto& iEMCPCM : {"PCM", "EMC"}) { + mHistManager.add(Form("pp%s/fSE_particle_%s", iHNM, iEMCPCM), "Same Event distribution;#bf{#it{Q}_{3} (GeV/#it{c})};#bf{#it{N}^{pp}}", HistType::kTH1F, {{8000, 0, 8}}); + mHistManager.add(Form("pp%s/fSE_Antiparticle_%s", iHNM, iEMCPCM), "Same Event distribution;#bf{#it{Q}_{3} (GeV/#it{c})};#bf{#it{N}^{#bar{p}#bar{p}}}", HistType::kTH1F, {{8000, 0, 8}}); + mHistManager.add(Form("pp%s/fProtonPtVsQ3_%s", iHNM, iEMCPCM), "pT (proton) vs Q_{3};#bf{#it{Q}_{3} (GeV/#it{c})};#bf{#it{p}_{T}^{p} (GeV/#it{c})}", HistType::kTH2F, {{{150, 0, 1.5}, {500, 0, 10}}}); + mHistManager.add(Form("pp%s/f%sCandPtVsQ3_%s", iHNM, iHNM, iEMCPCM), Form("pT (%s) vs Q_{3};#bf{#it{Q}_{3} (GeV/#it{c})};#bf{#it{p}_{T}^{%s} (GeV/#it{c})}", iHNM, iHNM), HistType::kTH2F, {{{150, 0, 1.5}, {500, 0, 10}}}); + mHistManager.add(Form("pp%s/fAntiProtonPtVsQ3_%s", iHNM, iEMCPCM), "pT (antiproton) vs Q_{3};#bf{#it{Q}_{3} (GeV/#it{c})};#bf{#it{p}_{T}^{#bar{p}} (GeV/#it{c})}", HistType::kTH2F, {{{150, 0, 1.5}, {500, 0, 10}}}); + } + } - // TPC signal - mHistManager.add("TrackCuts/TPCSignal/fTPCSignal", "TPCSignal;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalP", "TPCSignalP;p (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - // TPC signal anti - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAnti", "TPCSignal;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAntiP", "TPCSignalP;p (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - - // TPC signal particles - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalProton", "fTPCSignalProton;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAntiProton", "fTPCSignalAntiProton;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalDeuteron", "fTPCSignalDeuteron;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAntiDeuteron", "fTPCSignalAntiDeuteron;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalPion", "fTPCSignalPion;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAntiPion", "fTPCSignalAntiPion;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - - // proton - mHistManager.add("TrackCuts/Proton/fPProton", "Momentum of protons at PV;p (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/Proton/fPTPCProton", "Momentum of protons at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/Proton/fPtProton", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/Proton/fMomCorProtonDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - mHistManager.add("TrackCuts/Proton/fMomCorProtonRatio", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - mHistManager.add("TrackCuts/Proton/fEtaProton", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/Proton/fPhiProton", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/Proton/fNsigmaTPCvsPProton", "NSigmaTPC Proton;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Proton/fNsigmaTOFvsPProton", "NSigmaTOF Proton;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Proton/fNsigmaTPCTOFvsPProton", "NSigmaTPCTOF Proton;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - mHistManager.add("TrackCuts/Proton/fNsigmaITSvsPProton", "NSigmaITS Proton;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - mHistManager.add("TrackCuts/Proton/fNsigmaTPCvsPProtonP", "NSigmaTPC Proton P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Proton/fNsigmaTOFvsPProtonP", "NSigmaTOF Proton P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Proton/fNsigmaTPCTOFvsPProtonP", "NSigmaTPCTOF Proton P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/Proton/fDCAxyProton", "fDCAxy Proton;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/Proton/fDCAzProton", "fDCAz Proton;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/Proton/fTPCsClsProton", "fTPCsCls Proton;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/Proton/fTPCcRowsProton", "fTPCcRows Proton;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/Proton/fTrkTPCfClsProton", "fTrkTPCfCls Proton;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - mHistManager.add("TrackCuts/Proton/fTPCnclsProton", "fTPCncls Proton;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // antiproton - mHistManager.add("TrackCuts/AntiProton/fPtAntiProton", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/AntiProton/fMomCorAntiProtonDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - mHistManager.add("TrackCuts/AntiProton/fMomCorAntiProtonRatio", "Momentum correlation;p_{reco} (GeV/c); |p_{TPC} - p_{reco}| (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - mHistManager.add("TrackCuts/AntiProton/fEtaAntiProton", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/AntiProton/fPhiAntiProton", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/AntiProton/fNsigmaTPCvsPAntiProton", "NSigmaTPC AntiProton;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiProton/fNsigmaTOFvsPAntiProton", "NSigmaTOF AntiProton;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiProton/fNsigmaTPCTOFvsPAntiProton", "NSigmaTPCTOF AntiProton;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiProton/fNsigmaITSvsPAntiProton", "NSigmaITS AntiProton;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - mHistManager.add("TrackCuts/AntiProton/fNsigmaTPCvsPAntiProtonP", "NSigmaTPC AntiProton P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiProton/fNsigmaTOFvsPAntiProtonP", "NSigmaTOF AntiProton P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiProton/fNsigmaTPCTOFvsPAntiProtonP", "NSigmaTPCTOF AntiProton P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/AntiProton/fDCAxyAntiProton", "fDCAxy AntiProton;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/AntiProton/fDCAzAntiProton", "fDCAz AntiProton;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/AntiProton/fTPCsClsAntiProton", "fTPCsCls AntiProton;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/AntiProton/fTPCcRowsAntiProton", "fTPCcRows AntiProton;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/AntiProton/fTrkTPCfClsAntiProton", "fTrkTPCfCls AntiProton;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - mHistManager.add("TrackCuts/AntiProton/fTPCnclsAntiProton", "fTPCncls AntiProton;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // deuteron - mHistManager.add("TrackCuts/Deuteron/fPtDeuteron", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/Deuteron/fMomCorDeuteronDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - mHistManager.add("TrackCuts/Deuteron/fMomCorDeuteronRatio", "Momentum correlation;p_{reco} (GeV/c); |p_{TPC} - p_{reco}| (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - mHistManager.add("TrackCuts/Deuteron/fEtaDeuteron", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/Deuteron/fPhiDeuteron", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/Deuteron/fNsigmaTPCvsPDeuteron", "NSigmaTPC Deuteron;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Deuteron/fNsigmaTOFvsPDeuteron", "NSigmaTOF Deuteron;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Deuteron/fNsigmaTPCTOFvsPDeuteron", "NSigmaTPCTOF Deuteron;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - mHistManager.add("TrackCuts/Deuteron/fNsigmaITSvsPDeuteron", "NSigmaITS Deuteron;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - mHistManager.add("TrackCuts/Deuteron/fNsigmaTPCvsPDeuteronP", "NSigmaTPC Deuteron vd P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Deuteron/fNsigmaTOFvsPDeuteronP", "NSigmaTOF Deuteron P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Deuteron/fNsigmaTPCTOFvsPDeuteronP", "NSigmaTPCTOF Deuteron P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/Deuteron/fDCAxyDeuteron", "fDCAxy Deuteron;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/Deuteron/fDCAzDeuteron", "fDCAz Deuteron;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/Deuteron/fTPCsClsDeuteron", "fTPCsCls Deuteron;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/Deuteron/fTPCcRowsDeuteron", "fTPCcRows Deuteron;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/Deuteron/fTrkTPCfClsDeuteron", "fTrkTPCfCls Deuteron;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - mHistManager.add("TrackCuts/Deuteron/fTPCnclsDeuteron", "fTPCncls Deuteron;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // antideuteron - mHistManager.add("TrackCuts/AntiDeuteron/fPtAntiDeuteron", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/AntiDeuteron/fMomCorAntiDeuteronDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - mHistManager.add("TrackCuts/AntiDeuteron/fMomCorAntiDeuteronRatio", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - mHistManager.add("TrackCuts/AntiDeuteron/fEtaAntiDeuteron", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/AntiDeuteron/fPhiAntiDeuteron", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/AntiDeuteron/fNsigmaTPCvsPAntiDeuteron", "NSigmaTPC AntiDeuteron;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiDeuteron/fNsigmaTOFvsPAntiDeuteron", "NSigmaTOF AntiDeuteron;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiDeuteron/fNsigmaTPCTOFvsPAntiDeuteron", "NSigmaTPCTOF AntiDeuteron;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiDeuteron/fNsigmaITSvsPAntiDeuteron", "NSigmaITS AntiDeuteron;p (GeV/c);n#sigma_{ITS}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - - mHistManager.add("TrackCuts/AntiDeuteron/fNsigmaTPCvsPAntiDeuteronP", "NSigmaTPC AntiDeuteron P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiDeuteron/fNsigmaTOFvsPAntiDeuteronP", "NSigmaTOF AntiDeuteron P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiDeuteron/fNsigmaTPCTOFvsPAntiDeuteronP", "NSigmaTPCTOF AntiDeuteron P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/AntiDeuteron/fDCAxyAntiDeuteron", "fDCAxy AntiDeuteron;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/AntiDeuteron/fDCAzAntiDeuteron", "fDCAz AntiDeuteron;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/AntiDeuteron/fTPCsClsAntiDeuteron", "fTPCsCls AntiDeuteron;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/AntiDeuteron/fTPCcRowsAntiDeuteron", "fTPCcRows AntiDeuteron;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/AntiDeuteron/fTrkTPCfClsAntiDeuteron", "fTrkTPCfCls AntiDeuteron;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - mHistManager.add("TrackCuts/AntiDeuteron/fTPCnclsAntiDeuteron", "fTPCncls AntiDeuteron;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // pions - mHistManager.add("TrackCuts/Pion/fPPion", "Momentum of Pions at PV;p (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/Pion/fPTPCPion", "Momentum of Pions at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/Pion/fPtPion", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/Pion/fMomCorPionDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - mHistManager.add("TrackCuts/Pion/fMomCorPionRatio", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - mHistManager.add("TrackCuts/Pion/fEtaPion", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/Pion/fPhiPion", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/Pion/fNsigmaTPCvsPPion", "NSigmaTPC Pion;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Pion/fNsigmaTOFvsPPion", "NSigmaTOF Pion;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Pion/fNsigmaTPCTOFvsPPion", "NSigmaTPCTOF Pion;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/Pion/fNsigmaTPCvsPPionP", "NSigmaTPC Pion P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Pion/fNsigmaTOFvsPPionP", "NSigmaTOF Pion P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Pion/fNsigmaTPCTOFvsPPionP", "NSigmaTPCTOF Pion P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/Pion/fDCAxyPion", "fDCAxy Pion;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/Pion/fDCAzPion", "fDCAz Pion;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/Pion/fTPCsClsPion", "fTPCsCls Pion;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/Pion/fTPCcRowsPion", "fTPCcRows Pion;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/Pion/fTrkTPCfClsPion", "fTrkTPCfCls Pion;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - mHistManager.add("TrackCuts/Pion/fTPCnclsPion", "fTPCncls Pion;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // anti-pions - mHistManager.add("TrackCuts/AntiPion/fPtAntiPion", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/AntiPion/fMomCorAntiPionDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - mHistManager.add("TrackCuts/AntiPion/fMomCorAntiPionRatio", "Momentum correlation;p_{reco} (GeV/c); |p_{TPC} - p_{reco}| (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - mHistManager.add("TrackCuts/AntiPion/fEtaAntiPion", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/AntiPion/fPhiAntiPion", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPion", "NSigmaTPC AntiPion;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPion", "NSigmaTOF AntiPion;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPion", "NSigmaTPCTOF AntiPion;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPionP", "NSigmaTPC AntiPion P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPionP", "NSigmaTOF AntiPion P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPionP", "NSigmaTPCTOF AntiPion P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/AntiPion/fDCAxyAntiPion", "fDCAxy AntiPion;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/AntiPion/fDCAzAntiPion", "fDCAz AntiPion;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/AntiPion/fTPCsClsAntiPion", "fTPCsCls AntiPion;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/AntiPion/fTPCcRowsAntiPion", "fTPCcRows AntiPion;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/AntiPion/fTrkTPCfClsAntiPion", "fTrkTPCfCls AntiPion;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - mHistManager.add("TrackCuts/AntiPion/fTPCnclsAntiPion", "fTPCncls AntiPion;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // HNM - // omega QA - // daughter pos before - mHistManager.add("TrackCuts/HMN/Before/PosDaughter/fInvMass", "Invariant mass HMN Pos Daugh;M_{#pi};Entries", HistType::kTH1F, {{500, 0, 1}}); - mHistManager.add("TrackCuts/HMN/Before/PosDaughter/fPt", "Transverse momentum HMN Pos Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/Before/PosDaughter/fEta", "HMN Pos Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/Before/PosDaughter/fPhi", "Azimuthal angle of HMN Pos Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // daughter neg before - mHistManager.add("TrackCuts/HMN/Before/NegDaughter/fInvMass", "Invariant mass HMN Neg Daugh;M_{#pi};Entries", HistType::kTH1F, {{500, 0, 1}}); - mHistManager.add("TrackCuts/HMN/Before/NegDaughter/fPt", "Transverse momentum HMN Neg Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/Before/NegDaughter/fEta", "HMN Neg Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/Before/NegDaughter/fPhi", "Azimuthal angle of HMN Neg Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // HMNCand tracks before - mHistManager.add("TrackCuts/HMN/Before/fInvMass_tracks", "Invariant mass HMNCand;M_{#pi#pi#gammg#gamma};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/Before/fPt_tracks", "Transverse momentum HMNCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/Before/fEta_tracks", "Pseudorapidity of HMNCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/Before/fPhi_tracks", "Azimuthal angle of HMNCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // Right now we loose the information about the used tracks and gg properties after creating the HeavyNeutralMeson struct: Maybe it is better to keep track of these? - /*// daughter pos after - mHistManager.add("TrackCuts/omega/After/PosDaughter/fPt", "Transverse momentum omegaCand Pos Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/omega/After/PosDaughter/fEta", "omegaCandPos Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/omega/After/PosDaughter/fPhi", "Azimuthal angle of omegaCand Pos Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // daughter neg after - mHistManager.add("TrackCuts/omega/After/NegDaughter/fPt", "Transverse momentum omegaCand Neg Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/omega/After/NegDaughter/fEta", "omegaCand Neg Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/omega/After/NegDaughter/fPhi", "Azimuthal angle of omegaCand Neg Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}});*/ - // omegaCand after - // HMNCand full information - mHistManager.add("TrackCuts/HMN/Before/PCM/fInvMass", "Invariant mass HMNCand;M_{#pi#pi#gammg#gamma};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/Before/PCM/fPt", "Transverse momentum HMNCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/Before/PCM/fEta", "Pseudorapidity of HMNCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/Before/PCM/fPhi", "Azimuthal angle of HMNCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/HMN/Before/EMC/fInvMass", "Invariant mass HMNCand;M_{#pi#pi#gammg#gamma};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/Before/EMC/fPt", "Transverse momentum HMNCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/Before/EMC/fEta", "Pseudorapidity of HMNCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/Before/EMC/fPhi", "Azimuthal angle of HMNCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/HMN/Before/PCMEMC/fInvMass", "Invariant mass HMNCand;M_{#pi#pi#gammg#gamma};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/Before/PCMEMC/fPt", "Transverse momentum HMNCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/Before/PCMEMC/fEta", "Pseudorapidity of HMNCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/Before/PCMEMC/fPhi", "Azimuthal angle of HMNCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // OmegaCand - mHistManager.add("TrackCuts/HMN/After/Omega/PCM/fInvMass", "Invariant mass omegaCand;M_{#pi#pi};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/After/Omega/PCM/fPt", "Transverse momentum omegaCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/After/Omega/PCM/fEta", "Pseudorapidity of omegaCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/After/Omega/PCM/fPhi", "Azimuthal angle of omegaCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/HMN/After/Omega/EMC/fInvMass", "Invariant mass omegaCand;M_{#pi#pi};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/After/Omega/EMC/fPt", "Transverse momentum omegaCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/After/Omega/EMC/fEta", "Pseudorapidity of omegaCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/After/Omega/EMC/fPhi", "Azimuthal angle of omegaCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // EtaPrimeCand - mHistManager.add("TrackCuts/HMN/After/EtaPrime/PCM/fInvMass", "Invariant mass EtaPrimeCand;M_{#pi#pi};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/After/EtaPrime/PCM/fPt", "Transverse momentum EtaPrimeCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/After/EtaPrime/PCM/fEta", "Pseudorapidity of EtaPrimeCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/After/EtaPrime/PCM/fPhi", "Azimuthal angle of EtaPrimeCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/HMN/After/EtaPrime/EMC/fInvMass", "Invariant mass EtaPrimeCand;M_{#pi#pi};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/After/EtaPrime/EMC/fPt", "Transverse momentum EtaPrimeCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/After/EtaPrime/EMC/fEta", "Pseudorapidity of EtaPrimeCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/After/EtaPrime/EMC/fPhi", "Azimuthal angle of EtaPrimeCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - - // Trigger combs - // for ppomega - mHistManager.add("ppomega/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - mHistManager.add("ppomega/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - - mHistManager.add("ppomega/fSE_particle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("ppomega/fSE_Antiparticle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("ppomega/fProtonPtVsQ3_EMC", "pT (proton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - mHistManager.add("ppomega/fOmegaCandPtVsQ3_EMC", "pT (omega) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - mHistManager.add("ppomega/fAntiProtonPtVsQ3_EMC", "pT (antiproton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - - mHistManager.add("ppomega/fSE_particle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("ppomega/fSE_Antiparticle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("ppomega/fProtonPtVsQ3_PCM", "pT (proton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - mHistManager.add("ppomega/fOmegaCandPtVsQ3_PCM", "pT (omega) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - mHistManager.add("ppomega/fAntiProtonPtVsQ3_PCM", "pT (antiproton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - // for ppetaprime - mHistManager.add("ppetaprime/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - mHistManager.add("ppetaprime/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - - mHistManager.add("ppetaprime/fSE_particle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("ppetaprime/fSE_Antiparticle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("ppetaprime/fProtonPtVsQ3_EMC", "pT (proton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - mHistManager.add("ppetaprime/fEtaPrimeCandPtVsQ3_EMC", "pT (etaprime) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - mHistManager.add("ppetaprime/fAntiProtonPtVsQ3_EMC", "pT (antiproton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - - mHistManager.add("ppetaprime/fSE_particle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("ppetaprime/fSE_Antiparticle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("ppetaprime/fProtonPtVsQ3_PCM", "pT (proton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - mHistManager.add("ppetaprime/fEtaPrimeCandPtVsQ3_PCM", "pT (etaprime) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - mHistManager.add("ppetaprime/fAntiProtonPtVsQ3_PCM", "pT (antiproton) vs Q_{3};Q_{3} (GeV/c);p_{T} (GeV/c)", {HistType::kTH2F, {{150, 0, 1.5}, {500, 0, 10}}}); - - // two body - // omegad - mHistManager.add("omegad/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - mHistManager.add("omegad/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - - mHistManager.add("omegad/fSE_particle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegad/fSE_Antiparticle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegad/fomegaPtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegad/fDeuteronPtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegad/fAntiDeuteronPtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegad/fSE_particle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegad/fSE_Antiparticle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegad/fomegaPtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegad/fDeuteronPtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegad/fAntiDeuteronPtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - - // etaprimed - mHistManager.add("etaprimed/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - mHistManager.add("etaprimed/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - - mHistManager.add("etaprimed/fSE_particle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimed/fSE_Antiparticle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimed/fetaprimePtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimed/fDeuteronPtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimed/fAntiDeuteronPtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimed/fSE_particle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimed/fSE_Antiparticle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimed/fetaprimePtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimed/fDeuteronPtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimed/fAntiDeuteronPtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - - // omegap - mHistManager.add("omegap/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - mHistManager.add("omegap/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - - mHistManager.add("omegap/fSE_particle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegap/fSE_Antiparticle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegap/fomegaPtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegap/fProtonPtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegap/fAntiProtonPtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegap/fSE_particle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegap/fSE_Antiparticle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegap/fomegaPtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegap/fProtonPtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("omegap/fAntiProtonPtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - - // etaprimep - mHistManager.add("etaprimep/fMultiplicity", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - mHistManager.add("etaprimep/fZvtx", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - - mHistManager.add("etaprimep/fSE_particle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimep/fSE_Antiparticle_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimep/fetaprimePtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimep/fProtonPtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimep/fAntiProtonPtVskstar_PCM", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimep/fSE_particle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimep/fSE_Antiparticle_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimep/fetaprimePtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimep/fProtonPtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - mHistManager.add("etaprimep/fAntiProtonPtVskstar_EMC", "Same Event distribution", HistType::kTH1F, {{8000, 0, 8}}); - - if (ConfDoEMCShift.value) { - for (int iSM = 0; iSM < 20; iSM++) { - EMCEtaShift[iSM] = ConfEMCEtaShift.value[iSM]; - EMCPhiShift[iSM] = ConfEMCPhiShift.value[iSM]; - LOG(info) << "SM-wise shift in eta/phi for SM " << iSM << ": " << EMCEtaShift[iSM] << " / " << EMCPhiShift[iSM]; + if (cfgDoEMCShift.value) { + for (int iSM = 0; iSM < nSMs; iSM++) { + emcEtaShift[iSM] = cfgEMCEtaShift.value[iSM]; + emcPhiShift[iSM] = cfgEMCPhiShift.value[iSM]; + LOG(info) << "SM-wise shift in eta/phi for SM " << iSM << ": " << emcEtaShift[iSM] << " / " << emcPhiShift[iSM]; } } } - Preslice perCollision_pcm = aod::v0photonkf::collisionId; - Preslice perCollision_emc = aod::skimmedcluster::collisionId; void process(aod::MyCollision const& collision, aod::MyBCs const&, aod::SkimEMCClusters const& clusters, aod::V0PhotonsKF const& v0s, aod::SelectedTracks const& tracks) { // inlcude ITS PID information auto tracksWithItsPid = soa::Attach(tracks); - mHistManager.fill(HIST("Event/hCollisionCounter"), 0.); - // QA all evts mHistManager.fill(HIST("fProcessedEvents"), 0); - mHistManager.fill(HIST("EventCuts/fMultiplicityBefore"), collision.multNTracksPV()); - mHistManager.fill(HIST("EventCuts/fZvtxBefore"), collision.posZ()); + mHistManager.fill(HIST("Event/fMultiplicityBefore"), collision.multNTracksPV()); + mHistManager.fill(HIST("Event/fZvtxBefore"), collision.posZ()); // Ensure evts are consistent with Sel8 and Vtx-z selection - if (!isSelectedEvent(collision)) { + if (!isSelectedEvent(collision)) return; - } // QA accepted evts - mHistManager.fill(HIST("EventCuts/fMultiplicityAfter"), collision.multNTracksPV()); - mHistManager.fill(HIST("EventCuts/fZvtxAfter"), collision.posZ()); + mHistManager.fill(HIST("Event/fMultiplicityAfter"), collision.multNTracksPV()); + mHistManager.fill(HIST("Event/fZvtxAfter"), collision.posZ()); - colContainsPCMOmega = colContainsEMCOmega = colContainsPCMEtaPrime = colContainsEMCEtaPrime = false; - bool keepFemtoEvent[CFTrigger::kNFemtoTriggers] = {false, false, false, false, false, false}; - int lowMomentumMultiplets[CFTrigger::kNFemtoTriggers] = {0, 0, 0, 0, 0, 0}; + colContainsPCMOmega = colContainsEMCOmega = colContainsPCMEtaPrime = colContainsEMCEtaPrime = false; // Used by spectrum trigger to flag events with high-pT omega/eta' candidates + int lowMomentumMultiplets[hnmtrigger::kNFemtoTriggers] = {0, 0, 0, 0, 0, 0}; // Number of found femto pairs/triplets for each femto trigger + bool keepFemtoEvent[hnmtrigger::kNFemtoTriggers] = {false, false, false, false, false, false}; // Set based on number of found pairs (see above) - used to flag femto events // clean vecs // HNM candidates @@ -824,646 +481,654 @@ struct HeavyNeutralMesonFilter { vHNMs.clear(); // vGGs vector is cleared in reconstructGGs. - if (collision.foundBC_as().alias_bit(kTVXinEMC)) { - mHistManager.fill(HIST("Event/hCollisionCounter"), 1.); - mHistManager.fill(HIST("fProcessedEvents"), 8); - } - - auto v0sInThisCollision = v0s.sliceBy(perCollision_pcm, collision.globalIndex()); - auto clustersInThisCollision = clusters.sliceBy(perCollision_emc, collision.globalIndex()); - + // ---------------------------------> EMCal event QA <---------------------------------- + // - Fill Event/nEMCalEvents histogram for EMCal event QA + // ------------------------------------------------------------------------------------- + bool bcHasEMCCells = collision.isemcreadout(); + bool iskTVXinEMC = collision.foundBC_as().alias_bit(kTVXinEMC); + bool isL0Triggered = collision.foundBC_as().alias_bit(kEMC7) || collision.foundBC_as().alias_bit(kEG1) || collision.foundBC_as().alias_bit(kEG2); + + if (bcHasEMCCells && iskTVXinEMC) + mHistManager.fill(HIST("Event/nEMCalEvents"), 0); + if (bcHasEMCCells && isL0Triggered) + mHistManager.fill(HIST("Event/nEMCalEvents"), 1); + if (bcHasEMCCells && !iskTVXinEMC && !isL0Triggered) + mHistManager.fill(HIST("Event/nEMCalEvents"), 2); + if (!bcHasEMCCells && iskTVXinEMC) + mHistManager.fill(HIST("Event/nEMCalEvents"), 3); + if (!bcHasEMCCells && isL0Triggered) + mHistManager.fill(HIST("Event/nEMCalEvents"), 4); + + // --------------------------------> Process Photons <---------------------------------- + // - Slice clusters and V0s by collision ID to get the ones in this collision + // - Store the clusters and V0s in the vGammas vector + // - Reconstruct gamma-gamma pairs + // ------------------------------------------------------------------------------------- + auto v0sInThisCollision = v0s.sliceBy(perCollisionPCM, collision.globalIndex()); + auto clustersInThisCollision = clusters.sliceBy(perCollisionEMC, collision.globalIndex()); mHistManager.fill(HIST("Event/nClustersVsV0s"), clustersInThisCollision.size(), v0sInThisCollision.size()); - mHistManager.fill(HIST("Event/nTracks"), tracksWithItsPid.size()); std::vector vGammas; - hnmutilities::storeGammasInVector(clustersInThisCollision, v0sInThisCollision, vGammas, EMCEtaShift, EMCPhiShift); + hnmutilities::storeGammasInVector(clustersInThisCollision, v0sInThisCollision, vGammas, emcEtaShift, emcPhiShift); hnmutilities::reconstructGGs(vGammas, vGGs); vGammas.clear(); processGGs(vGGs); - bool isProton = false; - bool isDeuteron = false; - bool isPion = false; - - // #femtoPart + // ------------------------------> Loop over all tracks <------------------------------- + // - Sort them into vectors based on PID ((anti)protons, (anti)deuterons, (anti)pions) + // - Fill QA histograms for all tracks and per particle species + // ------------------------------------------------------------------------------------- for (const auto& track : tracksWithItsPid) { - // General QA mHistManager.fill(HIST("TrackCuts/TracksBefore/fPtTrackBefore"), track.pt()); mHistManager.fill(HIST("TrackCuts/TracksBefore/fEtaTrackBefore"), track.eta()); mHistManager.fill(HIST("TrackCuts/TracksBefore/fPhiTrackBefore"), track.phi()); - // Fill PID info - if (track.sign() > 0) { - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignal"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalP"), track.p(), track.tpcSignal()); + if (track.sign() > 0) { // All particles (positive electric charge) + mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalTPCP"), track.tpcInnerParam(), track.tpcSignal()); + mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignal"), track.p(), track.tpcSignal()); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationPos"), track.p(), track.tpcInnerParam()); } - if (track.sign() < 0) { - - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAnti"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiP"), track.p(), track.tpcSignal()); + if (track.sign() < 0) { // All anti-particles (negative electric charge) + mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiTPCP"), track.tpcInnerParam(), track.tpcSignal()); + mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAnti"), track.p(), track.tpcSignal()); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationNeg"), track.p(), track.tpcInnerParam()); } - // #fill protons and deuterons - isProton = (isSelectedTrackPID(track, CFTrigger::kProton) && isSelectedTrack(track, CFTrigger::kProton)); - isDeuteron = (isSelectedTrackPID(track, CFTrigger::kDeuteron) && isSelectedTrack(track, CFTrigger::kDeuteron)); - isPion = (isSelectedTrackPID(track, CFTrigger::kPion) && isSelectedTrack(track, CFTrigger::kPion)); + // For each track, check if it fulfills track and PID criteria to be identified as a proton, deuteron or pion + bool isProton = (isSelectedTrackPID(track, hnmtrigger::kProton) && isSelectedTrack(track, hnmtrigger::kProton)); + bool isDeuteron = (isSelectedTrackPID(track, hnmtrigger::kDeuteron) && isSelectedTrack(track, hnmtrigger::kDeuteron)); + bool isPion = (isSelectedTrackPID(track, hnmtrigger::kPion) && isSelectedTrack(track, hnmtrigger::kPion)); - if (track.sign() > 0) { // part + if (track.sign() > 0) { // Positive charge -> Particles if (isProton) { proton.emplace_back(track.pt(), track.eta(), track.phi(), mMassProton); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsProton"), track.p(), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalProton"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/Proton/fPProton"), track.p()); - mHistManager.fill(HIST("TrackCuts/Proton/fPTPCProton"), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/Proton/fPtProton"), track.pt()); - mHistManager.fill(HIST("TrackCuts/Proton/fMomCorProtonDif"), track.p(), track.tpcInnerParam() - track.p()); - mHistManager.fill(HIST("TrackCuts/Proton/fMomCorProtonRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - mHistManager.fill(HIST("TrackCuts/Proton/fEtaProton"), track.eta()); - mHistManager.fill(HIST("TrackCuts/Proton/fPhiProton"), track.phi()); - mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTPCvsPProton"), track.tpcInnerParam(), track.tpcNSigmaPr()); - mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTOFvsPProton"), track.tpcInnerParam(), track.tofNSigmaPr()); + + mHistManager.fill(HIST("TrackCuts/Proton/fP"), track.p()); + mHistManager.fill(HIST("TrackCuts/Proton/fPt"), track.pt()); + mHistManager.fill(HIST("TrackCuts/Proton/fMomCorDif"), track.p(), track.tpcInnerParam() - track.p()); + mHistManager.fill(HIST("TrackCuts/Proton/fMomCorRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + mHistManager.fill(HIST("TrackCuts/Proton/fEta"), track.eta()); + mHistManager.fill(HIST("TrackCuts/Proton/fPhi"), track.phi()); + + mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTPCvsTPCP"), track.tpcInnerParam(), track.tpcNSigmaPr()); + mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTOFvsTPCP"), track.tpcInnerParam(), track.tofNSigmaPr()); auto nSigmaTrackTPCTOF = std::sqrt(std::pow(track.tpcNSigmaPr(), 2) + std::pow(track.tofNSigmaPr(), 2)); - mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTPCTOFvsPProton"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPr() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPr() - nSigmaTrackTPCTOF, 2))); - mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaITSvsPProton"), track.p(), track.itsNSigmaPr()); - - mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTPCvsPProtonP"), track.p(), track.tpcNSigmaPr()); - mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTOFvsPProtonP"), track.p(), track.tofNSigmaPr()); - mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTPCTOFvsPProtonP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPr() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPr() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/Proton/fDCAxyProton"), track.dcaXY()); - mHistManager.fill(HIST("TrackCuts/Proton/fDCAzProton"), track.dcaZ()); - mHistManager.fill(HIST("TrackCuts/Proton/fTPCsClsProton"), track.tpcNClsShared()); - mHistManager.fill(HIST("TrackCuts/Proton/fTPCcRowsProton"), track.tpcNClsCrossedRows()); - mHistManager.fill(HIST("TrackCuts/Proton/fTrkTPCfClsProton"), track.tpcCrossedRowsOverFindableCls()); - mHistManager.fill(HIST("TrackCuts/Proton/fTPCnclsProton"), track.tpcNClsFound()); + mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTPCTOFvsTPCP"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPr() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPr() - nSigmaTrackTPCTOF, 2))); + mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaITSvsP"), track.p(), track.itsNSigmaPr()); + mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTPCvsP"), track.p(), track.tpcNSigmaPr()); + mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTOFvsP"), track.p(), track.tofNSigmaPr()); + mHistManager.fill(HIST("TrackCuts/Proton/fNsigmaTPCTOFvsP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPr() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPr() - nSigmaTrackTPCTOF, 2))); + + mHistManager.fill(HIST("TrackCuts/Proton/fDCAxy"), track.dcaXY()); + mHistManager.fill(HIST("TrackCuts/Proton/fDCAz"), track.dcaZ()); + mHistManager.fill(HIST("TrackCuts/Proton/fTPCsCls"), track.tpcNClsShared()); + mHistManager.fill(HIST("TrackCuts/Proton/fTPCcRows"), track.tpcNClsCrossedRows()); + mHistManager.fill(HIST("TrackCuts/Proton/fTrkTPCfCls"), track.tpcCrossedRowsOverFindableCls()); + mHistManager.fill(HIST("TrackCuts/Proton/fTPCncls"), track.tpcNClsFound()); } if (isDeuteron) { deuteron.emplace_back(track.pt(), track.eta(), track.phi(), mMassDeuteron); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsDeuteron"), track.p(), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalDeuteron"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fPtDeuteron"), track.pt()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fMomCorDeuteronDif"), track.p(), track.tpcInnerParam() - track.p()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fMomCorDeuteronRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fEtaDeuteron"), track.eta()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fPhiDeuteron"), track.phi()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCvsPDeuteron"), track.tpcInnerParam(), track.tpcNSigmaDe()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTOFvsPDeuteron"), track.tpcInnerParam(), track.tofNSigmaDe()); + + mHistManager.fill(HIST("TrackCuts/Deuteron/fP"), track.p()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fPt"), track.pt()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fMomCorDif"), track.p(), track.tpcInnerParam() - track.p()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fMomCorRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fEta"), track.eta()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fPhi"), track.phi()); + + mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCvsTPCP"), track.tpcInnerParam(), track.tpcNSigmaDe()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTOFvsTPCP"), track.tpcInnerParam(), track.tofNSigmaDe()); auto nSigmaTrackTPCTOF = std::sqrt(std::pow(track.tpcNSigmaDe(), 2) + std::pow(track.tofNSigmaDe(), 2)); - mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCTOFvsPDeuteron"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaDe() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaDe() - nSigmaTrackTPCTOF, 2))); - mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaITSvsPDeuteron"), track.p(), track.itsNSigmaDe()); - - mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCvsPDeuteronP"), track.p(), track.tpcNSigmaDe()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTOFvsPDeuteronP"), track.p(), track.tofNSigmaDe()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCTOFvsPDeuteronP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaDe() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaDe() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/Deuteron/fDCAxyDeuteron"), track.dcaXY()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fDCAzDeuteron"), track.dcaZ()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fTPCsClsDeuteron"), track.tpcNClsShared()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fTPCcRowsDeuteron"), track.tpcNClsCrossedRows()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fTrkTPCfClsDeuteron"), track.tpcCrossedRowsOverFindableCls()); - mHistManager.fill(HIST("TrackCuts/Deuteron/fTPCnclsDeuteron"), track.tpcNClsFound()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCTOFvsTPCP"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaDe() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaDe() - nSigmaTrackTPCTOF, 2))); + mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaITSvsP"), track.p(), track.itsNSigmaDe()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCvsP"), track.p(), track.tpcNSigmaDe()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTOFvsP"), track.p(), track.tofNSigmaDe()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fNsigmaTPCTOFvsP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaDe() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaDe() - nSigmaTrackTPCTOF, 2))); + + mHistManager.fill(HIST("TrackCuts/Deuteron/fDCAxy"), track.dcaXY()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fDCAz"), track.dcaZ()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fTPCsCls"), track.tpcNClsShared()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fTPCcRows"), track.tpcNClsCrossedRows()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fTrkTPCfCls"), track.tpcCrossedRowsOverFindableCls()); + mHistManager.fill(HIST("TrackCuts/Deuteron/fTPCncls"), track.tpcNClsFound()); } if (isPion) { pion.emplace_back(track.pt(), track.eta(), track.phi(), mMassPionCharged); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsPion"), track.p(), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalPion"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/Pion/fPPion"), track.p()); - mHistManager.fill(HIST("TrackCuts/Pion/fPTPCPion"), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/Pion/fPtPion"), track.pt()); - mHistManager.fill(HIST("TrackCuts/Pion/fMomCorPionDif"), track.p(), track.tpcInnerParam() - track.p()); - mHistManager.fill(HIST("TrackCuts/Pion/fMomCorPionRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - mHistManager.fill(HIST("TrackCuts/Pion/fEtaPion"), track.eta()); - mHistManager.fill(HIST("TrackCuts/Pion/fPhiPion"), track.phi()); - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCvsPPion"), track.tpcInnerParam(), track.tpcNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTOFvsPPion"), track.tpcInnerParam(), track.tofNSigmaPi()); + + mHistManager.fill(HIST("TrackCuts/Pion/fP"), track.p()); + mHistManager.fill(HIST("TrackCuts/Pion/fPt"), track.pt()); + mHistManager.fill(HIST("TrackCuts/Pion/fMomCorDif"), track.p(), track.tpcInnerParam() - track.p()); + mHistManager.fill(HIST("TrackCuts/Pion/fMomCorRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + mHistManager.fill(HIST("TrackCuts/Pion/fEta"), track.eta()); + mHistManager.fill(HIST("TrackCuts/Pion/fPhi"), track.phi()); + + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCvsTPCP"), track.tpcInnerParam(), track.tpcNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTOFvsTPCP"), track.tpcInnerParam(), track.tofNSigmaPi()); auto nSigmaTrackTPCTOF = std::sqrt(std::pow(track.tpcNSigmaPi(), 2) + std::pow(track.tofNSigmaPi(), 2)); - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCTOFvsPPion"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCvsPPionP"), track.p(), track.tpcNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTOFvsPPionP"), track.p(), track.tofNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCTOFvsPPionP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/Pion/fDCAxyPion"), track.dcaXY()); - mHistManager.fill(HIST("TrackCuts/Pion/fDCAzPion"), track.dcaZ()); - mHistManager.fill(HIST("TrackCuts/Pion/fTPCsClsPion"), track.tpcNClsShared()); - mHistManager.fill(HIST("TrackCuts/Pion/fTPCcRowsPion"), track.tpcNClsCrossedRows()); - mHistManager.fill(HIST("TrackCuts/Pion/fTrkTPCfClsPion"), track.tpcCrossedRowsOverFindableCls()); - mHistManager.fill(HIST("TrackCuts/Pion/fTPCnclsPion"), track.tpcNClsFound()); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCTOFvsTPCP"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaITSvsP"), track.p(), track.itsNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCvsP"), track.p(), track.tpcNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTOFvsP"), track.p(), track.tofNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCTOFvsP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); + + mHistManager.fill(HIST("TrackCuts/Pion/fDCAxy"), track.dcaXY()); + mHistManager.fill(HIST("TrackCuts/Pion/fDCAz"), track.dcaZ()); + mHistManager.fill(HIST("TrackCuts/Pion/fTPCsCls"), track.tpcNClsShared()); + mHistManager.fill(HIST("TrackCuts/Pion/fTPCcRows"), track.tpcNClsCrossedRows()); + mHistManager.fill(HIST("TrackCuts/Pion/fTrkTPCfCls"), track.tpcCrossedRowsOverFindableCls()); + mHistManager.fill(HIST("TrackCuts/Pion/fTPCncls"), track.tpcNClsFound()); } - - } else { // antipart + } else { // Negative charge -> Anti-particles if (isProton) { antiproton.emplace_back(track.pt(), track.eta(), track.phi(), mMassProton); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiProton"), track.p(), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiProton"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fPtAntiProton"), track.pt()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fMomCorAntiProtonDif"), track.p(), track.tpcInnerParam() - track.p()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fMomCorAntiProtonRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fEtaAntiProton"), track.eta()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fPhiAntiProton"), track.phi()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCvsPAntiProton"), track.tpcInnerParam(), track.tpcNSigmaPr()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTOFvsPAntiProton"), track.tpcInnerParam(), track.tofNSigmaPr()); + + mHistManager.fill(HIST("TrackCuts/AntiProton/fP"), track.p()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fPt"), track.pt()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fMomCorDif"), track.p(), track.tpcInnerParam() - track.p()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fMomCorRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fEta"), track.eta()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fPhi"), track.phi()); + + mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCvsTPCP"), track.tpcInnerParam(), track.tpcNSigmaPr()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTOFvsTPCP"), track.tpcInnerParam(), track.tofNSigmaPr()); auto nSigmaTrackTPCTOF = std::sqrt(std::pow(track.tpcNSigmaPr(), 2) + std::pow(track.tofNSigmaPr(), 2)); - mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCTOFvsPAntiProton"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPr() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPr() - nSigmaTrackTPCTOF, 2))); - mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaITSvsPAntiProton"), track.p(), track.itsNSigmaPr()); - - mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCvsPAntiProtonP"), track.p(), track.tpcNSigmaPr()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTOFvsPAntiProtonP"), track.p(), track.tofNSigmaPr()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCTOFvsPAntiProtonP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPr() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPr() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/AntiProton/fDCAxyAntiProton"), track.dcaXY()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fDCAzAntiProton"), track.dcaZ()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fTPCsClsAntiProton"), track.tpcNClsShared()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fTPCcRowsAntiProton"), track.tpcNClsCrossedRows()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fTrkTPCfClsAntiProton"), track.tpcCrossedRowsOverFindableCls()); - mHistManager.fill(HIST("TrackCuts/AntiProton/fTPCnclsAntiProton"), track.tpcNClsFound()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCTOFvsTPCP"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPr() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPr() - nSigmaTrackTPCTOF, 2))); + mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaITSvsP"), track.p(), track.itsNSigmaPr()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCvsP"), track.p(), track.tpcNSigmaPr()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTOFvsP"), track.p(), track.tofNSigmaPr()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fNsigmaTPCTOFvsP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPr() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPr() - nSigmaTrackTPCTOF, 2))); + + mHistManager.fill(HIST("TrackCuts/AntiProton/fDCAxy"), track.dcaXY()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fDCAz"), track.dcaZ()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fTPCsCls"), track.tpcNClsShared()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fTPCcRows"), track.tpcNClsCrossedRows()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fTrkTPCfCls"), track.tpcCrossedRowsOverFindableCls()); + mHistManager.fill(HIST("TrackCuts/AntiProton/fTPCncls"), track.tpcNClsFound()); } if (isDeuteron) { antideuteron.emplace_back(track.pt(), track.eta(), track.phi(), mMassDeuteron); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiDeuteron"), track.p(), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiDeuteron"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fPtAntiDeuteron"), track.pt()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fMomCorAntiDeuteronDif"), track.p(), track.tpcInnerParam() - track.p()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fMomCorAntiDeuteronRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fEtaAntiDeuteron"), track.eta()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fPhiAntiDeuteron"), track.phi()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCvsPAntiDeuteron"), track.tpcInnerParam(), track.tpcNSigmaDe()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTOFvsPAntiDeuteron"), track.tpcInnerParam(), track.tofNSigmaDe()); + + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fP"), track.p()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fPt"), track.pt()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fMomCorDif"), track.p(), track.tpcInnerParam() - track.p()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fMomCorRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fEta"), track.eta()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fPhi"), track.phi()); + + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCvsTPCP"), track.tpcInnerParam(), track.tpcNSigmaDe()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTOFvsTPCP"), track.tpcInnerParam(), track.tofNSigmaDe()); auto nSigmaTrackTPCTOF = std::sqrt(std::pow(track.tpcNSigmaDe(), 2) + std::pow(track.tofNSigmaDe(), 2)); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCTOFvsPAntiDeuteron"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaDe() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaDe() - nSigmaTrackTPCTOF, 2))); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaITSvsPAntiDeuteron"), track.p(), track.itsNSigmaDe()); - - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCvsPAntiDeuteronP"), track.p(), track.tpcNSigmaDe()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTOFvsPAntiDeuteronP"), track.p(), track.tofNSigmaDe()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCTOFvsPAntiDeuteronP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaDe() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaDe() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fDCAxyAntiDeuteron"), track.dcaXY()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fDCAzAntiDeuteron"), track.dcaZ()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fTPCsClsAntiDeuteron"), track.tpcNClsShared()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fTPCcRowsAntiDeuteron"), track.tpcNClsCrossedRows()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fTrkTPCfClsAntiDeuteron"), track.tpcCrossedRowsOverFindableCls()); - mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fTPCnclsAntiDeuteron"), track.tpcNClsFound()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCTOFvsTPCP"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaDe() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaDe() - nSigmaTrackTPCTOF, 2))); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaITSvsP"), track.p(), track.itsNSigmaDe()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCvsP"), track.p(), track.tpcNSigmaDe()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTOFvsP"), track.p(), track.tofNSigmaDe()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fNsigmaTPCTOFvsP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaDe() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaDe() - nSigmaTrackTPCTOF, 2))); + + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fDCAxy"), track.dcaXY()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fDCAz"), track.dcaZ()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fTPCsCls"), track.tpcNClsShared()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fTPCcRows"), track.tpcNClsCrossedRows()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fTrkTPCfCls"), track.tpcCrossedRowsOverFindableCls()); + mHistManager.fill(HIST("TrackCuts/AntiDeuteron/fTPCncls"), track.tpcNClsFound()); } if (isPion) { antipion.emplace_back(track.pt(), track.eta(), track.phi(), mMassPionCharged); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiPion"), track.p(), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiPion"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fPtAntiPion"), track.pt()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fMomCorAntiPionDif"), track.p(), track.tpcInnerParam() - track.p()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fMomCorAntiPionRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fEtaAntiPion"), track.eta()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fPhiAntiPion"), track.phi()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPion"), track.tpcInnerParam(), track.tpcNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPion"), track.tpcInnerParam(), track.tofNSigmaPi()); + + mHistManager.fill(HIST("TrackCuts/AntiPion/fP"), track.p()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fPt"), track.pt()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fMomCorDif"), track.p(), track.tpcInnerParam() - track.p()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fMomCorRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fEta"), track.eta()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fPhi"), track.phi()); + + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCvsTPCP"), track.tpcInnerParam(), track.tpcNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTOFvsTPCP"), track.tpcInnerParam(), track.tofNSigmaPi()); auto nSigmaTrackTPCTOF = std::sqrt(std::pow(track.tpcNSigmaPi(), 2) + std::pow(track.tofNSigmaPi(), 2)); - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPion"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPionP"), track.p(), track.tpcNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPionP"), track.p(), track.tofNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPionP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/AntiPion/fDCAxyAntiPion"), track.dcaXY()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fDCAzAntiPion"), track.dcaZ()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCsClsAntiPion"), track.tpcNClsShared()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCcRowsAntiPion"), track.tpcNClsCrossedRows()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fTrkTPCfClsAntiPion"), track.tpcCrossedRowsOverFindableCls()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCnclsAntiPion"), track.tpcNClsFound()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCTOFvsTPCP"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaITSvsP"), track.p(), track.itsNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCvsP"), track.p(), track.tpcNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTOFvsP"), track.p(), track.tofNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCTOFvsP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); + + mHistManager.fill(HIST("TrackCuts/AntiPion/fDCAxy"), track.dcaXY()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fDCAz"), track.dcaZ()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCsCls"), track.tpcNClsShared()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCcRows"), track.tpcNClsCrossedRows()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fTrkTPCfCls"), track.tpcCrossedRowsOverFindableCls()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCncls"), track.tpcNClsFound()); } } } - // reconstruct HMN candidates + // -------------------------> Reconstruct HNM candidates <------------------------------ + // - Based on the previously filled (anti)pion vectors + // - Fill QA histograms for kinematics of the pions and their combinations + // ------------------------------------------------------------------------------------- for (const auto& posPion : pion) { for (const auto& negPion : antipion) { - hnmutilities::reconstructHeavyNeutralMesons(posPion, negPion, vGGs, vHNMs); - - ROOT::Math::PtEtaPhiMVector temp = posPion + negPion; - - mHistManager.fill(HIST("TrackCuts/HMN/Before/fInvMass_tracks"), temp.M()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/fPt_tracks"), temp.pt()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/fEta_tracks"), temp.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/fPhi_tracks"), translatePhi(temp.phi())); - - mHistManager.fill(HIST("TrackCuts/HMN/Before/PosDaughter/fInvMass"), posPion.M()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/PosDaughter/fPt"), posPion.pt()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/PosDaughter/fEta"), posPion.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/PosDaughter/fPhi"), translatePhi(posPion.phi())); - - mHistManager.fill(HIST("TrackCuts/HMN/Before/NegDaughter/fInvMass"), negPion.M()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/NegDaughter/fPt"), negPion.pt()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/NegDaughter/fEta"), negPion.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/NegDaughter/fPhi"), translatePhi(negPion.phi())); + ROOT::Math::PtEtaPhiMVector vecPiPlPiMi = posPion + negPion; + hnmutilities::reconstructHeavyNeutralMesons(vecPiPlPiMi, vGGs, vHNMs); + + mHistManager.fill(HIST("HNM/Before/PiPlPiMi/fInvMassVsPt"), vecPiPlPiMi.M(), vecPiPlPiMi.pt()); + mHistManager.fill(HIST("HNM/Before/PiPlPiMi/fEta"), vecPiPlPiMi.eta()); + mHistManager.fill(HIST("HNM/Before/PiPlPiMi/fPhi"), RecoDecay::constrainAngle(vecPiPlPiMi.phi())); + + mHistManager.fill(HIST("HNM/Before/PosDaughter/fInvMass"), posPion.M()); + mHistManager.fill(HIST("HNM/Before/PosDaughter/fPt"), posPion.pt()); + mHistManager.fill(HIST("HNM/Before/PosDaughter/fEta"), posPion.eta()); + mHistManager.fill(HIST("HNM/Before/PosDaughter/fPhi"), RecoDecay::constrainAngle(posPion.phi())); + + mHistManager.fill(HIST("HNM/Before/NegDaughter/fInvMass"), negPion.M()); + mHistManager.fill(HIST("HNM/Before/NegDaughter/fPt"), negPion.pt()); + mHistManager.fill(HIST("HNM/Before/NegDaughter/fEta"), negPion.eta()); + mHistManager.fill(HIST("HNM/Before/NegDaughter/fPhi"), RecoDecay::constrainAngle(negPion.phi())); } } - processHNMs(vHNMs); // Contains QA of HMN properties - - // build triplets - float Q3 = 999.f, kstar = 999.f; - // omega - if (ConfTriggerSwitches->get("Switch", "PPOmega") > 0.) { - // ppomega trigger - + // ---------------------------> Process HNM candidates <-------------------------------- + // - Fill invMassVsPt histograms separated into HNM types (based on GG mass) and gamma reco method + // - Set colContains* flags for each HNM type to be used in the high-pt spectrum trigger + // - Fill femto HNM vectors (omegaPCM, etaPrimePCM, omegaEMC, etaPrimeEMC) + // ------------------------------------------------------------------------------------- + processHNMs(vHNMs); + + // ------------------------------> Build triplets <------------------------------------- + // - Calculate Q3 for each triplet (p-p-omega, p-p-eta', anti-p-anti-p-omega, anti-p-anti-p-eta') + // - Fill QA histograms for Q3 and pT of the triplet and its daughters + // - Increment lowMomentumMultiplets for each triplet with Q3 < kinematic limit (used in femto trigger) + // ------------------------------------------------------------------------------------- + if (cfgTriggerSwitches->get("Switch", "PPOmega") > 0.) { // -----> p-p-omega femtoscopy for (size_t i = 0; i < proton.size(); ++i) { for (size_t j = i + 1; j < proton.size(); ++j) { - const auto& Proton1 = proton[i]; - const auto& Proton2 = proton[j]; - // PCM - for (const auto& omegaParticles : omegaPCM) { + const auto& proton1 = proton[i]; + const auto& proton2 = proton[j]; + for (const auto& omegaParticles : omegaPCM) { // ---> PCM - Q3 = getQ3(Proton1, Proton2, omegaParticles); + float q3 = getQ3(proton1, proton2, omegaParticles); - mHistManager.fill(HIST("ppomega/fSE_particle_PCM"), Q3); - mHistManager.fill(HIST("ppomega/fProtonPtVsQ3_PCM"), Q3, Proton1.Pt()); - mHistManager.fill(HIST("ppomega/fProtonPtVsQ3_PCM"), Q3, Proton2.Pt()); - mHistManager.fill(HIST("ppomega/fOmegaCandPtVsQ3_PCM"), Q3, omegaParticles.Pt()); + mHistManager.fill(HIST("ppomega/fSE_particle_PCM"), q3); + mHistManager.fill(HIST("ppomega/fProtonPtVsQ3_PCM"), q3, proton1.Pt()); + mHistManager.fill(HIST("ppomega/fProtonPtVsQ3_PCM"), q3, proton2.Pt()); + mHistManager.fill(HIST("ppomega/fomegaCandPtVsQ3_PCM"), q3, omegaParticles.Pt()); - if (Q3 < ConfKinematicLimits->get(static_cast(0), CFTrigger::kPPOmega)) { - lowMomentumMultiplets[CFTrigger::kPPOmega] += 1; - } + if (q3 < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kPPOmega)) + lowMomentumMultiplets[hnmtrigger::kPPOmega] += 1; } - // EMC - for (const auto& omegaParticles : omegaEMC) { + for (const auto& omegaParticles : omegaEMC) { // ---> EMC - Q3 = getQ3(Proton1, Proton2, omegaParticles); + float q3 = getQ3(proton1, proton2, omegaParticles); - mHistManager.fill(HIST("ppomega/fSE_particle_EMC"), Q3); - mHistManager.fill(HIST("ppomega/fProtonPtVsQ3_EMC"), Q3, Proton1.Pt()); - mHistManager.fill(HIST("ppomega/fProtonPtVsQ3_EMC"), Q3, Proton2.Pt()); - mHistManager.fill(HIST("ppomega/fOmegaCandPtVsQ3_EMC"), Q3, omegaParticles.Pt()); + mHistManager.fill(HIST("ppomega/fSE_particle_EMC"), q3); + mHistManager.fill(HIST("ppomega/fProtonPtVsQ3_EMC"), q3, proton1.Pt()); + mHistManager.fill(HIST("ppomega/fProtonPtVsQ3_EMC"), q3, proton2.Pt()); + mHistManager.fill(HIST("ppomega/fomegaCandPtVsQ3_EMC"), q3, omegaParticles.Pt()); - if (Q3 < ConfKinematicLimits->get(static_cast(0), CFTrigger::kPPOmega)) { - lowMomentumMultiplets[CFTrigger::kPPOmega] += 1; - } + if (q3 < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kPPOmega)) + lowMomentumMultiplets[hnmtrigger::kPPOmega] += 1; } } } - // apapomega trigger - // PCM - for (size_t i = 0; i < antiproton.size(); ++i) { + for (size_t i = 0; i < antiproton.size(); ++i) { // -----> antip-antip-omega femtoscopy for (size_t j = i + 1; j < antiproton.size(); ++j) { const auto& antiProton1 = antiproton[i]; const auto& antiProton2 = antiproton[j]; - // PCM - for (const auto& omegaParticles : omegaPCM) { + for (const auto& omegaParticles : omegaPCM) { // ---> PCM - Q3 = getQ3(antiProton1, antiProton2, omegaParticles); + float q3 = getQ3(antiProton1, antiProton2, omegaParticles); - mHistManager.fill(HIST("ppomega/fSE_Antiparticle_PCM"), Q3); - mHistManager.fill(HIST("ppomega/fAntiProtonPtVsQ3_PCM"), Q3, antiProton1.Pt()); - mHistManager.fill(HIST("ppomega/fAntiProtonPtVsQ3_PCM"), Q3, antiProton2.Pt()); - mHistManager.fill(HIST("ppomega/fOmegaCandPtVsQ3_PCM"), Q3, omegaParticles.Pt()); + mHistManager.fill(HIST("ppomega/fSE_Antiparticle_PCM"), q3); + mHistManager.fill(HIST("ppomega/fAntiProtonPtVsQ3_PCM"), q3, antiProton1.Pt()); + mHistManager.fill(HIST("ppomega/fAntiProtonPtVsQ3_PCM"), q3, antiProton2.Pt()); + mHistManager.fill(HIST("ppomega/fomegaCandPtVsQ3_PCM"), q3, omegaParticles.Pt()); - if (Q3 < ConfKinematicLimits->get(static_cast(0), CFTrigger::kPPOmega)) { - lowMomentumMultiplets[CFTrigger::kPPOmega] += 1; - } + if (q3 < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kPPOmega)) + lowMomentumMultiplets[hnmtrigger::kPPOmega] += 1; } - // EMC - for (const auto& omegaParticles : omegaEMC) { + for (const auto& omegaParticles : omegaEMC) { // ---> EMC - Q3 = getQ3(antiProton1, antiProton2, omegaParticles); + float q3 = getQ3(antiProton1, antiProton2, omegaParticles); - mHistManager.fill(HIST("ppomega/fSE_Antiparticle_EMC"), Q3); - mHistManager.fill(HIST("ppomega/fAntiProtonPtVsQ3_EMC"), Q3, antiProton1.Pt()); - mHistManager.fill(HIST("ppomega/fAntiProtonPtVsQ3_EMC"), Q3, antiProton2.Pt()); - mHistManager.fill(HIST("ppomega/fOmegaCandPtVsQ3_EMC"), Q3, omegaParticles.Pt()); + mHistManager.fill(HIST("ppomega/fSE_Antiparticle_EMC"), q3); + mHistManager.fill(HIST("ppomega/fAntiProtonPtVsQ3_EMC"), q3, antiProton1.Pt()); + mHistManager.fill(HIST("ppomega/fAntiProtonPtVsQ3_EMC"), q3, antiProton2.Pt()); + mHistManager.fill(HIST("ppomega/fomegaCandPtVsQ3_EMC"), q3, omegaParticles.Pt()); - if (Q3 < ConfKinematicLimits->get(static_cast(0), CFTrigger::kPPOmega)) { - lowMomentumMultiplets[CFTrigger::kPPOmega] += 1; - } + if (q3 < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kPPOmega)) + lowMomentumMultiplets[hnmtrigger::kPPOmega] += 1; } } } } - - // etaprime - if (ConfTriggerSwitches->get("Switch", "PPEtaPrime") > 0.) { - // ppetaprimetrigger + if (cfgTriggerSwitches->get("Switch", "PPEtaPrime") > 0.) { // -----> p-p-eta' femtoscopy for (size_t i = 0; i < proton.size(); ++i) { for (size_t j = i + 1; j < proton.size(); ++j) { - const auto& Proton1 = proton[i]; - const auto& Proton2 = proton[j]; - // PCM - for (const auto& etaParticles : etaPrimePCM) { + const auto& proton1 = proton[i]; + const auto& proton2 = proton[j]; + for (const auto& etaParticles : etaPrimePCM) { // ---> PCM - Q3 = getQ3(Proton1, Proton2, etaParticles); + float q3 = getQ3(proton1, proton2, etaParticles); - mHistManager.fill(HIST("ppetaprime/fSE_particle_PCM"), Q3); - mHistManager.fill(HIST("ppetaprime/fProtonPtVsQ3_PCM"), Q3, Proton1.Pt()); - mHistManager.fill(HIST("ppetaprime/fProtonPtVsQ3_PCM"), Q3, Proton2.Pt()); - mHistManager.fill(HIST("ppetaprime/fEtaPrimeCandPtVsQ3_PCM"), Q3, etaParticles.Pt()); + mHistManager.fill(HIST("ppetaprime/fSE_particle_PCM"), q3); + mHistManager.fill(HIST("ppetaprime/fProtonPtVsQ3_PCM"), q3, proton1.Pt()); + mHistManager.fill(HIST("ppetaprime/fProtonPtVsQ3_PCM"), q3, proton2.Pt()); + mHistManager.fill(HIST("ppetaprime/fetaprimeCandPtVsQ3_PCM"), q3, etaParticles.Pt()); - if (Q3 < ConfKinematicLimits->get(static_cast(0), CFTrigger::kPPEtaPrime)) { - lowMomentumMultiplets[CFTrigger::kPPEtaPrime] += 1; - } + if (q3 < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kPPEtaPrime)) + lowMomentumMultiplets[hnmtrigger::kPPEtaPrime] += 1; } - // EMC - for (const auto& etaParticles : etaPrimeEMC) { + for (const auto& etaParticles : etaPrimeEMC) { // ---> EMC - Q3 = getQ3(Proton1, Proton2, etaParticles); + float q3 = getQ3(proton1, proton2, etaParticles); - mHistManager.fill(HIST("ppetaprime/fSE_particle_EMC"), Q3); - mHistManager.fill(HIST("ppetaprime/fProtonPtVsQ3_EMC"), Q3, Proton1.Pt()); - mHistManager.fill(HIST("ppetaprime/fProtonPtVsQ3_EMC"), Q3, Proton2.Pt()); - mHistManager.fill(HIST("ppetaprime/fEtaPrimeCandPtVsQ3_EMC"), Q3, etaParticles.Pt()); + mHistManager.fill(HIST("ppetaprime/fSE_particle_EMC"), q3); + mHistManager.fill(HIST("ppetaprime/fProtonPtVsQ3_EMC"), q3, proton1.Pt()); + mHistManager.fill(HIST("ppetaprime/fProtonPtVsQ3_EMC"), q3, proton2.Pt()); + mHistManager.fill(HIST("ppetaprime/fetaprimeCandPtVsQ3_EMC"), q3, etaParticles.Pt()); - if (Q3 < ConfKinematicLimits->get(static_cast(0), CFTrigger::kPPEtaPrime)) { - lowMomentumMultiplets[CFTrigger::kPPEtaPrime] += 1; - } + if (q3 < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kPPEtaPrime)) + lowMomentumMultiplets[hnmtrigger::kPPEtaPrime] += 1; } } } - // apapetaprime trigger - for (size_t i = 0; i < antiproton.size(); ++i) { + for (size_t i = 0; i < antiproton.size(); ++i) { // -----> antip-antip-eta' femtoscopy for (size_t j = i + 1; j < antiproton.size(); ++j) { const auto& antiProton1 = antiproton[i]; const auto& antiProton2 = antiproton[j]; - // PCM - for (const auto& etaParticles : etaPrimePCM) { + for (const auto& etaParticles : etaPrimePCM) { // ---> PCM - Q3 = getQ3(antiProton1, antiProton2, etaParticles); + float q3 = getQ3(antiProton1, antiProton2, etaParticles); - mHistManager.fill(HIST("ppetaprime/fSE_Antiparticle_PCM"), Q3); - mHistManager.fill(HIST("ppetaprime/fAntiProtonPtVsQ3_PCM"), Q3, antiProton1.Pt()); - mHistManager.fill(HIST("ppetaprime/fAntiProtonPtVsQ3_PCM"), Q3, antiProton2.Pt()); - mHistManager.fill(HIST("ppetaprime/fEtaPrimeCandPtVsQ3_PCM"), Q3, etaParticles.Pt()); + mHistManager.fill(HIST("ppetaprime/fSE_Antiparticle_PCM"), q3); + mHistManager.fill(HIST("ppetaprime/fAntiProtonPtVsQ3_PCM"), q3, antiProton1.Pt()); + mHistManager.fill(HIST("ppetaprime/fAntiProtonPtVsQ3_PCM"), q3, antiProton2.Pt()); + mHistManager.fill(HIST("ppetaprime/fetaprimeCandPtVsQ3_PCM"), q3, etaParticles.Pt()); - if (Q3 < ConfKinematicLimits->get(static_cast(0), CFTrigger::kPPEtaPrime)) { - lowMomentumMultiplets[CFTrigger::kPPEtaPrime] += 1; - } + if (q3 < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kPPEtaPrime)) + lowMomentumMultiplets[hnmtrigger::kPPEtaPrime] += 1; } - // EMC - for (const auto& etaParticles : etaPrimeEMC) { + for (const auto& etaParticles : etaPrimeEMC) { // ---> EMC - Q3 = getQ3(antiProton1, antiProton2, etaParticles); + float q3 = getQ3(antiProton1, antiProton2, etaParticles); - mHistManager.fill(HIST("ppetaprime/fSE_Antiparticle_EMC"), Q3); - mHistManager.fill(HIST("ppetaprime/fAntiProtonPtVsQ3_EMC"), Q3, antiProton1.Pt()); - mHistManager.fill(HIST("ppetaprime/fAntiProtonPtVsQ3_EMC"), Q3, antiProton2.Pt()); - mHistManager.fill(HIST("ppetaprime/fEtaPrimeCandPtVsQ3_EMC"), Q3, etaParticles.Pt()); + mHistManager.fill(HIST("ppetaprime/fSE_Antiparticle_EMC"), q3); + mHistManager.fill(HIST("ppetaprime/fAntiProtonPtVsQ3_EMC"), q3, antiProton1.Pt()); + mHistManager.fill(HIST("ppetaprime/fAntiProtonPtVsQ3_EMC"), q3, antiProton2.Pt()); + mHistManager.fill(HIST("ppetaprime/fetaprimeCandPtVsQ3_EMC"), q3, etaParticles.Pt()); - if (Q3 < ConfKinematicLimits->get(static_cast(0), CFTrigger::kPPEtaPrime)) { - lowMomentumMultiplets[CFTrigger::kPPEtaPrime] += 1; - } + if (q3 < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kPPEtaPrime)) + lowMomentumMultiplets[hnmtrigger::kPPEtaPrime] += 1; } } } } - // build pairs - if (ConfTriggerSwitches->get("Switch", "Omegad") > 0.) { - // PCM - // omegad trigger - for (auto iomega = omegaPCM.begin(); iomega != omegaPCM.end(); ++iomega) { - for (auto iDeuteron = deuteron.begin(); iDeuteron != deuteron.end(); ++iDeuteron) { - kstar = getkstar(*iomega, *iDeuteron); + // --------------------------------> Build Pairs <-------------------------------------- + // - Calculate k* for each pair ((anti)d-omega, (anti)d-eta', (anti)p-omega, (anti)p-eta') + // - Fill QA histograms for k* and pT of the pairs + // - Increment lowMomentumMultiplets for each triplet with k* < kinematic limit (used in femto trigger) + // ------------------------------------------------------------------------------------- + if (cfgTriggerSwitches->get("Switch", "Omegad") > 0.) { + for (auto iomega = omegaPCM.begin(); iomega != omegaPCM.end(); ++iomega) { // -----> PCM + for (auto iDeuteron = deuteron.begin(); iDeuteron != deuteron.end(); ++iDeuteron) { // ---> d-omega femtoscopy + + float kstar = getkstar(*iomega, *iDeuteron); + mHistManager.fill(HIST("omegad/fSE_particle_PCM"), kstar); mHistManager.fill(HIST("omegad/fomegaPtVskstar_PCM"), kstar, (*iomega).Pt()); - mHistManager.fill(HIST("omegad/fDeuteronPtVskstar_PCM"), kstar, (*iDeuteron).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kOmegaD)) { - lowMomentumMultiplets[CFTrigger::kOmegaD] += 1; - } + mHistManager.fill(HIST("omegad/fdPtVskstar_PCM"), kstar, (*iDeuteron).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kOmegaD)) + lowMomentumMultiplets[hnmtrigger::kOmegaD] += 1; } - // omegaAd trigger - for (auto iAntiDeuteron = antideuteron.begin(); iAntiDeuteron != antideuteron.end(); ++iAntiDeuteron) { - kstar = getkstar(*iomega, *iAntiDeuteron); + for (auto iAntiDeuteron = antideuteron.begin(); iAntiDeuteron != antideuteron.end(); ++iAntiDeuteron) { // ---> antid-omega femtoscopy + + float kstar = getkstar(*iomega, *iAntiDeuteron); + mHistManager.fill(HIST("omegad/fSE_Antiparticle_PCM"), kstar); mHistManager.fill(HIST("omegad/fomegaPtVskstar_PCM"), kstar, (*iomega).Pt()); - mHistManager.fill(HIST("omegad/fAntiDeuteronPtVskstar_PCM"), kstar, (*iAntiDeuteron).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kOmegaD)) { - lowMomentumMultiplets[CFTrigger::kOmegaD] += 1; - } + mHistManager.fill(HIST("omegad/fAntidPtVskstar_PCM"), kstar, (*iAntiDeuteron).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kOmegaD)) + lowMomentumMultiplets[hnmtrigger::kOmegaD] += 1; } } - // EMC - // omegad trigger - for (auto iomega = omegaEMC.begin(); iomega != omegaEMC.end(); ++iomega) { - for (auto iDeuteron = deuteron.begin(); iDeuteron != deuteron.end(); ++iDeuteron) { - kstar = getkstar(*iomega, *iDeuteron); + for (auto iomega = omegaEMC.begin(); iomega != omegaEMC.end(); ++iomega) { // -----> EMC + for (auto iDeuteron = deuteron.begin(); iDeuteron != deuteron.end(); ++iDeuteron) { // ---> d-omega femtoscopy + + float kstar = getkstar(*iomega, *iDeuteron); + mHistManager.fill(HIST("omegad/fSE_particle_EMC"), kstar); mHistManager.fill(HIST("omegad/fomegaPtVskstar_EMC"), kstar, (*iomega).Pt()); - mHistManager.fill(HIST("omegad/fDeuteronPtVskstar_EMC"), kstar, (*iDeuteron).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kOmegaD)) { - lowMomentumMultiplets[CFTrigger::kOmegaD] += 1; - } + mHistManager.fill(HIST("omegad/fdPtVskstar_EMC"), kstar, (*iDeuteron).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kOmegaD)) + lowMomentumMultiplets[hnmtrigger::kOmegaD] += 1; } - // omegaAd trigger - for (auto iAntiDeuteron = antideuteron.begin(); iAntiDeuteron != antideuteron.end(); ++iAntiDeuteron) { - kstar = getkstar(*iomega, *iAntiDeuteron); + for (auto iAntiDeuteron = antideuteron.begin(); iAntiDeuteron != antideuteron.end(); ++iAntiDeuteron) { // ---> antid-omega femtoscopy + + float kstar = getkstar(*iomega, *iAntiDeuteron); + mHistManager.fill(HIST("omegad/fSE_Antiparticle_EMC"), kstar); mHistManager.fill(HIST("omegad/fomegaPtVskstar_EMC"), kstar, (*iomega).Pt()); - mHistManager.fill(HIST("omegad/fAntiDeuteronPtVskstar_EMC"), kstar, (*iAntiDeuteron).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kOmegaD)) { - lowMomentumMultiplets[CFTrigger::kOmegaD] += 1; - } + mHistManager.fill(HIST("omegad/fAntidPtVskstar_EMC"), kstar, (*iAntiDeuteron).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kOmegaD)) + lowMomentumMultiplets[hnmtrigger::kOmegaD] += 1; } } } - if (ConfTriggerSwitches->get("Switch", "EtaPrimed") > 0.) { - // PCM - // etaPrimed trigger - for (auto ietaprime = etaPrimePCM.begin(); ietaprime != etaPrimePCM.end(); ++ietaprime) { - for (auto iDeuteron = deuteron.begin(); iDeuteron != deuteron.end(); ++iDeuteron) { - kstar = getkstar(*ietaprime, *iDeuteron); + if (cfgTriggerSwitches->get("Switch", "EtaPrimed") > 0.) { + for (auto ietaprime = etaPrimePCM.begin(); ietaprime != etaPrimePCM.end(); ++ietaprime) { // -----> PCM + for (auto iDeuteron = deuteron.begin(); iDeuteron != deuteron.end(); ++iDeuteron) { // ---> d-eta' femtoscopy + + float kstar = getkstar(*ietaprime, *iDeuteron); + mHistManager.fill(HIST("etaprimed/fSE_particle_PCM"), kstar); mHistManager.fill(HIST("etaprimed/fetaprimePtVskstar_PCM"), kstar, (*ietaprime).Pt()); - mHistManager.fill(HIST("etaprimed/fDeuteronPtVskstar_PCM"), kstar, (*iDeuteron).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kEtaPrimeD)) { - lowMomentumMultiplets[CFTrigger::kEtaPrimeD] += 1; - } + mHistManager.fill(HIST("etaprimed/fdPtVskstar_PCM"), kstar, (*iDeuteron).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kEtaPrimeD)) + lowMomentumMultiplets[hnmtrigger::kEtaPrimeD] += 1; } - // etaPrimeAd trigger - for (auto iAntiDeuteron = antideuteron.begin(); iAntiDeuteron != antideuteron.end(); ++iAntiDeuteron) { - kstar = getkstar(*ietaprime, *iAntiDeuteron); + for (auto iAntiDeuteron = antideuteron.begin(); iAntiDeuteron != antideuteron.end(); ++iAntiDeuteron) { // ---> antid-eta' femtoscopy + + float kstar = getkstar(*ietaprime, *iAntiDeuteron); + mHistManager.fill(HIST("etaprimed/fSE_Antiparticle_PCM"), kstar); mHistManager.fill(HIST("etaprimed/fetaprimePtVskstar_PCM"), kstar, (*ietaprime).Pt()); - mHistManager.fill(HIST("etaprimed/fAntiDeuteronPtVskstar_PCM"), kstar, (*iAntiDeuteron).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kEtaPrimeD)) { - lowMomentumMultiplets[CFTrigger::kEtaPrimeD] += 1; - } + mHistManager.fill(HIST("etaprimed/fAntidPtVskstar_PCM"), kstar, (*iAntiDeuteron).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kEtaPrimeD)) + lowMomentumMultiplets[hnmtrigger::kEtaPrimeD] += 1; } } - // EMC - // etaPrimed trigger - for (auto ietaprime = etaPrimeEMC.begin(); ietaprime != etaPrimeEMC.end(); ++ietaprime) { - for (auto iDeuteron = deuteron.begin(); iDeuteron != deuteron.end(); ++iDeuteron) { - kstar = getkstar(*ietaprime, *iDeuteron); + for (auto ietaprime = etaPrimeEMC.begin(); ietaprime != etaPrimeEMC.end(); ++ietaprime) { // -----> EMC + for (auto iDeuteron = deuteron.begin(); iDeuteron != deuteron.end(); ++iDeuteron) { // ---> d-eta' femtoscopy + + float kstar = getkstar(*ietaprime, *iDeuteron); + mHistManager.fill(HIST("etaprimed/fSE_particle_EMC"), kstar); mHistManager.fill(HIST("etaprimed/fetaprimePtVskstar_EMC"), kstar, (*ietaprime).Pt()); - mHistManager.fill(HIST("etaprimed/fDeuteronPtVskstar_EMC"), kstar, (*iDeuteron).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kEtaPrimeD)) { - lowMomentumMultiplets[CFTrigger::kEtaPrimeD] += 1; - } + mHistManager.fill(HIST("etaprimed/fdPtVskstar_EMC"), kstar, (*iDeuteron).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kEtaPrimeD)) + lowMomentumMultiplets[hnmtrigger::kEtaPrimeD] += 1; } - // etaPrimeAd trigger - for (auto iAntiDeuteron = antideuteron.begin(); iAntiDeuteron != antideuteron.end(); ++iAntiDeuteron) { - kstar = getkstar(*ietaprime, *iAntiDeuteron); + for (auto iAntiDeuteron = antideuteron.begin(); iAntiDeuteron != antideuteron.end(); ++iAntiDeuteron) { // ---> antid-eta' femtoscopy + + float kstar = getkstar(*ietaprime, *iAntiDeuteron); + mHistManager.fill(HIST("etaprimed/fSE_Antiparticle_EMC"), kstar); mHistManager.fill(HIST("etaprimed/fetaprimePtVskstar_EMC"), kstar, (*ietaprime).Pt()); - mHistManager.fill(HIST("etaprimed/fAntiDeuteronPtVskstar_EMC"), kstar, (*iAntiDeuteron).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kEtaPrimeD)) { - lowMomentumMultiplets[CFTrigger::kEtaPrimeD] += 1; - } + mHistManager.fill(HIST("etaprimed/fAntidPtVskstar_EMC"), kstar, (*iAntiDeuteron).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kEtaPrimeD)) + lowMomentumMultiplets[hnmtrigger::kEtaPrimeD] += 1; } } } - if (ConfTriggerSwitches->get("Switch", "OmegaP") > 0.) { - // PCM - // omegap trigger - for (auto iomega = omegaPCM.begin(); iomega != omegaPCM.end(); ++iomega) { - for (auto iProton = proton.begin(); iProton != proton.end(); ++iProton) { - kstar = getkstar(*iomega, *iProton); + if (cfgTriggerSwitches->get("Switch", "OmegaP") > 0.) { + for (auto iomega = omegaPCM.begin(); iomega != omegaPCM.end(); ++iomega) { // -----> PCM + for (auto iProton = proton.begin(); iProton != proton.end(); ++iProton) { // ---> p-omega femtoscopy + + float kstar = getkstar(*iomega, *iProton); + mHistManager.fill(HIST("omegap/fSE_particle_PCM"), kstar); mHistManager.fill(HIST("omegap/fomegaPtVskstar_PCM"), kstar, (*iomega).Pt()); - mHistManager.fill(HIST("omegap/fProtonPtVskstar_PCM"), kstar, (*iProton).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kOmegaP)) { - lowMomentumMultiplets[CFTrigger::kOmegaP] += 1; - } + mHistManager.fill(HIST("omegap/fpPtVskstar_PCM"), kstar, (*iProton).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kOmegaP)) + lowMomentumMultiplets[hnmtrigger::kOmegaP] += 1; } - // omegaAp trigger - for (auto iAntiProton = antiproton.begin(); iAntiProton != antiproton.end(); ++iAntiProton) { - kstar = getkstar(*iomega, *iAntiProton); + for (auto iAntiProton = antiproton.begin(); iAntiProton != antiproton.end(); ++iAntiProton) { // ---> antip-omega femtoscopy + + float kstar = getkstar(*iomega, *iAntiProton); + mHistManager.fill(HIST("omegap/fSE_Antiparticle_PCM"), kstar); mHistManager.fill(HIST("omegap/fomegaPtVskstar_PCM"), kstar, (*iomega).Pt()); - mHistManager.fill(HIST("omegap/fAntiProtonPtVskstar_PCM"), kstar, (*iAntiProton).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kOmegaP)) { - lowMomentumMultiplets[CFTrigger::kOmegaP] += 1; - } + mHistManager.fill(HIST("omegap/fAntipPtVskstar_PCM"), kstar, (*iAntiProton).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kOmegaP)) + lowMomentumMultiplets[hnmtrigger::kOmegaP] += 1; } } - // EMC - // omegap trigger - for (auto iomega = omegaEMC.begin(); iomega != omegaEMC.end(); ++iomega) { - for (auto iProton = proton.begin(); iProton != proton.end(); ++iProton) { - kstar = getkstar(*iomega, *iProton); + for (auto iomega = omegaEMC.begin(); iomega != omegaEMC.end(); ++iomega) { // -----> EMC + for (auto iProton = proton.begin(); iProton != proton.end(); ++iProton) { // ---> p-omega femtoscopy + + float kstar = getkstar(*iomega, *iProton); + mHistManager.fill(HIST("omegap/fSE_particle_EMC"), kstar); mHistManager.fill(HIST("omegap/fomegaPtVskstar_EMC"), kstar, (*iomega).Pt()); - mHistManager.fill(HIST("omegap/fProtonPtVskstar_EMC"), kstar, (*iProton).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kOmegaP)) { - lowMomentumMultiplets[CFTrigger::kOmegaP] += 1; - } + mHistManager.fill(HIST("omegap/fpPtVskstar_EMC"), kstar, (*iProton).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kOmegaP)) + lowMomentumMultiplets[hnmtrigger::kOmegaP] += 1; } - // omegaAp trigger - for (auto iAntiProton = antiproton.begin(); iAntiProton != antiproton.end(); ++iAntiProton) { - kstar = getkstar(*iomega, *iAntiProton); + for (auto iAntiProton = antiproton.begin(); iAntiProton != antiproton.end(); ++iAntiProton) { // ---> antip-omega femtoscopy + + float kstar = getkstar(*iomega, *iAntiProton); + mHistManager.fill(HIST("omegap/fSE_Antiparticle_EMC"), kstar); mHistManager.fill(HIST("omegap/fomegaPtVskstar_EMC"), kstar, (*iomega).Pt()); - mHistManager.fill(HIST("omegap/fAntiProtonPtVskstar_EMC"), kstar, (*iAntiProton).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kOmegaP)) { - lowMomentumMultiplets[CFTrigger::kOmegaP] += 1; - } + mHistManager.fill(HIST("omegap/fAntipPtVskstar_EMC"), kstar, (*iAntiProton).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kOmegaP)) + lowMomentumMultiplets[hnmtrigger::kOmegaP] += 1; } } } - if (ConfTriggerSwitches->get("Switch", "EtaPrimeP") > 0.) { - // PCM - // etaPrimep trigger - for (auto ietaprime = etaPrimePCM.begin(); ietaprime != etaPrimePCM.end(); ++ietaprime) { - for (auto iProton = proton.begin(); iProton != proton.end(); ++iProton) { - kstar = getkstar(*ietaprime, *iProton); + if (cfgTriggerSwitches->get("Switch", "EtaPrimeP") > 0.) { + for (auto ietaprime = etaPrimePCM.begin(); ietaprime != etaPrimePCM.end(); ++ietaprime) { // -----> PCM + for (auto iProton = proton.begin(); iProton != proton.end(); ++iProton) { // ---> p-eta' femtoscopy + + float kstar = getkstar(*ietaprime, *iProton); + mHistManager.fill(HIST("etaprimep/fSE_particle_PCM"), kstar); mHistManager.fill(HIST("etaprimep/fetaprimePtVskstar_PCM"), kstar, (*ietaprime).Pt()); - mHistManager.fill(HIST("etaprimep/fProtonPtVskstar_PCM"), kstar, (*iProton).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kEtaPrimeP)) { - lowMomentumMultiplets[CFTrigger::kEtaPrimeP] += 1; - } + mHistManager.fill(HIST("etaprimep/fpPtVskstar_PCM"), kstar, (*iProton).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kEtaPrimeP)) + lowMomentumMultiplets[hnmtrigger::kEtaPrimeP] += 1; } - // etaPrimeAp trigger - for (auto iAntiProton = antiproton.begin(); iAntiProton != antiproton.end(); ++iAntiProton) { - kstar = getkstar(*ietaprime, *iAntiProton); + for (auto iAntiProton = antiproton.begin(); iAntiProton != antiproton.end(); ++iAntiProton) { // ---> antip-eta' femtoscopy + + float kstar = getkstar(*ietaprime, *iAntiProton); + mHistManager.fill(HIST("etaprimep/fSE_Antiparticle_PCM"), kstar); mHistManager.fill(HIST("etaprimep/fetaprimePtVskstar_PCM"), kstar, (*ietaprime).Pt()); - mHistManager.fill(HIST("etaprimep/fAntiProtonPtVskstar_PCM"), kstar, (*iAntiProton).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kEtaPrimeP)) { - lowMomentumMultiplets[CFTrigger::kEtaPrimeP] += 1; - } + mHistManager.fill(HIST("etaprimep/fAntipPtVskstar_PCM"), kstar, (*iAntiProton).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kEtaPrimeP)) + lowMomentumMultiplets[hnmtrigger::kEtaPrimeP] += 1; } } - // EMC - // etaPrimep trigger - for (auto ietaprime = etaPrimeEMC.begin(); ietaprime != etaPrimeEMC.end(); ++ietaprime) { - for (auto iProton = proton.begin(); iProton != proton.end(); ++iProton) { - kstar = getkstar(*ietaprime, *iProton); + for (auto ietaprime = etaPrimeEMC.begin(); ietaprime != etaPrimeEMC.end(); ++ietaprime) { // -----> EMC + for (auto iProton = proton.begin(); iProton != proton.end(); ++iProton) { // ---> p-eta' femtoscopy + + float kstar = getkstar(*ietaprime, *iProton); + mHistManager.fill(HIST("etaprimep/fSE_particle_EMC"), kstar); mHistManager.fill(HIST("etaprimep/fetaprimePtVskstar_EMC"), kstar, (*ietaprime).Pt()); - mHistManager.fill(HIST("etaprimep/fProtonPtVskstar_EMC"), kstar, (*iProton).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kEtaPrimeP)) { - lowMomentumMultiplets[CFTrigger::kEtaPrimeP] += 1; - } + mHistManager.fill(HIST("etaprimep/fpPtVskstar_EMC"), kstar, (*iProton).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kEtaPrimeP)) + lowMomentumMultiplets[hnmtrigger::kEtaPrimeP] += 1; } - // etaPrimeAp trigger - for (auto iAntiProton = antiproton.begin(); iAntiProton != antiproton.end(); ++iAntiProton) { - kstar = getkstar(*ietaprime, *iAntiProton); + for (auto iAntiProton = antiproton.begin(); iAntiProton != antiproton.end(); ++iAntiProton) { // ---> antip-eta' femtoscopy + + float kstar = getkstar(*ietaprime, *iAntiProton); + mHistManager.fill(HIST("etaprimep/fSE_Antiparticle_EMC"), kstar); mHistManager.fill(HIST("etaprimep/fetaprimePtVskstar_EMC"), kstar, (*ietaprime).Pt()); - mHistManager.fill(HIST("etaprimep/fAntiProtonPtVskstar_EMC"), kstar, (*iAntiProton).Pt()); - if (kstar < ConfKinematicLimits->get(static_cast(0), CFTrigger::kEtaPrimeP)) { - lowMomentumMultiplets[CFTrigger::kEtaPrimeP] += 1; - } + mHistManager.fill(HIST("etaprimep/fAntipPtVskstar_EMC"), kstar, (*iAntiProton).Pt()); + + if (kstar < cfgKinematicLimits->get(static_cast(0), hnmtrigger::kEtaPrimeP)) + lowMomentumMultiplets[hnmtrigger::kEtaPrimeP] += 1; } } } - // create tags for three body triggers - if (lowMomentumMultiplets[CFTrigger::kPPOmega] > 0) { - keepFemtoEvent[CFTrigger::kPPOmega] = true; - mHistManager.fill(HIST("fProcessedEvents"), 2); + // -----------------------------> Create femto tags <----------------------------------- + // - Set keepFemtoEvent flags for each HNM type based on the lowMomentumMultiplets + // - Fill histograms for the multiplicity and z-vertex of femto-accepted events + // ------------------------------------------------------------------------------------- + if (lowMomentumMultiplets[hnmtrigger::kPPOmega] > 0) { + keepFemtoEvent[hnmtrigger::kPPOmega] = true; + mHistManager.fill(HIST("fProcessedEvents"), 6); mHistManager.fill(HIST("ppomega/fMultiplicity"), collision.multNTracksPV()); mHistManager.fill(HIST("ppomega/fZvtx"), collision.posZ()); } - if (lowMomentumMultiplets[CFTrigger::kPPEtaPrime] > 0) { - keepFemtoEvent[CFTrigger::kPPEtaPrime] = true; - mHistManager.fill(HIST("fProcessedEvents"), 3); + if (lowMomentumMultiplets[hnmtrigger::kPPEtaPrime] > 0) { + keepFemtoEvent[hnmtrigger::kPPEtaPrime] = true; + mHistManager.fill(HIST("fProcessedEvents"), 7); mHistManager.fill(HIST("ppetaprime/fMultiplicity"), collision.multNTracksPV()); mHistManager.fill(HIST("ppetaprime/fZvtx"), collision.posZ()); } - if (lowMomentumMultiplets[CFTrigger::kOmegaD] > 0) { - keepFemtoEvent[CFTrigger::kOmegaD] = true; - mHistManager.fill(HIST("fProcessedEvents"), 4); + if (lowMomentumMultiplets[hnmtrigger::kOmegaD] > 0) { + keepFemtoEvent[hnmtrigger::kOmegaD] = true; + mHistManager.fill(HIST("fProcessedEvents"), 8); mHistManager.fill(HIST("omegad/fMultiplicity"), collision.multNTracksPV()); mHistManager.fill(HIST("omegad/fZvtx"), collision.posZ()); } - if (lowMomentumMultiplets[CFTrigger::kEtaPrimeD] > 0) { - keepFemtoEvent[CFTrigger::kEtaPrimeD] = true; - mHistManager.fill(HIST("fProcessedEvents"), 5); + if (lowMomentumMultiplets[hnmtrigger::kEtaPrimeD] > 0) { + keepFemtoEvent[hnmtrigger::kEtaPrimeD] = true; + mHistManager.fill(HIST("fProcessedEvents"), 9); mHistManager.fill(HIST("etaprimed/fMultiplicity"), collision.multNTracksPV()); mHistManager.fill(HIST("etaprimed/fZvtx"), collision.posZ()); } - if (lowMomentumMultiplets[CFTrigger::kOmegaP] > 0) { - keepFemtoEvent[CFTrigger::kOmegaP] = true; - mHistManager.fill(HIST("fProcessedEvents"), 6); + if (lowMomentumMultiplets[hnmtrigger::kOmegaP] > 0) { + keepFemtoEvent[hnmtrigger::kOmegaP] = true; + mHistManager.fill(HIST("fProcessedEvents"), 10); mHistManager.fill(HIST("omegap/fMultiplicity"), collision.multNTracksPV()); mHistManager.fill(HIST("omegap/fZvtx"), collision.posZ()); } - if (lowMomentumMultiplets[CFTrigger::kEtaPrimeP] > 0) { - keepFemtoEvent[CFTrigger::kEtaPrimeP] = true; - mHistManager.fill(HIST("fProcessedEvents"), 7); + if (lowMomentumMultiplets[hnmtrigger::kEtaPrimeP] > 0) { + keepFemtoEvent[hnmtrigger::kEtaPrimeP] = true; + mHistManager.fill(HIST("fProcessedEvents"), 11); mHistManager.fill(HIST("etaprimep/fMultiplicity"), collision.multNTracksPV()); mHistManager.fill(HIST("etaprimep/fZvtx"), collision.posZ()); } - // #set flag for tag - if (ConfKeepTwoBody.value) { - tags(colContainsPCMOmega, colContainsEMCOmega, colContainsPCMEtaPrime, colContainsEMCEtaPrime, - keepFemtoEvent[CFTrigger::kPPOmega] || keepFemtoEvent[CFTrigger::kOmegaP], keepFemtoEvent[CFTrigger::kPPEtaPrime] || keepFemtoEvent[CFTrigger::kEtaPrimeP], - keepFemtoEvent[CFTrigger::kOmegaD], keepFemtoEvent[CFTrigger::kEtaPrimeD]); - } else { - tags(colContainsPCMOmega, colContainsEMCOmega, colContainsPCMEtaPrime, colContainsEMCEtaPrime, - keepFemtoEvent[CFTrigger::kPPOmega], keepFemtoEvent[CFTrigger::kPPEtaPrime], - keepFemtoEvent[CFTrigger::kOmegaD], keepFemtoEvent[CFTrigger::kEtaPrimeD]); - } + // -----------------------------> Set trigger flags <----------------------------------- + // - 4 high pT spectrum trigger flags (PCM & EMC * omega & eta') + // - 4 femto trigger flags (p-omega, p-eta', d-omega || pp-omega, d-eta' || pp-eta') + // ------------------------------------------------------------------------------------- + tags(colContainsPCMOmega, colContainsEMCOmega, colContainsPCMEtaPrime, colContainsEMCEtaPrime, keepFemtoEvent[hnmtrigger::kOmegaP], keepFemtoEvent[hnmtrigger::kEtaPrimeP], + keepFemtoEvent[hnmtrigger::kPPOmega] || keepFemtoEvent[hnmtrigger::kOmegaD], keepFemtoEvent[hnmtrigger::kPPEtaPrime] || keepFemtoEvent[hnmtrigger::kEtaPrimeD]); - if (!keepFemtoEvent[CFTrigger::kPPOmega] && !keepFemtoEvent[CFTrigger::kOmegaP] && !keepFemtoEvent[CFTrigger::kPPEtaPrime] && !keepFemtoEvent[CFTrigger::kEtaPrimeP] && - !keepFemtoEvent[CFTrigger::kOmegaD] && !keepFemtoEvent[CFTrigger::kEtaPrimeD]) { - mHistManager.fill(HIST("fProcessedEvents"), 1); - } + if (!colContainsPCMOmega && !colContainsEMCOmega && !colContainsPCMEtaPrime && !colContainsEMCEtaPrime && !keepFemtoEvent[hnmtrigger::kPPOmega] && !keepFemtoEvent[hnmtrigger::kOmegaP] && !keepFemtoEvent[hnmtrigger::kPPEtaPrime] && !keepFemtoEvent[hnmtrigger::kEtaPrimeP] && !keepFemtoEvent[hnmtrigger::kOmegaD] && !keepFemtoEvent[hnmtrigger::kEtaPrimeD]) + mHistManager.fill(HIST("fProcessedEvents"), 1); // Fill "rejected", if no trigger selected the event } /// \brief Loop over the GG candidates, fill the mass/pt histograms and set the isPi0/isEta flags based on the reconstructed mass @@ -1481,9 +1146,9 @@ struct HeavyNeutralMesonFilter { mHistManager.fill(HIST("GG/invMassVsPt_PCMEMC"), lightMeson->m(), lightMeson->pT()); } - if (lightMeson->m() > massWindowOmega->get("pi0_min") && lightMeson->m() < massWindowOmega->get("pi0_max")) { + if (lightMeson->m() > cfgMassWindowOmega->get("pi0_min") && lightMeson->m() < cfgMassWindowOmega->get("pi0_max")) { lightMeson->isPi0 = true; - } else if (lightMeson->m() > massWindowEtaPrime->get("eta_min") && lightMeson->m() < massWindowEtaPrime->get("eta_max")) { + } else if (lightMeson->m() > cfgMassWindowEtaPrime->get("eta_min") && lightMeson->m() < cfgMassWindowEtaPrime->get("eta_max")) { lightMeson->isEta = true; } else { vGGs.erase(vGGs.begin() + iGG); @@ -1497,93 +1162,82 @@ struct HeavyNeutralMesonFilter { void processHNMs(std::vector& vHNMs) { int nHNMsBeforeMassCuts = vHNMs.size(); + for (unsigned int iHNM = 0; iHNM < vHNMs.size(); iHNM++) { auto heavyNeutralMeson = vHNMs.at(iHNM); - float massHNM = heavyNeutralMeson.m(cfgHNMMassCorrection); + if (heavyNeutralMeson.gg->reconstructionType == photonpair::kPCMPCM) { - if (heavyNeutralMeson.gg->isPi0) - mHistManager.fill(HIST("Omega/invMassVsPt_PCM"), massHNM, heavyNeutralMeson.pT()); - else if (heavyNeutralMeson.gg->isEta) - mHistManager.fill(HIST("EtaPrime/invMassVsPt_PCM"), massHNM, heavyNeutralMeson.pT()); - // QA - mHistManager.fill(HIST("TrackCuts/HMN/Before/PCM/fInvMass"), massHNM); - mHistManager.fill(HIST("TrackCuts/HMN/Before/PCM/fPt"), heavyNeutralMeson.pT()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/PCM/fEta"), heavyNeutralMeson.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/PCM/fPhi"), translatePhi(heavyNeutralMeson.phi())); + if (heavyNeutralMeson.gg->isPi0) { + mHistManager.fill(HIST("HNM/Before/Omega/PCM/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/Omega/PCM/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/Omega/PCM/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } else if (heavyNeutralMeson.gg->isEta) { + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCM/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCM/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCM/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } } else if (heavyNeutralMeson.gg->reconstructionType == photonpair::kEMCEMC) { - if (heavyNeutralMeson.gg->isPi0) - mHistManager.fill(HIST("Omega/invMassVsPt_EMC"), massHNM, heavyNeutralMeson.pT()); - else if (heavyNeutralMeson.gg->isEta) - mHistManager.fill(HIST("EtaPrime/invMassVsPt_EMC"), massHNM, heavyNeutralMeson.pT()); - // QA - mHistManager.fill(HIST("TrackCuts/HMN/Before/EMC/fInvMass"), massHNM); - mHistManager.fill(HIST("TrackCuts/HMN/Before/EMC/fPt"), heavyNeutralMeson.pT()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/EMC/fEta"), heavyNeutralMeson.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/EMC/fPhi"), translatePhi(heavyNeutralMeson.phi())); + if (heavyNeutralMeson.gg->isPi0) { + mHistManager.fill(HIST("HNM/Before/Omega/EMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/Omega/EMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/Omega/EMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } else if (heavyNeutralMeson.gg->isEta) { + mHistManager.fill(HIST("HNM/Before/EtaPrime/EMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/EMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/EMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } } else { - if (heavyNeutralMeson.gg->isPi0) - mHistManager.fill(HIST("Omega/invMassVsPt_PCMEMC"), massHNM, heavyNeutralMeson.pT()); - else if (heavyNeutralMeson.gg->isEta) - mHistManager.fill(HIST("EtaPrime/invMassVsPt_PCMEMC"), massHNM, heavyNeutralMeson.pT()); - // QA - mHistManager.fill(HIST("TrackCuts/HMN/Before/PCMEMC/fInvMass"), massHNM); - mHistManager.fill(HIST("TrackCuts/HMN/Before/PCMEMC/fPt"), heavyNeutralMeson.pT()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/PCMEMC/fEta"), heavyNeutralMeson.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/Before/PCMEMC/fPhi"), translatePhi(heavyNeutralMeson.phi())); + if (heavyNeutralMeson.gg->isPi0) { + mHistManager.fill(HIST("HNM/Before/Omega/PCMEMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/Omega/PCMEMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/Omega/PCMEMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } else if (heavyNeutralMeson.gg->isEta) { + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCMEMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCMEMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCMEMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } } - if (heavyNeutralMeson.gg->isPi0 && massHNM > massWindowOmega->get("omega_min") && massHNM < massWindowOmega->get("omega_max")) { + if (heavyNeutralMeson.gg->isPi0 && massHNM > cfgMassWindowOmega->get("omega_min") && massHNM < cfgMassWindowOmega->get("omega_max")) { if (heavyNeutralMeson.gg->reconstructionType == photonpair::kPCMPCM) { - if (heavyNeutralMeson.pT() > minFemtoHNMPts->get("PCM_omega")) { - omegaPCM.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), translatePhi(heavyNeutralMeson.phi()), mMassOmega); - // QA - mHistManager.fill(HIST("TrackCuts/HMN/After/Omega/PCM/fInvMass"), massHNM); - mHistManager.fill(HIST("TrackCuts/HMN/After/Omega/PCM/fPt"), heavyNeutralMeson.pT()); - mHistManager.fill(HIST("TrackCuts/HMN/After/Omega/PCM/fEta"), heavyNeutralMeson.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/After/Omega/PCM/fPhi"), translatePhi(heavyNeutralMeson.phi())); + if (heavyNeutralMeson.pT() > cfgMinHNMPtsFemtoTrigger->get("PCM_omega")) { + omegaPCM.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), RecoDecay::constrainAngle(heavyNeutralMeson.phi()), mMassOmega); + mHistManager.fill(HIST("HNM/After/Omega/PCM/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/After/Omega/PCM/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/After/Omega/PCM/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); } - if (heavyNeutralMeson.pT() > minHNMPts->get("PCM_omega")) { + if (heavyNeutralMeson.pT() > cfgMinHNMPtsSpectrumTrigger->get("PCM_omega")) colContainsPCMOmega = true; - } } else if (heavyNeutralMeson.gg->reconstructionType == photonpair::kEMCEMC) { - if (heavyNeutralMeson.pT() > minFemtoHNMPts->get("EMC_omega")) { - omegaEMC.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), translatePhi(heavyNeutralMeson.phi()), mMassOmega); - // QA - mHistManager.fill(HIST("TrackCuts/HMN/After/Omega/EMC/fInvMass"), massHNM); - mHistManager.fill(HIST("TrackCuts/HMN/After/Omega/EMC/fPt"), heavyNeutralMeson.pT()); - mHistManager.fill(HIST("TrackCuts/HMN/After/Omega/EMC/fEta"), heavyNeutralMeson.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/After/Omega/EMC/fPhi"), translatePhi(heavyNeutralMeson.phi())); + if (heavyNeutralMeson.pT() > cfgMinHNMPtsFemtoTrigger->get("EMC_omega")) { + omegaEMC.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), RecoDecay::constrainAngle(heavyNeutralMeson.phi()), mMassOmega); + mHistManager.fill(HIST("HNM/After/Omega/EMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/After/Omega/EMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/After/Omega/EMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); } - if (heavyNeutralMeson.pT() > minHNMPts->get("EMC_omega")) { + if (heavyNeutralMeson.pT() > cfgMinHNMPtsSpectrumTrigger->get("EMC_omega")) colContainsEMCOmega = true; - } } - } else if (heavyNeutralMeson.gg->isEta && massHNM > massWindowEtaPrime->get("etaprime_min") && massHNM < massWindowEtaPrime->get("etaprime_max")) { + } else if (heavyNeutralMeson.gg->isEta && massHNM > cfgMassWindowEtaPrime->get("etaprime_min") && massHNM < cfgMassWindowEtaPrime->get("etaprime_max")) { if (heavyNeutralMeson.gg->reconstructionType == photonpair::kPCMPCM) { - if (heavyNeutralMeson.pT() > minFemtoHNMPts->get("PCM_etaprime")) { - etaPrimePCM.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), translatePhi(heavyNeutralMeson.phi()), mMassEtaPrime); - // QA - mHistManager.fill(HIST("TrackCuts/HMN/After/EtaPrime/PCM/fInvMass"), massHNM); - mHistManager.fill(HIST("TrackCuts/HMN/After/EtaPrime/PCM/fPt"), heavyNeutralMeson.pT()); - mHistManager.fill(HIST("TrackCuts/HMN/After/EtaPrime/PCM/fEta"), heavyNeutralMeson.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/After/EtaPrime/PCM/fPhi"), translatePhi(heavyNeutralMeson.phi())); + if (heavyNeutralMeson.pT() > cfgMinHNMPtsFemtoTrigger->get("PCM_etaprime")) { + etaPrimePCM.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), RecoDecay::constrainAngle(heavyNeutralMeson.phi()), mMassEtaPrime); + mHistManager.fill(HIST("HNM/After/EtaPrime/PCM/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/After/EtaPrime/PCM/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/After/EtaPrime/PCM/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); } - if (heavyNeutralMeson.pT() > minHNMPts->get("PCM_etaprime")) { + if (heavyNeutralMeson.pT() > cfgMinHNMPtsSpectrumTrigger->get("PCM_etaprime")) colContainsPCMEtaPrime = true; - } } else if (heavyNeutralMeson.gg->reconstructionType == photonpair::kEMCEMC) { - if (heavyNeutralMeson.pT() > minFemtoHNMPts->get("EMC_etaprime")) { - etaPrimeEMC.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), translatePhi(heavyNeutralMeson.phi()), mMassEtaPrime); - // QA - mHistManager.fill(HIST("TrackCuts/HMN/After/EtaPrime/EMC/fInvMass"), massHNM); - mHistManager.fill(HIST("TrackCuts/HMN/After/EtaPrime/EMC/fPt"), heavyNeutralMeson.pT()); - mHistManager.fill(HIST("TrackCuts/HMN/After/EtaPrime/EMC/fEta"), heavyNeutralMeson.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/After/EtaPrime/EMC/fPhi"), translatePhi(heavyNeutralMeson.phi())); + if (heavyNeutralMeson.pT() > cfgMinHNMPtsFemtoTrigger->get("EMC_etaprime")) { + etaPrimeEMC.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), RecoDecay::constrainAngle(heavyNeutralMeson.phi()), mMassEtaPrime); + mHistManager.fill(HIST("HNM/After/EtaPrime/EMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/After/EtaPrime/EMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/After/EtaPrime/EMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); } - if (heavyNeutralMeson.pT() > minHNMPts->get("EMC_etaprime")) { + if (heavyNeutralMeson.pT() > cfgMinHNMPtsSpectrumTrigger->get("EMC_etaprime")) colContainsEMCEtaPrime = true; - } } } else { vHNMs.erase(vHNMs.begin() + iHNM); @@ -1592,26 +1246,15 @@ struct HeavyNeutralMesonFilter { } mHistManager.fill(HIST("Event/nHeavyNeutralMesons"), nHNMsBeforeMassCuts, vHNMs.size()); - if (colContainsPCMOmega) { - mHistManager.fill(HIST("Event/hCollisionCounter"), 2.); - mHistManager.fill(HIST("fProcessedEvents"), 9); - } - if (colContainsEMCOmega) { - mHistManager.fill(HIST("Event/hCollisionCounter"), 3.); - mHistManager.fill(HIST("fProcessedEvents"), 10); - } - if (colContainsPCMEtaPrime) { - mHistManager.fill(HIST("Event/hCollisionCounter"), 4.); - mHistManager.fill(HIST("fProcessedEvents"), 11); - } - if (colContainsEMCEtaPrime) { - mHistManager.fill(HIST("Event/hCollisionCounter"), 5.); - mHistManager.fill(HIST("fProcessedEvents"), 12); - } + if (colContainsPCMOmega) + mHistManager.fill(HIST("fProcessedEvents"), 2); + if (colContainsEMCOmega) + mHistManager.fill(HIST("fProcessedEvents"), 3); + if (colContainsPCMEtaPrime) + mHistManager.fill(HIST("fProcessedEvents"), 4); + if (colContainsEMCEtaPrime) + mHistManager.fill(HIST("fProcessedEvents"), 5); } }; -WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& cfgc) -{ - return WorkflowSpec{adaptAnalysisTask(cfgc)}; -} +WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } diff --git a/EventFiltering/PWGHF/HFFilter.cxx b/EventFiltering/PWGHF/HFFilter.cxx index a0830524997..14390515f56 100644 --- a/EventFiltering/PWGHF/HFFilter.cxx +++ b/EventFiltering/PWGHF/HFFilter.cxx @@ -75,7 +75,7 @@ struct HfFilter { // Main struct for HF triggers // nsigma PID (except for V0 and cascades) Configurable> nSigmaPidCuts{"nSigmaPidCuts", {cutsNsigma[0], 4, 8, labelsRowsNsigma, labelsColumnsNsigma}, "Nsigma cuts for ITS/TPC/TOF PID (except for V0 and cascades)"}; // min and max pts for tracks and bachelors (except for V0 and cascades) - Configurable> ptCuts{"ptCuts", {cutsPt[0], 2, 9, labelsRowsCutsPt, labelsColumnsCutsPt}, "minimum and maximum pT for bachelor tracks (except for V0 and cascades)"}; + Configurable> ptCuts{"ptCuts", {cutsPt[0], 2, 10, labelsRowsCutsPt, labelsColumnsCutsPt}, "minimum and maximum pT for bachelor tracks (except for V0 and cascades)"}; // parameters for high-pT triggers Configurable> ptThresholds{"ptThresholds", {cutsHighPtThresholds[0], 1, 2, labelsEmpty, labelsColumnsHighPtThresholds}, "pT treshold for high pT charm hadron candidates for kHighPt triggers in GeV/c"}; @@ -208,6 +208,7 @@ struct HfFilter { // Main struct for HF triggers helper.setPtLimitsDeuteronForFemto(ptCuts->get(0u, 6u), ptCuts->get(1u, 6u)); helper.setPtLimitsCharmBaryonBachelor(ptCuts->get(0u, 3u), ptCuts->get(1u, 3u)); helper.setPtLimitsLcResonanceBachelor(ptCuts->get(0u, 8u), ptCuts->get(1u, 8u)); + helper.setPtLimitsThetaCBachelor(ptCuts->get(0u, 9u), ptCuts->get(1u, 9u)); helper.setCutsSingleTrackBeauty(cutsTrackBeauty3Prong, cutsTrackBeauty4Prong, cutsTrackBeauty4Prong); helper.setCutsSingleTrackCharmBaryonBachelor(cutsTrackCharmBaryonBachelor); helper.setCutsBhadrons(cutsBtoHadrons.cutsBplus, cutsBtoHadrons.cutsBzeroToDstar, cutsBtoHadrons.cutsBc, cutsBtoHadrons.cutsBzero, cutsBtoHadrons.cutsBs, cutsBtoHadrons.cutsLb, cutsBtoHadrons.cutsXib); @@ -977,11 +978,14 @@ struct HfFilter { // Main struct for HF triggers o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, trackParBachelorProton, 2.f, noMatCorr, &dcaInfoBachProton); } std::array pVecProton = trackProton.pVector(); - bool isSelProton = helper.isSelectedProtonFromLcReso(trackProton); - if (isSelProton) { + bool isSelPIDProton = helper.isSelectedProton4CharmOrBeautyBaryons(trackProton); + if (isSelPIDProton) { if (!keepEvent[kPrCharm2P]) { // we first look for a D*+ for (const auto& trackBachelorId : trackIdsThisCollision) { // start loop over tracks to find bachelor pion + if (!helper.isSelectedProtonFromLcResoOrThetaC(trackProton)) { + continue; + } // stop here if proton below pT threshold for thetaC to avoid computational losses auto trackBachelor = tracks.rawIteratorAt(trackBachelorId.trackId()); if (trackBachelor.globalIndex() == trackPos.globalIndex() || trackBachelor.globalIndex() == trackNeg.globalIndex() || trackBachelor.globalIndex() == trackProton.globalIndex()) { continue; @@ -1064,6 +1068,9 @@ struct HfFilter { // Main struct for HF triggers if (pt2Prong < cutsPtDeltaMassCharmReso->get(3u, 11u)) { continue; } + if (!helper.isSelectedProtonFromLcResoOrThetaC(trackProton)) { + continue; + } float massLcStarCand{-999.}, massLcStarBarCand{-999.}; float massDiffLcStarCand{-999.}, massDiffLcStarBarCand{-999.}; bool isRightSignLcStar{false}, isRightSignLcStarBar{false}; diff --git a/EventFiltering/PWGHF/HFFilterHelpers.h b/EventFiltering/PWGHF/HFFilterHelpers.h index bbd792841a3..798a96b1ec7 100644 --- a/EventFiltering/PWGHF/HFFilterHelpers.h +++ b/EventFiltering/PWGHF/HFFilterHelpers.h @@ -298,9 +298,9 @@ constexpr float cutsPtThresholdsForFemto[1][2] = {{8., 1.4}}; // proton, deutero static const std::vector labelsColumnsPtThresholdsForFemto = {"Proton", "Deuteron"}; // min and max pT for all tracks combined (except for V0 and cascades) -constexpr float cutsPt[2][9] = {{1., 0.1, 0.8, 0.5, 0.1, 0.2, 0.4, 0.5, 0.3}, - {100000., 100000., 5., 100000., 100000., 100000., 100000., 100000., 100000.}}; // beauty, D*, femto, SigmaC, Xic*+ -> SigmaC++K-, beauty to JPsi, Lc*->D0p -static const std::vector labelsColumnsCutsPt = {"Beauty", "DstarPlus", "PrForFemto", "CharmBaryon", "SoftPiSigmaC", "SoftKaonXicResoToSigmaC", "DeForFemto", "BeautyToJPsi", "PrForLcReso"}; +constexpr float cutsPt[2][10] = {{1., 0.1, 0.8, 0.5, 0.1, 0.2, 0.4, 0.5, 0.3, 0.3}, + {100000., 100000., 5., 100000., 100000., 100000., 100000., 100000., 100000., 100000.}}; // beauty, D*, femto, SigmaC, Xic*+ -> SigmaC++K-, beauty to JPsi, Lc*->D0p +static const std::vector labelsColumnsCutsPt = {"Beauty", "DstarPlus", "PrForFemto", "CharmBaryon", "SoftPiSigmaC", "SoftKaonXicResoToSigmaC", "DeForFemto", "BeautyToJPsi", "PrForLcReso", "PrForThetaC"}; static const std::vector labelsRowsCutsPt = {"Minimum", "Maximum"}; // PID cuts @@ -481,6 +481,11 @@ class HfFilterHelper mPtMinLcResonanceBachelor = minPt; mPtMaxLcResonanceBachelor = maxPt; } + void setPtLimitsThetaCBachelor(float minPt, float maxPt) + { + mPtMinThetaCBachelor = minPt; + mPtMaxThetaCBachelor = maxPt; + } void setNsigmaProtonCutsForFemto(std::array nSigmaCuts) { mNSigmaPrCutsForFemto = nSigmaCuts; } void setNsigmaDeuteronCutsForFemto(std::array nSigmaCuts) { mNSigmaDeCutsForFemto = nSigmaCuts; } @@ -628,8 +633,8 @@ class HfFilterHelper bool isSelectedXiBach(T const& trackParCasc, T const& trackParBachelor, int8_t isSelBachelor, C const& collision, o2::vertexing::DCAFitterN<2>& dcaFitter, const int& activateQA, H2 hMassVsPtXiPi, H2 hMassVsPtXiKa); template bool isSelectedXiBachBach(T const& trackParCasc, std::array const& trackParBachelor, C const& collision, o2::vertexing::DCAFitterN& dcaFitter, const int& activateQA, H2 hMassVsPtXiPiPi); - template - bool isSelectedProtonFromLcReso(const T& track); + template + bool isSelectedProtonFromLcResoOrThetaC(const T& track); // helpers template T computeRelativeMomentum(const std::array& pTrack, const std::array& CharmCandMomentum, const T& CharmMass); @@ -682,6 +687,7 @@ class HfFilterHelper float mPtMinDeuteronForFemto{0.8}; // minimum pt for the deuteron for femto float mPtMinCharmBaryonBachelor{0.5}; // minimum pt for the bachelor pion from Xic/Omegac decays float mPtMinLcResonanceBachelor{0.3}; // minimum pt for the bachelor proton from Lc resonance decays + float mPtMinThetaCBachelor{0.3}; // minimum pt for the bachelor proton from ThetaC decays float mPtMaxSoftPionForDstar{2.}; // maximum pt for the D*+ soft pion float mPtMaxBeautyBachelor{100000.}; // maximum pt for the b-hadron pion daughter float mPtMaxBeautyToJPsiBachelor{100000.}; // maximum pt for the b-hadron -> JPsi X daughters (not the muons) @@ -689,6 +695,7 @@ class HfFilterHelper float mPtMaxDeuteronForFemto{5.0}; // maximum pt for the deuteron for femto float mPtMaxCharmBaryonBachelor{100000.}; // maximum pt for the bachelor pion from Xic/Omegac decays float mPtMaxLcResonanceBachelor{100000.}; // maximum pt for the bachelor proton from Lc resonance decays + float mPtMaxThetaCBachelor{100000.}; // maximum pt for the bachelor proton from ThetaC decays float mPtThresholdProtonForFemto{8.}; // pt threshold to change strategy for proton PID for femto float mPtThresholdDeuteronForFemto{1.4}; // pt threshold to change strategy for deuteron PID for femto float mPtMinSigmaCZero{0.f}; // pt min SigmaC0 candidate @@ -1945,19 +1952,22 @@ inline bool HfFilterHelper::isSelectedKaon4Charm3ProngOrBeautyToJPsi(const T& tr /// Basic selection of proton candidates forLc and ThetaC decays /// \param track is a track /// \return true if track passes all cuts -template -inline bool HfFilterHelper::isSelectedProtonFromLcReso(const T& track) +template +inline bool HfFilterHelper::isSelectedProtonFromLcResoOrThetaC(const T& track) { // pt selections float pt = track.pt(); - if (pt < mPtMinLcResonanceBachelor || pt > mPtMaxLcResonanceBachelor) { - return false; + if constexpr (is4ThetaC) { + if (pt < mPtMinThetaCBachelor || pt > mPtMaxThetaCBachelor) { + return false; + } + } else { + if (pt < mPtMinLcResonanceBachelor || pt > mPtMaxLcResonanceBachelor) { + return false; + } } - /// PID selection - return isSelectedProton4CharmOrBeautyBaryons(track); - return true; } diff --git a/EventFiltering/PWGLF/nucleiFilter.cxx b/EventFiltering/PWGLF/nucleiFilter.cxx index de8a35a4993..1db68711b36 100644 --- a/EventFiltering/PWGLF/nucleiFilter.cxx +++ b/EventFiltering/PWGLF/nucleiFilter.cxx @@ -448,8 +448,8 @@ struct nucleiFilter { } for (const auto& v0 : v0s) { - const auto& posTrack = tracks.rawIteratorAt(v0.posTrackId()); - const auto& negTrack = tracks.rawIteratorAt(v0.negTrackId()); + const auto& posTrack = v0.posTrack_as(); + const auto& negTrack = v0.negTrack_as(); if ((posTrack.itsNCls() < cfgCutNclusITS || posTrack.tpcNClsFound() < cfgCutNclusTPC) && (negTrack.itsNCls() < cfgCutNclusITS || negTrack.tpcNClsFound() < cfgCutNclusTPC)) { continue; diff --git a/EventFiltering/PWGLF/strangenessFilter.cxx b/EventFiltering/PWGLF/strangenessFilter.cxx index ef311a4a221..952436eebcd 100644 --- a/EventFiltering/PWGLF/strangenessFilter.cxx +++ b/EventFiltering/PWGLF/strangenessFilter.cxx @@ -15,6 +15,7 @@ /// \since June 1, 2021 #include +#include "TVector3.h" #include "CCDB/BasicCCDBManager.h" #include "DataFormatsParameters/GRPMagField.h" #include "DataFormatsParameters/GRPObject.h" @@ -25,6 +26,7 @@ #include "Framework/AnalysisDataModel.h" #include "Framework/ASoAHelpers.h" #include "ReconstructionDataFormats/Track.h" +#include "ReconstructionDataFormats/TrackParametrization.h" #include "Common/Core/RecoDecay.h" #include "Common/Core/trackUtilities.h" #include "PWGLF/DataModel/LFStrangenessTables.h" @@ -73,10 +75,38 @@ struct strangenessFilter { HistogramRegistry QAHistosTriggerParticles{"QAHistosTriggerParticles", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; HistogramRegistry QAHistosStrangenessTracking{"QAHistosStrangenessTracking", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; HistogramRegistry EventsvsMultiplicity{"EventsvsMultiplicity", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; - OutputObj hProcessedEvents{TH1D("hProcessedEvents", "Strangeness - event filtered;; Number of events", 16, -1., 15.)}; + OutputObj hProcessedEvents{TH1D("hProcessedEvents", "Strangeness - event filtered;; Number of events", 17, -1., 16.)}; OutputObj hCandidate{TH1F("hCandidate", "; Candidate pass selection; Number of events", 30, 0., 30.)}; OutputObj hEvtvshMinPt{TH1F("hEvtvshMinPt", " Number of h-Omega events with pT_h higher than thrd; min p_{T, trigg} (GeV/c); Number of events", 11, 0., 11.)}; + // Dedicated selection criteria for lambda-lambda + struct : ConfigurableGroup { + Configurable cfgv0radiusMin{"cfgv0radiusMin", 1.2, "minimum decay radius"}; + Configurable cfgDCAPosToPVMin{"cfgDCAPosToPVMin", 0.05, "minimum DCA to PV for positive track"}; + Configurable cfgDCANegToPVMin{"cfgDCANegToPVMin", 0.2, "minimum DCA to PV for negative track"}; + Configurable cfgv0CosPA{"cfgv0CosPA", 0.995, "minimum v0 cosine"}; + Configurable cfgDCAV0Dau{"cfgDCAV0Dau", 1.0, "maximum DCA between daughters"}; + Configurable cfgV0PtMin{"cfgV0PtMin", 0, "minimum pT for lambda"}; + Configurable cfgV0RapMin{"cfgV0RapMin", -0.5, "maximum rapidity"}; + Configurable cfgV0RapMax{"cfgV0RapMax", 0.5, "maximum rapidity"}; + Configurable cfgV0LifeTime{"cfgV0LifeTime", 30., "maximum lambda lifetime"}; + Configurable cfgDaughTPCnclsMin{"cfgDaughTPCnclsMin", 70, "minimum fired crossed rows"}; + Configurable cfgITSNclus{"cfgITSNclus", 1, "minimum its cluster"}; + Configurable cfgRCrossedFindable{"cfgRCrossedFindable", 0.0, "minimum ratio of crossed rows over findable clusters"}; + Configurable cfgDaughPIDCutsTPCPr{"cfgDaughPIDCutsTPCPr", 5, "proton nsigma for TPC"}; + Configurable cfgDaughPIDCutsTPCPi{"cfgDaughPIDCutsTPCPi", 5, "pion nsigma for TPC"}; + Configurable cfgDaughEtaMin{"cfgDaughEtaMin", -0.8, "minimum daughter eta"}; + Configurable cfgDaughEtaMax{"cfgDaughEtaMax", 0.8, "maximum daughter eta"}; + Configurable cfgDaughPrPt{"cfgDaughPrPt", 0.5, "minimum daughter proton pt"}; + Configurable cfgDaughPiPt{"cfgDaughPiPt", 0.5, "minimum daughter pion pt"}; + Configurable cfgLambdaMassWindow{"cfgLambdaMassWindow", 0.01, "window for lambda mass selection"}; + Configurable cfgCompV0Rej{"cfgCompV0Rej", 0.01, "competing V0 rejection"}; + Configurable cfgMinCPAV0V0{"cfgMinCPAV0V0", 0.8, "minimum CPA of v0v0"}; + Configurable cfgMaxRadiusV0V0{"cfgMaxRadiusV0V0", 10.0, "maximum radius of v0v0"}; + Configurable cfgMaxDistanceV0V0{"cfgMaxDistanceV0V0", 5.0, "maximum distance of v0v0"}; + Configurable cfgMaxDCAV0V0{"cfgMaxDCAV0V0", 5.0, "maximum DCA of v0v0"}; + } cfgLLCuts; + // Selection criteria for cascades Configurable useCascadeMomentumAtPrimVtx{"useCascadeMomentumAtPrimVtx", false, "use cascade momentum at PV"}; Configurable doextraQA{"doextraQA", 1, "do extra QA"}; @@ -178,6 +208,81 @@ struct strangenessFilter { return track.pt() > hMinPt && std::abs(track.eta()) < hEta && track.tpcNClsCrossedRows() >= tpcmincrossedrows && track.tpcCrossedRowsOverFindableCls() >= 0.8f && track.tpcChi2NCl() <= 4.f && track.itsChi2NCl() <= 36.f && (track.itsClusterMap() & 0x7) != 0; } + float getV0V0DCA(TVector3 v01pos, TVector3 v01mom, TVector3 v02pos, TVector3 v02mom) + { + TVector3 posdiff = v02pos - v01pos; + TVector3 cross = v01mom.Cross(v02mom); + TVector3 dcaVec = (posdiff.Dot(cross) / cross.Mag2()) * cross; + return dcaVec.Mag(); + } + float getV0V0CPA(TVector3 v01mom, TVector3 v02mom) + { + return v01mom.Dot(v02mom) / (v01mom.Mag() * v02mom.Mag()); + } + float getV0V0Distance(TVector3 v01pos, TVector3 v02pos) + { + TVector3 posdiff = v02pos - v01pos; + return posdiff.Mag(); + } + float getV0V0Radius(TVector3 v01pos, TVector3 v01mom, TVector3 v02pos, TVector3 v02mom) + { + TVector3 posdiff = v02pos - v01pos; + v01mom *= 1. / v01mom.Mag(); + v02mom *= 1. / v02mom.Mag(); + float dd = 1. - TMath::Power(v01mom.Dot(v02mom), 2); + if (dd < 1e-5) + return 999; + float tt = posdiff.Dot(v01mom - v01mom.Dot(v02mom) * v02mom) / dd; + float ss = -posdiff.Dot(v02mom - v01mom.Dot(v02mom) * v01mom) / dd; + TVector3 radVec = v01pos + v02pos + tt * v01mom + ss * v02mom; + radVec *= 0.5; + return radVec.Mag(); + } + bool isSelectedV0V0(TVector3 v01pos, TVector3 v01mom, TVector3 v02pos, TVector3 v02mom) + { + if (getV0V0DCA(v01pos, v01mom, v02pos, v02mom) > cfgLLCuts.cfgMaxDCAV0V0) + return false; + if (getV0V0CPA(v01mom, v02mom) < cfgLLCuts.cfgMinCPAV0V0) + return false; + if (getV0V0Distance(v01pos, v02pos) > cfgLLCuts.cfgMaxDistanceV0V0) + return false; + if (getV0V0Radius(v01pos, v01mom, v02pos, v02mom) > cfgLLCuts.cfgMaxRadiusV0V0) + return false; + + return true; + } + + template + bool isSelectedV0Daughter(T const& track) + { + if (track.tpcNClsCrossedRows() < cfgLLCuts.cfgDaughTPCnclsMin) + return false; + if (track.tpcCrossedRowsOverFindableCls() < cfgLLCuts.cfgRCrossedFindable) + return false; + if (track.itsNCls() < cfgLLCuts.cfgITSNclus) + return false; + if (track.eta() > cfgLLCuts.cfgDaughEtaMax) + return false; + if (track.eta() < cfgLLCuts.cfgDaughEtaMin) + return false; + + return true; + } + template + bool isSelectedV0DaughterPID(T const& track, int pid) // pid 0: proton, pid 1: pion + { + if (pid == 0 && std::abs(track.tpcNSigmaPr()) > cfgLLCuts.cfgDaughPIDCutsTPCPr) + return false; + if (pid == 1 && std::abs(track.tpcNSigmaPi()) > cfgLLCuts.cfgDaughPIDCutsTPCPi) + return false; + if (pid == 0 && track.pt() < cfgLLCuts.cfgDaughPrPt) + return false; + if (pid == 1 && track.pt() < cfgLLCuts.cfgDaughPiPt) + return false; + + return true; + } + void init(o2::framework::InitContext&) { // set V0 parameters in the helper @@ -223,6 +328,7 @@ struct strangenessFilter { hProcessedEvents->GetXaxis()->SetBinLabel(14, aod::filtering::OmegaHighMult::columnLabel()); hProcessedEvents->GetXaxis()->SetBinLabel(15, aod::filtering::DoubleOmega::columnLabel()); hProcessedEvents->GetXaxis()->SetBinLabel(16, aod::filtering::OmegaXi::columnLabel()); + hProcessedEvents->GetXaxis()->SetBinLabel(17, "LL"); hCandidate->GetXaxis()->SetBinLabel(1, "All"); hCandidate->GetXaxis()->SetBinLabel(2, "PassBuilderSel"); @@ -449,14 +555,14 @@ struct strangenessFilter { void fillTriggerTable(bool keepEvent[]) { - strgtable(keepEvent[0], keepEvent[1], keepEvent[2], keepEvent[3], keepEvent[4], keepEvent[5], keepEvent[6], keepEvent[7], keepEvent[8], keepEvent[9], keepEvent[10], keepEvent[11]); + strgtable(keepEvent[0], keepEvent[1], keepEvent[2], keepEvent[3], keepEvent[4], keepEvent[5], keepEvent[6], keepEvent[7], keepEvent[8], keepEvent[9], keepEvent[10], keepEvent[11], keepEvent[12]); } - void process(CollisionCandidates const& collision, TrackCandidates const& tracks, aod::Cascades const& cascadesBase, aod::AssignedTrackedCascades const& trackedCascades, aod::AssignedTrackedV0s const& /*trackedV0s*/, aod::AssignedTracked3Bodys const& /*tracked3Bodys*/, aod::V0s const&, aod::BCs const&, aod::FT0s const& /*ft0s*/) + void process(CollisionCandidates const& collision, TrackCandidates const& tracks, aod::Cascades const& cascadesBase, aod::AssignedTrackedCascades const& trackedCascades, aod::AssignedTrackedV0s const& /*trackedV0s*/, aod::AssignedTracked3Bodys const& /*tracked3Bodys*/, aod::V0s const& v0Base, aod::BCs const&, aod::FT0s const& /*ft0s*/) { // Is event good? [0] = Omega, [1] = high-pT hadron + Omega, [2] = 2Xi, [3] = 3Xi, [4] = 4Xi, [5] single-Xi, [6] Omega with high radius // [7] tracked Xi, [8] tracked Omega, [9] Omega + high mult event - bool keepEvent[12]{}; // explicitly zero-initialised + bool keepEvent[13]{}; // explicitly zero-initialised std::vector> v0sFromOmegaID; std::vector> v0sFromXiID; @@ -573,6 +679,102 @@ struct strangenessFilter { const auto primaryVertex = getPrimaryVertex(collision); o2::dataformats::DCA impactParameterTrk; + std::vector> v0sSelTuple; + for (auto& v00 : v0Base) { // loop over v0 for pre selection + hCandidate->Fill(0.5); // All candidates + + if (v00.v0Type() != 1) { + continue; + } + + const auto posTrack0 = v00.posTrack_as(); + const auto negTrack0 = v00.negTrack_as(); + + if (!isSelectedV0Daughter(posTrack0) || !isSelectedV0Daughter(negTrack0)) { + continue; + } + + auto trackParPos0 = getTrackParCov(posTrack0); + auto trackParNeg0 = getTrackParCov(negTrack0); + + if (!mStraHelper.buildV0Candidate(v00.collisionId(), pvPos[0], pvPos[1], pvPos[2], posTrack0, negTrack0, trackParPos0, trackParNeg0)) { + continue; + } + + if (std::hypot(mStraHelper.v0.position[0], mStraHelper.v0.position[1]) < cfgLLCuts.cfgv0radiusMin) { + continue; + } + if (std::fabs(mStraHelper.v0.positiveDCAxy) < cfgLLCuts.cfgDCAPosToPVMin) { + continue; + } + if (std::fabs(mStraHelper.v0.negativeDCAxy) < cfgLLCuts.cfgDCANegToPVMin) { + continue; + } + if (TMath::Cos(mStraHelper.v0.pointingAngle) < cfgLLCuts.cfgv0CosPA) { + continue; + } + if (std::fabs(mStraHelper.v0.daughterDCA) > cfgLLCuts.cfgDCAV0Dau) { + continue; + } + if (std::hypot(mStraHelper.v0.momentum[0], mStraHelper.v0.momentum[1]) < cfgLLCuts.cfgV0PtMin) { + continue; + } + double yLambda = RecoDecay::y(array{mStraHelper.v0.momentum[0], mStraHelper.v0.momentum[1], mStraHelper.v0.momentum[2]}, o2::constants::physics::MassLambda0); + if (yLambda < cfgLLCuts.cfgV0RapMin) { + continue; + } + if (yLambda > cfgLLCuts.cfgV0RapMax) { + continue; + } + double distovertotmom = std::hypot(mStraHelper.v0.position[0] - collision.posX(), mStraHelper.v0.position[1] - collision.posY(), mStraHelper.v0.position[2] - collision.posZ()) / (std::hypot(mStraHelper.v0.momentum[0], mStraHelper.v0.momentum[1], mStraHelper.v0.momentum[2]) + 1e-13); + if (distovertotmom * o2::constants::physics::MassLambda0 > cfgLLCuts.cfgV0LifeTime) { + continue; + } + + int Tag = 0; + if (isSelectedV0DaughterPID(posTrack0, 0) && isSelectedV0DaughterPID(negTrack0, 1)) { + if (cfgLLCuts.cfgLambdaMassWindow > std::fabs(mStraHelper.v0.massLambda - o2::constants::physics::MassLambda0)) { + if (cfgLLCuts.cfgCompV0Rej < std::fabs(mStraHelper.v0.massK0Short - o2::constants::physics::MassLambda0)) { + Tag++; + } + } + } // lambda + if (isSelectedV0DaughterPID(posTrack0, 1) && isSelectedV0DaughterPID(negTrack0, 0)) { + if (cfgLLCuts.cfgLambdaMassWindow > std::fabs(mStraHelper.v0.massAntiLambda - o2::constants::physics::MassLambda0)) { + if (cfgLLCuts.cfgCompV0Rej < std::fabs(mStraHelper.v0.massK0Short - o2::constants::physics::MassLambda0)) { + Tag++; + } + } + } // anti lambda + if (Tag != 1) { // Select when only one hypothesis is satisfied + continue; + } + + TVector3 v0pos(mStraHelper.v0.position[0], mStraHelper.v0.position[1], mStraHelper.v0.position[2]); + TVector3 v0mom(mStraHelper.v0.momentum[0], mStraHelper.v0.momentum[1], mStraHelper.v0.momentum[2]); + + v0sSelTuple.emplace_back(posTrack0.globalIndex(), negTrack0.globalIndex(), v0pos, v0mom); + } + + for (size_t i = 0; i < v0sSelTuple.size(); ++i) { + for (size_t j = i + 1; j < v0sSelTuple.size(); ++j) { + auto d00 = std::get<0>(v0sSelTuple[i]); + auto d01 = std::get<1>(v0sSelTuple[i]); + auto d10 = std::get<0>(v0sSelTuple[j]); + auto d11 = std::get<1>(v0sSelTuple[j]); + if (d00 == d10 || d00 == d11 || d01 == d10 || d01 == d11) { + continue; + } + auto v00pos = std::get<2>(v0sSelTuple[i]); + auto v00mom = std::get<3>(v0sSelTuple[i]); + auto v01pos = std::get<2>(v0sSelTuple[j]); + auto v01mom = std::get<3>(v0sSelTuple[j]); + if (isSelectedV0V0(v00pos, v00mom, v01pos, v01mom)) { + keepEvent[12] = true; + } + } + } + for (auto& casc : cascadesBase) { // loop over cascades hCandidate->Fill(0.5); // All candidates @@ -1149,7 +1351,9 @@ struct strangenessFilter { if (keepEvent[11]) { hProcessedEvents->Fill(14.5); } - + if (keepEvent[12]) { + hProcessedEvents->Fill(15.5); + } // Filling the table fillTriggerTable(keepEvent); } diff --git a/EventFiltering/filterTables.h b/EventFiltering/filterTables.h index 7ec3b46ccaa..363a7176165 100644 --- a/EventFiltering/filterTables.h +++ b/EventFiltering/filterTables.h @@ -102,15 +102,28 @@ DECLARE_SOA_COLUMN(HfBtoJPsiPrKa, hasHfBtoJPsiPrKa, bool); DECLARE_SOA_COLUMN(HfBtoJPsiPi, hasHfBtoJPsiPi, bool); //! Bc -> JPsi(->mumu)pi+ // CF two body triggers -DECLARE_SOA_COLUMN(PD, hasPD, bool); //! has d-p pair -DECLARE_SOA_COLUMN(LD, hasLD, bool); //! has l-d pair +DECLARE_SOA_COLUMN(PD_TightKstar, hasPD_TightKstar, bool); //! has d-p pair with tight kstar limit +DECLARE_SOA_COLUMN(PD_LooseKstar, hasPD_LooseKstar, bool); //! has d-p pair with loose kstar limit +DECLARE_SOA_COLUMN(LD_TightKstar, hasLD_TightKstar, bool); //! has l-d pair with tight kstar limit +DECLARE_SOA_COLUMN(LD_LooseKstar, hasLD_LooseKstar, bool); //! has l-d pair with loose kstar limit +DECLARE_SOA_COLUMN(PHID_TightKstar, hasPHID_TightKstar, bool); //! has phi-d pair with tight kstar limit +DECLARE_SOA_COLUMN(PHID_LooseKstar, hasPHID_LooseKstar, bool); //! has phi-d pair with loose kstar limit +DECLARE_SOA_COLUMN(RHOD_TightKstar, hasRHOD_TightKstar, bool); //! has rho-d pair with tight kstar limit +DECLARE_SOA_COLUMN(RHOD_LooseKstar, hasRHOD_LooseKstar, bool); //! has rho-d pair with loose kstar limit // CF three body triggers -DECLARE_SOA_COLUMN(PPP, hasPPP, bool); //! has p-p-p triplet -DECLARE_SOA_COLUMN(PPL, hasPPL, bool); //! has p-p-L triplet -DECLARE_SOA_COLUMN(PLL, hasPLL, bool); //! has p-L-L triplet -DECLARE_SOA_COLUMN(LLL, hasLLL, bool); //! has L-L-L tripletD -DECLARE_SOA_COLUMN(PPPHI, hasPPPHI, bool); //! has P-P-PHI triplet +DECLARE_SOA_COLUMN(PPP_TightQ3, hasPPP_TightQ3, bool); //! has p-p-p triplet with tight Q3 limit +DECLARE_SOA_COLUMN(PPP_LooseQ3, hasPPP_LooseQ3, bool); //! has p-p-p triplet with loose Q3 limit +DECLARE_SOA_COLUMN(PPL_TightQ3, hasPPL_TightQ3, bool); //! has p-p-L triplet with tight Q3 limit +DECLARE_SOA_COLUMN(PPL_LooseQ3, hasPPL_LooseQ3, bool); //! has p-p-L triplet with loose Q3 limit +DECLARE_SOA_COLUMN(PLL_TightQ3, hasPLL_TightQ3, bool); //! has p-L-L triplet with tight Q3 limit +DECLARE_SOA_COLUMN(PLL_LooseQ3, hasPLL_LooseQ3, bool); //! has p-L-L triplet with loose Q3 limit +DECLARE_SOA_COLUMN(LLL_TightQ3, hasLLL_TightQ3, bool); //! has L-L-L tripletD with tight Q3 limit +DECLARE_SOA_COLUMN(LLL_LooseQ3, hasLLL_LooseQ3, bool); //! has L-L-L tripletD with loose Q3 limit +DECLARE_SOA_COLUMN(PPPHI_TightQ3, hasPPPHI_TightQ3, bool); //! has P-P-PHI triplet with tight Q3 limit +DECLARE_SOA_COLUMN(PPPHI_LooseQ3, hasPPPHI_LooseQ3, bool); //! has P-P-PHI triplet with loose Q3 limit +DECLARE_SOA_COLUMN(PPRHO_TightQ3, hasPPRHO_TightQ3, bool); //! has P-P-RHO triplet with tight Q3 limit +DECLARE_SOA_COLUMN(PPRHO_LooseQ3, hasPPRHO_highQ3, bool); //! has P-P-RHO triplet with loose Q3 limit // jets DECLARE_SOA_COLUMN(JetChLowPt, hasJetChLowPt, bool); //! low-pT charged jet @@ -154,6 +167,7 @@ DECLARE_SOA_COLUMN(TrackedXi, hasTrackedXi, bool); //! at least 1 DECLARE_SOA_COLUMN(TrackedOmega, hasTrackedOmega, bool); //! at least 1 tracked Omega DECLARE_SOA_COLUMN(Tracked3Body, hasTracked3Body, bool); //! at least 1 tracked 3Body DECLARE_SOA_COLUMN(OmegaHighMult, hasOmegaHighMult, bool); //! at least 1 Omega + high-mult event +DECLARE_SOA_COLUMN(LambdaLambda, lambdaLambda, bool); //! at least 2 lambda satisfying selection // F1-proton DECLARE_SOA_COLUMN(TriggerEventF1Proton, triggereventf1proton, bool); //! F1 - proton femto trigger event @@ -186,10 +200,10 @@ DECLARE_SOA_COLUMN(PCMOmegaMeson, hasPCMOmegaMeson, bool); //! Omega meson DECLARE_SOA_COLUMN(EMCOmegaMeson, hasEMCOmegaMeson, bool); //! Omega meson candidate (3pi) in the collision DECLARE_SOA_COLUMN(PCMEtaPrimeMeson, hasPCMEtaPrimeMeson, bool); //! Eta' meson candidate (3pi) in the collision DECLARE_SOA_COLUMN(EMCEtaPrimeMeson, hasEMCEtaPrimeMeson, bool); //! Eta' meson candidate (3pi) in the collision -DECLARE_SOA_COLUMN(PPOmega, hasPPOmega, bool); //! PPomega meson candidate (3pi) in the collision -DECLARE_SOA_COLUMN(PPEtaPrime, hasPPEtaPrime, bool); //! PPEta' meson candidate (3pi) in the collision -DECLARE_SOA_COLUMN(Omegad, hasOmegad, bool); //! Omegad' meson candidate (3pi) in the collision -DECLARE_SOA_COLUMN(EtaPrimed, hasEtaPrimed, bool); //! Eta'd meson candidate (3pi) in the collision +DECLARE_SOA_COLUMN(POmega, hasPPOmega, bool); //! Pomega meson candidate (3pi) in the collision +DECLARE_SOA_COLUMN(PEtaPrime, hasPEtaPrime, bool); //! PPEta' meson candidate (3pi) in the collision +DECLARE_SOA_COLUMN(OmegadOrPP, hasOmegadOrPP, bool); //! Omegad' meson candidate (3pi) in the collision +DECLARE_SOA_COLUMN(EtaPrimedOrPP, hasEtaPrimedOrPP, bool); //! Eta'd meson candidate (3pi) in the collision } // namespace filtering @@ -268,7 +282,17 @@ DECLARE_SOA_TABLE(HfFilters, "AOD", "HfFilters", //! using HfFilter = HfFilters::iterator; DECLARE_SOA_TABLE(CFFilters, "AOD", "CFFilters", //! - filtering::PPP, filtering::PPL, filtering::PLL, filtering::LLL, filtering::PPPHI, filtering::PD, filtering::LD); + filtering::PPP_TightQ3, filtering::PPP_LooseQ3, + filtering::PPL_TightQ3, filtering::PPL_LooseQ3, + filtering::PLL_TightQ3, filtering::PLL_LooseQ3, + filtering::LLL_TightQ3, filtering::LLL_LooseQ3, + filtering::PPPHI_TightQ3, filtering::PPPHI_LooseQ3, + filtering::PPRHO_TightQ3, filtering::PPRHO_LooseQ3, + filtering::PD_TightKstar, filtering::PD_LooseKstar, + filtering::LD_TightKstar, filtering::LD_LooseKstar, + filtering::PHID_TightKstar, filtering::PHID_LooseKstar, + filtering::RHOD_TightKstar, filtering::RHOD_LooseKstar); + using CfFilter = CFFilters::iterator; // jets @@ -295,7 +319,7 @@ using FullJetFilter = FullJetFilters::iterator; // strangeness (lf) DECLARE_SOA_TABLE(StrangenessFilters, "AOD", "LFStrgFilters", //! - filtering::Omega, filtering::hadronOmega, filtering::DoubleXi, filtering::TripleXi, filtering::QuadrupleXi, filtering::SingleXiYN, filtering::OmegaLargeRadius, filtering::TrackedXi, filtering::TrackedOmega, filtering::OmegaHighMult, filtering::DoubleOmega, filtering::OmegaXi); + filtering::Omega, filtering::hadronOmega, filtering::DoubleXi, filtering::TripleXi, filtering::QuadrupleXi, filtering::SingleXiYN, filtering::OmegaLargeRadius, filtering::TrackedXi, filtering::TrackedOmega, filtering::OmegaHighMult, filtering::DoubleOmega, filtering::OmegaXi, filtering::LambdaLambda); using StrangenessFilter = StrangenessFilters::iterator; @@ -325,8 +349,8 @@ using PhotonFilter = PhotonFilters::iterator; DECLARE_SOA_TABLE(HeavyNeutralMesonFilters, "AOD", "HeavyNeutralMesonFilters", //! filtering::PCMOmegaMeson, filtering::EMCOmegaMeson, filtering::PCMEtaPrimeMeson, filtering::EMCEtaPrimeMeson, - filtering::PPOmega, filtering::PPEtaPrime, - filtering::Omegad, filtering::EtaPrimed); + filtering::POmega, filtering::PEtaPrime, + filtering::OmegadOrPP, filtering::EtaPrimedOrPP); using HeavyNeutralMesonFilter = HeavyNeutralMesonFilters::iterator; diff --git a/PWGCF/Flow/Tasks/flowPbpbPikp.cxx b/PWGCF/Flow/Tasks/flowPbpbPikp.cxx index 311cccc5b84..f880deaf75b 100644 --- a/PWGCF/Flow/Tasks/flowPbpbPikp.cxx +++ b/PWGCF/Flow/Tasks/flowPbpbPikp.cxx @@ -52,6 +52,7 @@ #include #include +#include using namespace o2; using namespace o2::framework; @@ -88,6 +89,10 @@ struct FlowPbpbPikp { O2_DEFINE_CONFIGURABLE(cfgCutOccupancy, int, 3000, "Occupancy cut") O2_DEFINE_CONFIGURABLE(cfgUseGlobalTrack, bool, true, "use Global track") O2_DEFINE_CONFIGURABLE(cfgITScluster, int, 0, "Number of ITS cluster") + O2_DEFINE_CONFIGURABLE(cfgTrackDensityCorrUse, bool, true, "Use track density efficiency correction") + + Configurable> cfgTrackDensityP0{"cfgTrackDensityP0", std::vector{0.7217476707, 0.7384792571, 0.7542625668, 0.7640680200, 0.7701951667, 0.7755299053, 0.7805901710, 0.7849446786, 0.7957356586, 0.8113039262, 0.8211968966, 0.8280558878, 0.8329342135}, "parameter 0 for track density efficiency correction"}; + Configurable> cfgTrackDensityP1{"cfgTrackDensityP1", std::vector{-2.169488e-05, -2.191913e-05, -2.295484e-05, -2.556538e-05, -2.754463e-05, -2.816832e-05, -2.846502e-05, -2.843857e-05, -2.705974e-05, -2.477018e-05, -2.321730e-05, -2.203315e-05, -2.109474e-05}, "parameter 1 for track density efficiency correction"}; ConfigurableAxis axisVertex{"axisVertex", {20, -10, 10}, "vertex axis for histograms"}; ConfigurableAxis axisPhi{"axisPhi", {60, 0.0, constants::math::TwoPI}, "phi axis for histograms"}; @@ -127,6 +132,13 @@ struct FlowPbpbPikp { std::vector mAcceptance; bool correctionsLoaded = false; + // local track density correction + std::vector funcEff; + TH1D* hFindPtBin; + TF1* funcV2; + TF1* funcV3; + TF1* funcV4; + void init(InitContext const&) { ccdb->setURL(ccdbUrl.value); @@ -199,6 +211,10 @@ struct FlowPbpbPikp { for (int i = 0; i < fPtAxis->GetNbins(); i++) oba->Add(new TNamed(Form("Pr08Gap24_pt_%i", i + 1), "Pr08Gap24_pTDiff")); + oba->Add(new TNamed("Pi08BGap22", "Pi08BGap22")); + for (int i = 0; i < fPtAxis->GetNbins(); i++) + oba->Add(new TNamed(Form("Pi08BGap22_pt_%i", i + 1), "Pi08BGap22_pTDiff")); + fFC->SetName("FlowContainer"); fFC->SetXAxis(fPtAxis); fFC->Initialize(oba, axisMultiplicity, cfgNbootstrap); @@ -219,6 +235,9 @@ struct FlowPbpbPikp { fGFW->AddRegion("poiNpi", -0.8, -0.4, 1 + fPtAxis->GetNbins(), 2); fGFW->AddRegion("olNpi", -0.8, -0.4, 1 + fPtAxis->GetNbins(), 16); + fGFW->AddRegion("poiPpi", 0.4, 0.8, 1 + fPtAxis->GetNbins(), 2); + fGFW->AddRegion("olPpi", 0.4, 0.8, 1 + fPtAxis->GetNbins(), 16); + // kaon fGFW->AddRegion("poiNk", -0.8, -0.4, 1 + fPtAxis->GetNbins(), 4); fGFW->AddRegion("olNk", -0.8, -0.4, 1 + fPtAxis->GetNbins(), 32); @@ -251,7 +270,30 @@ struct FlowPbpbPikp { corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNk refN08 | olNk {2 2} refP08 {-2 -2}", "Ka08Gap24", kTRUE)); corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNpr refN08 | olNpr {2 2} refP08 {-2 -2}", "Pr08Gap24", kTRUE)); + // Backward correlations + corrconfigs.push_back(fGFW->GetCorrelatorConfig("refN08 {2} refP08 {-2}", "Pi08BGap22", kFALSE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPpi refP08 | olPpi {2} refN08 {-2}", "Pi08BGap22", kTRUE)); + fGFW->CreateRegions(); + + if (cfgTrackDensityCorrUse) { + std::vector pTEffBins = {0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.4, 1.8, 2.2, 2.6, 3.0}; + hFindPtBin = new TH1D("hFindPtBin", "hFindPtBin", pTEffBins.size() - 1, &pTEffBins[0]); + funcEff.resize(pTEffBins.size() - 1); + // LHC24g3 Eff + std::vector f1p0 = cfgTrackDensityP0; + std::vector f1p1 = cfgTrackDensityP1; + for (uint ifunc = 0; ifunc < pTEffBins.size() - 1; ifunc++) { + funcEff[ifunc] = new TF1(Form("funcEff%i", ifunc), "[0]+[1]*x", 0, 3000); + funcEff[ifunc]->SetParameters(f1p0[ifunc], f1p1[ifunc]); + } + funcV2 = new TF1("funcV2", "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x", 0, 100); + funcV2->SetParameters(0.0186111, 0.00351907, -4.38264e-05, 1.35383e-07, -3.96266e-10); + funcV3 = new TF1("funcV3", "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x", 0, 100); + funcV3->SetParameters(0.0174056, 0.000703329, -1.45044e-05, 1.91991e-07, -1.62137e-09); + funcV4 = new TF1("funcV4", "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x", 0, 100); + funcV4->SetParameters(0.008845, 0.000259668, -3.24435e-06, 4.54837e-08, -6.01825e-10); + } } enum Particles { @@ -286,8 +328,9 @@ struct FlowPbpbPikp { if (track.pt() >= cfgTofPtCut && !track.hasTOF()) return -1; + const int numSpecies = 3; // Select particle with the lowest nsigma - for (int i = 0; i < 3; ++i) { + for (int i = 0; i < numSpecies; ++i) { if (std::abs(nSigmaToUse[i]) < nsigma) { pid = i; nsigma = std::abs(nSigmaToUse[i]); @@ -303,8 +346,10 @@ struct FlowPbpbPikp { int bayesid = -1; int prob = 0; - for (int i = 0; i < 3; ++i) { - if (bayesprobs[i] > prob && bayesprobs[i] > 80) { + const int nParts = 3; + const int bayesCut = 80; + for (int i = 0; i < nParts; ++i) { + if (bayesprobs[i] > prob && bayesprobs[i] > bayesCut) { bayesid = i; prob = bayesprobs[i]; } @@ -317,12 +362,13 @@ struct FlowPbpbPikp { { int maxProb[3] = {80, 80, 80}; int pidID = -1; + const int nParts = 3; std::pair idprob = getBayesID(track); if (idprob.first == PIONS || idprob.first == KAONS || idprob.first == PROTONS) { // 0 = pion, 1 = kaon, 2 = proton pidID = idprob.first; float nsigmaTPC[3] = {track.tpcNSigmaPi(), track.tpcNSigmaKa(), track.tpcNSigmaPr()}; if (idprob.second > maxProb[pidID]) { - if (std::fabs(nsigmaTPC[pidID]) > 3) + if (std::fabs(nsigmaTPC[pidID]) > nParts) return 0; return pidID + 1; // shift the pid by 1, 1 = pion, 2 = kaon, 3 = proton } else { @@ -523,6 +569,37 @@ struct FlowPbpbPikp { int pidIndex; loadCorrections(bc); // load corrections for the each event + // Track loop for calculating the Qn angles + double psi2Est = 0, psi3Est = 0, psi4Est = 0; + float wEPeff = 1; + double v2 = 0, v3 = 0, v4 = 0; + // be cautious, this only works for Pb-Pb + // esimate the Qn angles and vn for this event + if (cfgTrackDensityCorrUse) { + double q2x = 0, q2y = 0; + double q3x = 0, q3y = 0; + double q4x = 0, q4y = 0; + for (const auto& track : tracks) { + bool withinPtRef = (cfgCutPtMin < track.pt()) && (track.pt() < cfgCutPtMax); // within RF pT range + if (withinPtRef) { + q2x += std::cos(2 * track.phi()); + q2y += std::sin(2 * track.phi()); + q3x += std::cos(3 * track.phi()); + q3y += std::sin(3 * track.phi()); + q4x += std::cos(4 * track.phi()); + q4y += std::sin(4 * track.phi()); + } + } + psi2Est = std::atan2(q2y, q2x) / 2.; + psi3Est = std::atan2(q3y, q3x) / 3.; + psi4Est = std::atan2(q4y, q4x) / 4.; + + v2 = funcV2->Eval(cent); + v3 = funcV3->Eval(cent); + v4 = funcV4->Eval(cent); + } + + // Actual track loop for (auto const& track : tracks) { if (!selectionTrack(track)) continue; @@ -540,6 +617,9 @@ struct FlowPbpbPikp { // pidIndex = getBayesPIDIndex(track); pidIndex = getNsigmaPID(track); + + weff = 1; // Initializing weff for each track + // NUA weights if (cfgOutputNUAWeights) fillWeights(track, vtxz, pidIndex, runNumber); @@ -550,10 +630,24 @@ struct FlowPbpbPikp { if (withinPtRef && withinPtPOI && pidIndex) waccRef = waccPOI; // if particle is both (then it's overlap), override ref with POI + // Track density correction + if (cfgTrackDensityCorrUse && withinPtRef) { + double fphi = v2 * std::cos(2 * (track.phi() - psi2Est)) + v3 * std::cos(3 * (track.phi() - psi3Est)) + v4 * std::cos(4 * (track.phi() - psi4Est)); + fphi = (1 + 2 * fphi); + int pTBinForEff = hFindPtBin->FindBin(track.pt()); + if (pTBinForEff >= 1 && pTBinForEff <= hFindPtBin->GetNbinsX()) { + wEPeff = funcEff[pTBinForEff - 1]->Eval(fphi * tracks.size()); + if (wEPeff > 0.) { + wEPeff = 1. / wEPeff; + weff *= wEPeff; + } + } + } // end of track density correction loop + if (withinPtRef) { histos.fill(HIST("hPhiWeighted"), track.phi(), waccRef); fGFW->Fill(track.eta(), fPtAxis->FindBin(pt) - 1, track.phi(), waccRef * weff, 1); - fGFW->Fill(track.eta(), 1, track.phi(), waccRef * weff, 512); + fGFW->Fill(track.eta(), fPtAxis->FindBin(pt) - 1, track.phi(), waccRef * weff, 512); } if (withinPtPOI) { fGFW->Fill(track.eta(), fPtAxis->FindBin(pt) - 1, track.phi(), waccPOI * weff, 128); diff --git a/PWGCF/Flow/Tasks/resonancesGfwFlow.cxx b/PWGCF/Flow/Tasks/resonancesGfwFlow.cxx index 6bde6c05c99..8f6db97fde8 100644 --- a/PWGCF/Flow/Tasks/resonancesGfwFlow.cxx +++ b/PWGCF/Flow/Tasks/resonancesGfwFlow.cxx @@ -38,6 +38,7 @@ #include "Common/DataModel/Multiplicity.h" #include "Common/Core/TrackSelection.h" #include "Common/Core/trackUtilities.h" +#include "Common/Core/RecoDecay.h" #include "CommonConstants/PhysicsConstants.h" #include "PWGLF/DataModel/EPCalibrationTables.h" @@ -135,10 +136,19 @@ struct ResonancesGfwFlow { O2_DEFINE_CONFIGURABLE(cfgUseWeightPhiEtaPt, bool, false, "Use Phi, Eta, Pt dependent NUA weights") O2_DEFINE_CONFIGURABLE(cfgNbootstrap, int, 10, "Number of subsamples") O2_DEFINE_CONFIGURABLE(cfgUseBootStrap, bool, true, "Use bootstrap for error estimation") - O2_DEFINE_CONFIGURABLE(cfgTrackDensityCorrUse, bool, false, "Use track density efficiency correction") + O2_DEFINE_CONFIGURABLE(cfgTrackDensityCorrUse, bool, true, "Use track density efficiency correction") + O2_DEFINE_CONFIGURABLE(cfgUsePhi, bool, true, "Analyze Phi") O2_DEFINE_CONFIGURABLE(cfgUseK0, bool, true, "Analyze K0") O2_DEFINE_CONFIGURABLE(cfgUseLambda, bool, true, "Analyze Lambda") - O2_DEFINE_CONFIGURABLE(cfgUsePhi, bool, true, "Analyze Phi") + + enum OutputSpecies { + Ref = 0, + K0 = 1, + Lambda = 2, + AnLambda = 3, + Phi = 4, + kCount_OutputSpecies + }; struct : ConfigurableGroup { Configurable> cfgCosPAs{"cfgCosPAs", std::vector{0.97f, 0.995f, 0.04f}, "Minimum Pointing angle for resonances [K0, Lambda, Phi]"}; @@ -146,7 +156,7 @@ struct ResonancesGfwFlow { Configurable> cfgMassMin{"cfgMassMin", std::vector{0.44f, 1.1f, 0.99f}, "Minimum mass for resonances [K0, Lambda, Phi]"}; Configurable> cfgMassMax{"cfgMassMax", std::vector{0.56f, 1.16f, 1.06f}, "Maximum mass for resonances [K0, Lambda, Phi]"}; Configurable> cfgNMassBins{"cfgNMassBins", std::vector{70, 70, 70}, "Invariant mass bins for resonances [K0, Lambda, Phi]"}; - Configurable> cfgMccCut{"cfgMccCut", std::vector{0.005f, 0.01f}, "MCC cut for resonances [K0, Lambda]"}; + Configurable> cfgMccCut{"cfgMccCut", std::vector{0.005f, 0.01f, 0.0f}, "MCC cut for resonances [K0, Lambda, Phi]"}; Configurable> cfgPosTrackPt{"cfgPosTrackPt", std::vector{0.15f, 0.15f, 0.15f}, "Pt cut for positive track of resonances [K0, Lambda, Phi]"}; Configurable> cfgNegTrackPt{"cfgNegTrackPt", std::vector{0.15f, 0.15f, 0.15f}, "Pt cut for negative track of resonances [K0, Lambda, Phi]"}; } resoCuts; @@ -200,15 +210,6 @@ struct ResonancesGfwFlow { TAxis* fLambdaMassAxis; TRandom3* fRndm = new TRandom3(0); - enum OutputSpecies { - Ref = 0, - K0 = 1, - Lambda = 2, - AnLambda = 3, - Phi = 4, - kCount_OutputSpecies - }; - std::vector mAcceptance; bool correctionsLoaded = false; @@ -243,13 +244,40 @@ struct ResonancesGfwFlow { histos.add("hPhiPhi", "", {HistType::kTH1D, {axisPhi}}); histos.add("hPhiEta", "", {HistType::kTH1D, {axisEta}}); histos.add("hPhiMass_sparse", "", {HistType::kTHnSparseD, {{axisPhiMass, axisPt, axisMultiplicity}}}); + histos.add("hPhimassSparse_RD", "", {HistType::kTHnSparseD, {{axisPhiMass, axisPt, axisMultiplicity}}}); histos.add("Phid22Fpt", "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); histos.add("Phid24Fpt", "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); histos.add("Phid22Bpt", "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); histos.add("Phid24Bpt", "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); } + if (cfgUseK0) { + histos.add("PlusTPC_K0", "", {HistType::kTH2D, {{axisPt, axisTPCsignal}}}); + histos.add("MinusTPC_K0", "", {HistType::kTH2D, {{axisPt, axisTPCsignal}}}); + histos.add("PlusTOF_K0", "", {HistType::kTH2D, {{axisPt, axisTOFsignal}}}); + histos.add("MinusTOF_K0", "", {HistType::kTH2D, {{axisPt, axisTOFsignal}}}); + histos.add("hK0Phi", "", {HistType::kTH1D, {axisPhi}}); + histos.add("hK0Eta", "", {HistType::kTH1D, {axisEta}}); + histos.add("hK0Mass_sparse", "", {HistType::kTHnSparseF, {{axisK0Mass, axisPt, axisMultiplicity}}}); + histos.add("hK0s", "", {HistType::kTH1D, {singleCount}}); + + histos.add("K0d22Fpt", "", {HistType::kTProfile3D, {axisPt, axisK0Mass, axisMultiplicity}}); + histos.add("K0d24Fpt", "", {HistType::kTProfile3D, {axisPt, axisK0Mass, axisMultiplicity}}); + histos.add("K0d22Bpt", "", {HistType::kTProfile3D, {axisPt, axisK0Mass, axisMultiplicity}}); + histos.add("K0d24Bpt", "", {HistType::kTProfile3D, {axisPt, axisK0Mass, axisMultiplicity}}); + histos.add("hK0Count", "Number of K0;; Count", {HistType::kTH1D, {{10, 0, 10}}}); + histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(1, "K0 candidates"); + histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(2, "Daughter pt"); + histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(3, "Mass cut"); + histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(4, "Rapidity cut"); + histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(5, "DCA to PV"); + histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(6, "DCA between daughters"); + histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(7, "V0radius"); + histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(8, "CosPA"); + histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(9, "Proper lifetime"); + histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(10, "Daughter track selection"); + } if (cfgUseLambda) { histos.add("PlusTPC_L", "", {HistType::kTH2D, {{axisPt, axisTPCsignal}}}); histos.add("MinusTPC_L", "", {HistType::kTH2D, {{axisPt, axisTPCsignal}}}); @@ -277,7 +305,7 @@ struct ResonancesGfwFlow { histos.add("AnLambdad22Bpt", "", {HistType::kTProfile3D, {axisPt, axisLambdaMass, axisMultiplicity}}); histos.add("AnLambdad24Bpt", "", {HistType::kTProfile3D, {axisPt, axisLambdaMass, axisMultiplicity}}); - histos.add("hLambdaCount", "Number of Lambda;; Count", {HistType::kTH1D, {{11, 0, 11}}}); + histos.add("hLambdaCount", "Number of Lambda;; Count", {HistType::kTH1D, {{10, 0, 10}}}); histos.get(HIST("hLambdaCount"))->GetXaxis()->SetBinLabel(1, "Lambda candidates"); histos.get(HIST("hLambdaCount"))->GetXaxis()->SetBinLabel(2, "Daughter pt"); histos.get(HIST("hLambdaCount"))->GetXaxis()->SetBinLabel(3, "Mass cut"); @@ -288,36 +316,6 @@ struct ResonancesGfwFlow { histos.get(HIST("hLambdaCount"))->GetXaxis()->SetBinLabel(8, "CosPA"); histos.get(HIST("hLambdaCount"))->GetXaxis()->SetBinLabel(9, "Proper lifetime"); histos.get(HIST("hLambdaCount"))->GetXaxis()->SetBinLabel(10, "Daughter track selection"); - histos.get(HIST("hLambdaCount"))->GetXaxis()->SetBinLabel(11, "Mass cross check"); - } - - if (cfgUseK0) { - histos.add("PlusTPC_K0", "", {HistType::kTH2D, {{axisPt, axisTPCsignal}}}); - histos.add("MinusTPC_K0", "", {HistType::kTH2D, {{axisPt, axisTPCsignal}}}); - histos.add("PlusTOF_K0", "", {HistType::kTH2D, {{axisPt, axisTOFsignal}}}); - histos.add("MinusTOF_K0", "", {HistType::kTH2D, {{axisPt, axisTOFsignal}}}); - histos.add("hK0Phi", "", {HistType::kTH1D, {axisPhi}}); - histos.add("hK0Eta", "", {HistType::kTH1D, {axisEta}}); - histos.add("hK0Mass_sparse", "", {HistType::kTHnSparseF, {{axisK0Mass, axisPt, axisMultiplicity}}}); - histos.add("hK0s", "", {HistType::kTH1D, {singleCount}}); - - histos.add("K0d22Fpt", "", {HistType::kTProfile3D, {axisPt, axisK0Mass, axisMultiplicity}}); - histos.add("K0d24Fpt", "", {HistType::kTProfile3D, {axisPt, axisK0Mass, axisMultiplicity}}); - histos.add("K0d22Bpt", "", {HistType::kTProfile3D, {axisPt, axisK0Mass, axisMultiplicity}}); - histos.add("K0d24Bpt", "", {HistType::kTProfile3D, {axisPt, axisK0Mass, axisMultiplicity}}); - - histos.add("hK0Count", "Number of K0;; Count", {HistType::kTH1D, {{11, 0, 11}}}); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(1, "K0 candidates"); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(2, "Daughter pt"); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(3, "Mass cut"); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(4, "Rapidity cut"); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(5, "DCA to PV"); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(6, "DCA between daughters"); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(7, "V0radius"); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(8, "CosPA"); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(9, "Proper lifetime"); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(10, "Daughter track selection"); - histos.get(HIST("hK0Count"))->GetXaxis()->SetBinLabel(11, "Mass cross check"); } histos.add("hEventCount", "Number of Event;; Count", {HistType::kTH1D, {{8, 0, 8}}}); @@ -355,10 +353,10 @@ struct ResonancesGfwFlow { refC22Boot[i] = histos.add(Form("BootStrap/Refc22_bootstrap_%d", i), "", {HistType::kTProfile, {axisMultiplicity}}); refC24Boot[i] = histos.add(Form("BootStrap/Refc24_bootstrap_%d", i), "", {HistType::kTProfile, {axisMultiplicity}}); if (cfgUsePhi) { - phiD22FPtBoot[i] = histos.add(Form("BootStrap/Phid22Fpt_bootstrap_%d", i), "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); - phiD24FPtBoot[i] = histos.add(Form("BootStrap/Phid24Fpt_bootstrap_%d", i), "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); - phiD22BPtBoot[i] = histos.add(Form("BootStrap/Phid22Bpt_bootstrap_%d", i), "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); - phiD24BPtBoot[i] = histos.add(Form("BootStrap/Phid24Bpt_bootstrap_%d", i), "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); + phiD22FPtBoot[i] = histos.add(Form("BootStrap/phid22Fpt_bootstrap_%d", i), "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); + phiD24FPtBoot[i] = histos.add(Form("BootStrap/phid24Fpt_bootstrap_%d", i), "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); + phiD22BPtBoot[i] = histos.add(Form("BootStrap/phid22Bpt_bootstrap_%d", i), "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); + phiD24BPtBoot[i] = histos.add(Form("BootStrap/phid24Bpt_bootstrap_%d", i), "", {HistType::kTProfile3D, {axisPt, axisPhiMass, axisMultiplicity}}); } if (cfgUseK0) { k0D22FPtBoot[i] = histos.add(Form("BootStrap/k0d22Fpt_bootstrap_%d", i), "", {HistType::kTProfile3D, {axisPt, axisK0Mass, axisMultiplicity}}); @@ -385,7 +383,7 @@ struct ResonancesGfwFlow { double* ptBins = &(axis.binEdges)[0]; fPtAxis = new TAxis(nPtBins, ptBins); - fPhiMassAxis = new TAxis(vMassBins[Phi - 2], 0.99, 1.06); + fPhiMassAxis = new TAxis(vMassBins[Phi - 2], vMassMin[Phi - 2], vMassMax[Phi - 2]); fK0MassAxis = new TAxis(vMassBins[K0 - 1], vMassMin[K0 - 1], vMassMax[K0 - 1]); fLambdaMassAxis = new TAxis(vMassBins[Lambda - 1], vMassMin[Lambda - 1], vMassMax[Lambda - 1]); @@ -433,29 +431,29 @@ struct ResonancesGfwFlow { corrconfigs.push_back(fGFW->GetCorrelatorConfig("refN08 {2 2} refP08 {-2 -2}", "Ref08Gap24", kFALSE)); //--------- pt differential pois - if (cfgUsePhi) { - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNphi refN08 | olNphi {2} refP08 {-2}", "PhiF08Gap22", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNphi refN08 | olNphi {2 2} refP08 {-2 -2}", "PhiF08Gap24", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPphi refP08 | olPphi {2} refN08 {-2}", "PhiB08Gap22", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPphi refP08 | olPphi {2 2} refN08 {-2 -2}", "PhiB08Gap24", kTRUE)); - } - if (cfgUseK0) { - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNk0 refN08 | olNk0 {2} refP08 {-2}", "KsF08Gap22", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNk0 refN08 | olNk0 {2 2} refP08 {-2 -2}", "KsF08Gap24", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPk0 refP08 | olPk0 {2} refN08 {-2}", "KsB08Gap22", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPk0 refP08 | olPk0 {2 2} refN08 {-2 -2}", "KsB08Gap24", kTRUE)); - } - if (cfgUseLambda) { - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNlam refN08 | olNlam {2} refP08 {-2}", "LamF08Gap22", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNlam refN08 | olNlam {2 2} refP08 {-2 -2}", "LamF08Gap24", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPlam refP08 | olPlam {2} refN08 {-2}", "LamB08Gap22", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPlam refP08 | olPlam {2 2} refN08 {-2 -2}", "LamB08Gap24", kTRUE)); - - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNantilam refN08 | olNantilam {2} refP08 {-2}", "AnLamF08Gap22", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNantilam refN08 | olNantilam {2 2} refP08 {-2 -2}", "AnLamF08Gap24", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPantilam refP08 | olPantilam {2} refN08 {-2}", "AnLamB08Gap22", kTRUE)); - corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPantilam refP08 | olPantilam {2 2} refN08 {-2 -2}", "AnLamB08Gap24", kTRUE)); - } + // Phi + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNphi refN08 | olNphi {2} refP08 {-2}", "PhiF08Gap22", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNphi refN08 | olNphi {2 2} refP08 {-2 -2}", "PhiF08Gap24", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPphi refP08 | olPphi {2} refN08 {-2}", "PhiB08Gap22", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPphi refP08 | olPphi {2 2} refN08 {-2 -2}", "PhiB08Gap24", kTRUE)); + + // K0 + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNk0 refN08 | olNk0 {2} refP08 {-2}", "KsF08Gap22", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNk0 refN08 | olNk0 {2 2} refP08 {-2 -2}", "KsF08Gap24", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPk0 refP08 | olPk0 {2} refN08 {-2}", "KsB08Gap22", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPk0 refP08 | olPk0 {2 2} refN08 {-2 -2}", "KsB08Gap24", kTRUE)); + + // Lambda + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNlam refN08 | olNlam {2} refP08 {-2}", "LamF08Gap22", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNlam refN08 | olNlam {2 2} refP08 {-2 -2}", "LamF08Gap24", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPlam refP08 | olPlam {2} refN08 {-2}", "LamB08Gap22", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPlam refP08 | olPlam {2 2} refN08 {-2 -2}", "LamB08Gap24", kTRUE)); + + // Antilambda + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNantilam refN08 | olNantilam {2} refP08 {-2}", "AnLamF08Gap22", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiNantilam refN08 | olNantilam {2 2} refP08 {-2 -2}", "AnLamF08Gap24", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPantilam refP08 | olPantilam {2} refN08 {-2}", "AnLamB08Gap22", kTRUE)); + corrconfigs.push_back(fGFW->GetCorrelatorConfig("poiPantilam refP08 | olPantilam {2 2} refN08 {-2 -2}", "AnLamB08Gap24", kTRUE)); fGFW->CreateRegions(); @@ -480,7 +478,7 @@ struct ResonancesGfwFlow { } template - void fillResoProfile(const GFW::CorrConfig& corrconf, const ConstStr& tarName, const double& cent, TAxis* partaxis) + void fillResoProfile(const GFW::CorrConfig& corrconf, const ConstStr& tarName, const double cent, TAxis* partaxis) { double dnx, val; if (!corrconf.pTDif) { @@ -684,6 +682,8 @@ struct ResonancesGfwFlow { double wacc = 1; double cent = collision.centFT0C(); double vtxz = collision.posZ(); + double phi = mom.Phi(); + phi = RecoDecay::constrainAngle(phi, 0.0, 1); // constrain azimuthal angle to [0,2pi] if ((cfgUseWeightPhiEtaVtxz && cfgUseWeightPhiPtCent) || (cfgUseWeightPhiEtaPt && cfgUseWeightPhiPtCent) || (cfgUseWeightPhiEtaVtxz && cfgUseWeightPhiEtaPt)) { LOGF(fatal, "Only one of the three weight options can be used at a time"); @@ -694,11 +694,11 @@ struct ResonancesGfwFlow { return 1; } if (cfgUseWeightPhiEtaVtxz) - wacc = mAcceptance[pid_index_reso]->getNUA(mom.Phi(), mom.Eta(), vtxz); + wacc = mAcceptance[pid_index_reso]->getNUA(phi, mom.Eta(), vtxz); if (cfgUseWeightPhiPtCent) - wacc = mAcceptance[pid_index_reso]->getNUA(mom.Phi(), mom.Pt(), cent); + wacc = mAcceptance[pid_index_reso]->getNUA(phi, mom.Pt(), cent); if (cfgUseWeightPhiEtaPt) - wacc = mAcceptance[pid_index_reso]->getNUA(mom.Phi(), mom.Eta(), mom.Pt()); + wacc = mAcceptance[pid_index_reso]->getNUA(phi, mom.Eta(), mom.Pt()); } return wacc; } @@ -761,34 +761,45 @@ struct ResonancesGfwFlow { histos.fill(HIST("KaminusTPC"), partminus.pt(), partminus.tpcNSigmaKa()); histos.fill(HIST("KaminusTOF"), partminus.pt(), partminus.tofNSigmaKa()); + std::array, 2> ptarr = {{{partplus.px(), partplus.py(), partplus.pz()}, {partminus.px(), partminus.py(), partminus.pz()}}}; + std::array massarr = {plusmass, plusmass}; + + // Calculation using RecoDecay + double invMassRD = RecoDecay::m2(ptarr, massarr); + double ptRD = std::sqrt(RecoDecay::sumOfSquares(partplus.pt(), partminus.pt())); + + // Calculation using ROOT vectors plusdaug = ROOT::Math::PxPyPzMVector(partplus.px(), partplus.py(), partplus.pz(), plusmass); minusdaug = ROOT::Math::PxPyPzMVector(partminus.px(), partminus.py(), partminus.pz(), plusmass); mom = plusdaug + minusdaug; double pt = mom.Pt(); double invMass = mom.M(); + double phi = mom.Phi(); bool withinPtPOI = (cfgCutPtPOIMin < pt) && (pt < cfgCutPtPOIMax); // within POI pT range bool withinPtRef = (cfgCutPtMin < pt) && (pt < cfgCutPtMax); + phi = RecoDecay::constrainAngle(phi, 0.0, 1); // constrain azimuthal angle to [0,2pi] + if (std::abs(mom.Rapidity()) < cfgRapidityCut) { histos.fill(hist, invMass, pt, collision.centFT0C()); - histos.fill(HIST("hPhiPhi"), mom.Phi()); + histos.fill(HIST("hPhiPhi"), phi); histos.fill(HIST("hPhiEta"), mom.Eta()); + histos.fill(HIST("hPhimassSparse_RD"), invMassRD, ptRD, collision.centFT0C()); // fill RecoDecay mass and pt // Fill Phi weights if (cfgOutputNUAWeights && withinPtPOI) { - histos.fill(HIST("NUA/hPhiEtaVtxz_phi"), mom.Phi(), mom.Eta(), collision.posZ()); - histos.fill(HIST("NUA/hPhiPtCent_phi"), mom.Phi(), pt, collision.centFT0C()); - histos.fill(HIST("NUA/hPhiEtaPt_phi"), mom.Phi(), mom.Eta(), pt); + histos.fill(HIST("NUA/hPhiEtaVtxz_phi"), phi, mom.Eta(), collision.posZ()); + histos.fill(HIST("NUA/hPhiPtCent_phi"), phi, pt, collision.centFT0C()); + histos.fill(HIST("NUA/hPhiEtaPt_phi"), phi, mom.Eta(), pt); } - double weff = 1; double waccPOI = getAcceptancePhi(mom, collision, Phi); if (withinPtPOI) - fGFW->Fill(mom.Eta(), ((fPtAxis->FindBin(pt) - 1) * fPhiMassAxis->GetNbins()) + (fPhiMassAxis->FindBin(invMass) - 1), mom.Phi(), weff * waccPOI, 2); + fGFW->Fill(mom.Eta(), ((fPtAxis->FindBin(pt) - 1) * fPhiMassAxis->GetNbins()) + (fPhiMassAxis->FindBin(invMass) - 1), phi, weff * waccPOI, 2); if (withinPtPOI && withinPtRef) - fGFW->Fill(mom.Eta(), ((fPtAxis->FindBin(pt) - 1) * fPhiMassAxis->GetNbins()) + (fPhiMassAxis->FindBin(invMass) - 1), mom.Phi(), weff * waccPOI, 32); + fGFW->Fill(mom.Eta(), ((fPtAxis->FindBin(pt) - 1) * fPhiMassAxis->GetNbins()) + (fPhiMassAxis->FindBin(invMass) - 1), phi, weff * waccPOI, 32); } } return; @@ -875,10 +886,6 @@ struct ResonancesGfwFlow { return false; } histos.fill(HIST("hLambdaCount"), 9.5); - // Mass cross check - if (cfgUseMCCLambda && std::abs(massK0Short - 0.497614) < vMccCut[Lambda - 1]) - return false; - histos.fill(HIST("hLambdaCount"), 10.5); bool withinPtPOI = (cfgCutPtPOIMin < candidate.pt()) && (candidate.pt() < cfgCutPtPOIMax); // within POI pT range bool withinPtRef = (cfgCutPtMin < candidate.pt()) && (candidate.pt() < cfgCutPtMax); @@ -965,12 +972,6 @@ struct ResonancesGfwFlow { if (!selectionV0Daughter(postrack, 0) || !selectionV0Daughter(negtrack, 0)) return false; histos.fill(HIST("hK0Count"), 9.5); - // Mass cross check - if (cfgUseMCCK0 && std::abs(massLambda - 1.11568) < vMccCut[K0 - 1]) - return false; - if (cfgUseMCCK0 && std::abs(massLambda - 1.11568) < vMccCut[K0 - 1]) - return false; - histos.fill(HIST("hK0Count"), 10.5); bool withinPtPOI = (cfgCutPtPOIMin < candidate.pt()) && (candidate.pt() < cfgCutPtPOIMax); // within POI pT range bool withinPtRef = (cfgCutPtMin < candidate.pt()) && (candidate.pt() < cfgCutPtMax); @@ -1087,6 +1088,8 @@ struct ResonancesGfwFlow { double pt = track.pt(); bool withinPtRef = (cfgCutPtMin < pt) && (pt < cfgCutPtMax); + weff = 1; // Initializing weff for each track + if (withinPtRef) if (cfgOutputNUAWeights) fillWeights(track, collision, Ref); @@ -1117,19 +1120,18 @@ struct ResonancesGfwFlow { } for (auto const& v0s : V0s) { - if (cfgUseLambda) { - if (selectionLambda(collision, v0s) == true) - histos.fill(HIST("hLambdas"), 1); - } if (cfgUseK0) { if (selectionK0(collision, v0s) == true) histos.fill(HIST("hK0s"), 1); } + if (cfgUseLambda) { + if (selectionLambda(collision, v0s) == true) + histos.fill(HIST("hLambdas"), 1); + } } // End of v0 loop fillResoProfile(corrconfigs.at(0), HIST("Refc22"), cent, fPhiMassAxis); fillResoProfile(corrconfigs.at(1), HIST("Refc24"), cent, fPhiMassAxis); - if (cfgUsePhi) { fillResoProfile(corrconfigs.at(2), HIST("Phid22Fpt"), cent, fPhiMassAxis); fillResoProfile(corrconfigs.at(3), HIST("Phid24Fpt"), cent, fPhiMassAxis); @@ -1185,7 +1187,6 @@ struct ResonancesGfwFlow { fillProfileBoot3D(corrconfigs.at(16), anLambdaD22BPtBoot[bootId], cent, fLambdaMassAxis); fillProfileBoot3D(corrconfigs.at(17), anLambdaD24BPtBoot[bootId], cent, fLambdaMassAxis); } - } // end of bootstrap condition } // end of process }; diff --git a/PWGCF/MultiparticleCorrelations/Tasks/threeParticleCorrelations.cxx b/PWGCF/MultiparticleCorrelations/Tasks/threeParticleCorrelations.cxx index 2e94202f054..a9ae8ac562c 100644 --- a/PWGCF/MultiparticleCorrelations/Tasks/threeParticleCorrelations.cxx +++ b/PWGCF/MultiparticleCorrelations/Tasks/threeParticleCorrelations.cxx @@ -470,11 +470,13 @@ struct ThreeParticleCorrelations { // End of the MC Mixed-events Correlations } - void processMCGen(MyFilteredMCGenCollision const&, MyFilteredMCParticles const&) + void processMCGen(MyFilteredMCGenCollision const& collision, MyFilteredMCParticles const&) { + auto groupMCParticles = mcParticles->sliceByCached(aod::mcparticle::mcCollisionId, collision.globalIndex(), cache); + // Start of the Monte-Carlo generated QA - for (const auto& particle : mcParticles) { + for (const auto& particle : groupMCParticles) { if (particle.isPhysicalPrimary()) { // Efficiency - Generated diff --git a/PWGCF/Tasks/correlations.cxx b/PWGCF/Tasks/correlations.cxx index f0ef51ff0d7..7461cc4b671 100644 --- a/PWGCF/Tasks/correlations.cxx +++ b/PWGCF/Tasks/correlations.cxx @@ -22,6 +22,7 @@ #include #include #include +#include #include "Framework/runDataProcessing.h" #include "Framework/AnalysisTask.h" @@ -165,6 +166,7 @@ struct CorrelationTask { registry.add("invMass", "2-prong invariant mass (GeV/c^2)", {HistType::kTH3F, {axisInvMassHistogram, axisPtTrigger, axisMultiplicity}}); if (doprocessSame2Prong2Prong || doprocessSame2Prong2ProngML) { registry.add("invMassTwoPart", "2D 2-prong invariant mass (GeV/c^2)", {HistType::kTHnSparseF, {axisInvMassHistogram, axisInvMassHistogram, axisPtTrigger, axisPtAssoc, axisMultiplicity}}); + registry.add("invMassTwoPartDPhi", "2D 2-prong invariant mass (GeV/c^2)", {HistType::kTHnSparseF, {axisInvMassHistogram, axisInvMassHistogram, axisPtTrigger, axisPtAssoc, axisDeltaPhi}}); } } registry.add("multiplicity", "event multiplicity", {HistType::kTH1F, {{1000, 0, 100, "/multiplicity/centrality"}}}); @@ -328,6 +330,7 @@ struct CorrelationTask { if (cfgCorrelationMethod == 2 && track1.decay() == track2.decay()) continue; registry.fill(HIST("invMassTwoPart"), track1.invMass(), track2.invMass(), track1.pt(), track2.pt(), multiplicity); + registry.fill(HIST("invMassTwoPartDPhi"), track1.invMass(), track2.invMass(), track1.pt(), track2.pt(), TVector2::Phi_0_2pi(track1.phi() - track2.phi() + TMath::Pi() / 2.0) - TMath::Pi() / 2.0); } } } diff --git a/PWGCF/TwoParticleCorrelations/TableProducer/identifiedBfFilter.cxx b/PWGCF/TwoParticleCorrelations/TableProducer/identifiedBfFilter.cxx index 4b57042f15a..5eda3450473 100644 --- a/PWGCF/TwoParticleCorrelations/TableProducer/identifiedBfFilter.cxx +++ b/PWGCF/TwoParticleCorrelations/TableProducer/identifiedBfFilter.cxx @@ -1679,13 +1679,14 @@ inline int8_t IdentifiedBfFilterTracks::acceptParticle(ParticleObject& particle, } if (ptlow < particle.pt() && particle.pt() < ptup && etalow < particle.eta() && particle.eta() < etaup) { - MatchRecoGenSpecies sp; + MatchRecoGenSpecies sp = kWrongSpecies; if (recoIdMethod == recoIdMethods[0]) { sp = kIdBfCharged; } - if (recoIdMethod == recoIdMethods[1]) { + if (recoIdMethod == recoIdMethods[1] || recoIdMethod == recoIdMethods[2]) { sp = identifyParticle(particle); } + if (sp != kWrongSpecies) { if (sp != kIdBfCharged) { /* fill the charged particle histograms */ diff --git a/PWGCF/TwoParticleCorrelations/Tasks/identifiedbf.cxx b/PWGCF/TwoParticleCorrelations/Tasks/identifiedbf.cxx index 7319f70d946..b357272c17c 100644 --- a/PWGCF/TwoParticleCorrelations/Tasks/identifiedbf.cxx +++ b/PWGCF/TwoParticleCorrelations/Tasks/identifiedbf.cxx @@ -100,6 +100,7 @@ struct IdentifiedbfTask { std::vector fhN1VsZEtaPhiPt{nch + 1, nullptr}; //! fhN1VsZEtaPhiPtPrimary{nch, nullptr}; //! fhN1VsZEtaPhiPtSecondary{nch, nullptr}; //! fhN1VsZEtaPhiPtPure{nch + 1, nullptr}; //! fhSum1PtVsZEtaPhiPt{nch, nullptr}; //! fhNuaNueVsZEtaPhiPt{nch, nullptr}; //! fhPtAvgVsEtaPhi{nch, nullptr}; //! + bool isSpeciesCheck(ParticleObject const& particle, int trkId) + { + int pdgcode = particle.pdgCode(); + int realPID = -1; + switch (pdgcode) { + case kPositron: + realPID = 0; + break; + case kElectron: + realPID = 1; + break; + case kPiPlus: + realPID = 2; + break; + case kPiMinus: + realPID = 3; + break; + case kKPlus: + realPID = 4; + break; + case kKMinus: + realPID = 5; + break; + case kProton: + realPID = 6; + break; + case kProtonBar: + realPID = 7; + break; + default: + realPID = -1; + break; + } + return (realPID == trkId); + } + + /// \brief checks whether MC track is a physical primary or secondary + /// \param particle passed MC track converted to MCParticle + template + bool isPrimarySpeciesCheck(TrackObject const& track, int trkId) + { + if constexpr (framework::has_type_v) { + return (isPrimaryCheck(track.template mcParticle_as()) && isSpeciesCheck(track.template mcParticle_as(), trkId)); + } + return false; + } + /// \brief fills the singles histograms in singles execution mode /// \param passedtracks filtered table with the tracks associated to the passed index /// \param tix index, in the singles histogram bank, for the passed filetered track table @@ -315,6 +366,9 @@ struct IdentifiedbfTask { fhN1VsZEtaPhiPt[track.trackacceptedid()]->Fill(zvtx, getEtaPhiIndex(track) + 0.5, track.pt(), corr); fhSum1PtVsZEtaPhiPt[track.trackacceptedid()]->Fill(zvtx, getEtaPhiIndex(track) + 0.5, track.pt(), track.pt() * corr); trackPrimaryCheck(track, zvtx, corr); + if (isPrimarySpeciesCheck(track, track.trackacceptedid())) { + fhN1VsZEtaPhiPtPure[track.trackacceptedid()]->Fill(zvtx, getEtaPhiIndex(track) + 0.5, track.pt(), corr); + } } index++; } @@ -583,6 +637,23 @@ struct IdentifiedbfTask { ptlow, ptup); + fhN1VsZEtaPhiPtPure[i] = new TH3F( + TString::Format("n1_%s_Pure_vsZ_vsEtaPhi_vsPt", tname[i].c_str()).Data(), + TString::Format("#LT n_{1} Pure #GT;vtx_{z};#eta_{%s}#times#varphi_{%s};p_{t,%s} (GeV/c)", + tname[i].c_str(), + tname[i].c_str(), + tname[i].c_str()) + .Data(), + zvtxbins, + zvtxlow, + zvtxup, + etabins * phibins, + 0.0, + static_cast(etabins * phibins), + ptbins, + ptlow, + ptup); + fhSum1PtVsZEtaPhiPt[i] = new TH3F( TString::Format("sumPt1_%s_vsZ_vsEtaPhi_vsPt", tname[i].c_str()).Data(), TString::Format( @@ -618,6 +689,8 @@ struct IdentifiedbfTask { fhN1VsZEtaPhiPtPrimary[i]->Sumw2(false); fhN1VsZEtaPhiPtSecondary[i]->SetBit(TH1::kIsNotW); fhN1VsZEtaPhiPtSecondary[i]->Sumw2(false); + fhN1VsZEtaPhiPtPure[i]->SetBit(TH1::kIsNotW); + fhN1VsZEtaPhiPtPure[i]->Sumw2(false); fhSum1PtVsZEtaPhiPt[i]->SetBit(TH1::kIsNotW); fhSum1PtVsZEtaPhiPt[i]->Sumw2(false); } @@ -632,6 +705,7 @@ struct IdentifiedbfTask { fOutputList->Add(fhN1VsZEtaPhiPt[i]); fOutputList->Add(fhN1VsZEtaPhiPtPrimary[i]); fOutputList->Add(fhN1VsZEtaPhiPtSecondary[i]); + fOutputList->Add(fhN1VsZEtaPhiPtPure[i]); fOutputList->Add(fhSum1PtVsZEtaPhiPt[i]); } } diff --git a/PWGDQ/Core/CutsLibrary.cxx b/PWGDQ/Core/CutsLibrary.cxx index f9da97e17d7..ff2cfe9298d 100644 --- a/PWGDQ/Core/CutsLibrary.cxx +++ b/PWGDQ/Core/CutsLibrary.cxx @@ -119,6 +119,53 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) cut->AddCut(pidCuts); return cut; } + + if (!nameStr.compare("Electron2025_4")) { + AnalysisCut* kineCut = new AnalysisCut("kineCut", "kine cut"); + kineCut->AddCut(VarManager::kP, 1.0, 1000.0); + kineCut->AddCut(VarManager::kEta, -0.9, 0.9); + + AnalysisCut* qualityCuts = new AnalysisCut("qualityCuts", "quality cuts"); + qualityCuts->AddCut(VarManager::kIsITSibAny, 0.5, 1.5); + qualityCuts->AddCut(VarManager::kTPCchi2, 0.0, 5.0); + qualityCuts->AddCut(VarManager::kTPCncls, 60, 161.); + qualityCuts->AddCut(VarManager::kTrackDCAz, -0.5, 0.5); + + AnalysisCut* pidCuts = new AnalysisCut("pidCuts", "pid cuts"); + pidCuts->AddCut(VarManager::kTPCnSigmaEl, -2.5, 4.0, false, VarManager::kPin, 0.0, 5.0); + pidCuts->AddCut(VarManager::kTPCnSigmaEl, -1.5, 4.0, false, VarManager::kPin, 5.0, 1000.0); + pidCuts->AddCut(VarManager::kTPCnSigmaPi, 2.5, 999, false, VarManager::kPin, 0.0, 5.0); + pidCuts->AddCut(VarManager::kTPCnSigmaPr, 3.0, 999, false, VarManager::kPin, 0.0, 5.0); + + cut->AddCut(kineCut); + cut->AddCut(qualityCuts); + cut->AddCut(pidCuts); + return cut; + } + + if (!nameStr.compare("Electron2025_5")) { + AnalysisCut* kineCut = new AnalysisCut("kineCut", "kine cut"); + kineCut->AddCut(VarManager::kP, 1.0, 1000.0); + kineCut->AddCut(VarManager::kEta, -0.9, 0.9); + + AnalysisCut* qualityCuts = new AnalysisCut("qualityCuts", "quality cuts"); + qualityCuts->AddCut(VarManager::kIsITSibAny, 0.5, 1.5); + qualityCuts->AddCut(VarManager::kTPCchi2, 0.0, 5.0); + qualityCuts->AddCut(VarManager::kTPCncls, 60, 161.); + qualityCuts->AddCut(VarManager::kTrackDCAz, -0.5, 0.5); + + AnalysisCut* pidCuts = new AnalysisCut("pidCuts", "pid cuts"); + pidCuts->AddCut(VarManager::kTPCnSigmaEl, -2.25, 4.0, false, VarManager::kPin, 0.0, 5.0); + pidCuts->AddCut(VarManager::kTPCnSigmaEl, -1.5, 4.0, false, VarManager::kPin, 5.0, 1000.0); + pidCuts->AddCut(VarManager::kTPCnSigmaPi, 2.5, 999, false, VarManager::kPin, 0.0, 5.0); + pidCuts->AddCut(VarManager::kTPCnSigmaPr, 3.0, 999, false, VarManager::kPin, 0.0, 5.0); + + cut->AddCut(kineCut); + cut->AddCut(qualityCuts); + cut->AddCut(pidCuts); + return cut; + } + if (!nameStr.compare("LowMassElectron2023")) { cut->AddCut(GetAnalysisCut("lmeeStandardKine")); cut->AddCut(GetAnalysisCut("LooseGlobalTrackRun3")); @@ -2910,6 +2957,11 @@ AnalysisCompositeCut* o2::aod::dqcuts::GetCompositeCut(const char* cutName) return cut; } + if (!nameStr.compare("muonMinimalCuts")) { + cut->AddCut(GetAnalysisCut("muonMinimalCuts")); + return cut; + } + if (!nameStr.compare("muonQualityCuts")) { cut->AddCut(GetAnalysisCut("muonQualityCuts")); return cut; @@ -3946,6 +3998,15 @@ AnalysisCut* o2::aod::dqcuts::GetAnalysisCut(const char* cutName) return cut; } + if (!nameStr.compare("eventStandardSel8VtxQuality1")) { // kIsSel8 = kIsTriggerTVX && kNoITSROFrameBorder && kNoTimeFrameBorder + cut->AddCut(VarManager::kVtxZ, -10.0, 10.0); + cut->AddCut(VarManager::kIsSel8, 0.5, 1.5); + cut->AddCut(VarManager::kIsNoSameBunch, 0.5, 1.5); + cut->AddCut(VarManager::kIsVertexITSTPC, 0.5, 1.5); + cut->AddCut(VarManager::kIsVertexTOFmatched, 0.5, 1.5); + return cut; + } + if (!nameStr.compare("eventStandardSel8PbPbMultCorr")) { TF1* fMultPVCutLow = new TF1("fMultPVCutLow", "[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x - 3.5*([5]+[6]*x+[7]*x*x+[8]*x*x*x+[9]*x*x*x*x)", 0, 100); fMultPVCutLow->SetParameters(3257.29, -121.848, 1.98492, -0.0172128, 6.47528e-05, 154.756, -1.86072, -0.0274713, 0.000633499, -3.37757e-06); @@ -5982,6 +6043,14 @@ AnalysisCut* o2::aod::dqcuts::GetAnalysisCut(const char* cutName) return cut; } + if (!nameStr.compare("muonMinimalCuts")) { + cut->AddCut(VarManager::kEta, -4.0, -2.5); + cut->AddCut(VarManager::kMuonRAtAbsorberEnd, 17.6, 89.5); + cut->AddCut(VarManager::kMuonPDca, 0.0, 594.0, false, VarManager::kMuonRAtAbsorberEnd, 17.6, 26.5); + cut->AddCut(VarManager::kMuonPDca, 0.0, 324.0, false, VarManager::kMuonRAtAbsorberEnd, 26.5, 89.5); + return cut; + } + if (!nameStr.compare("muonQualityCuts")) { cut->AddCut(VarManager::kEta, -4.0, -2.5); cut->AddCut(VarManager::kMuonRAtAbsorberEnd, 17.6, 89.5); diff --git a/PWGDQ/Core/HistogramsLibrary.cxx b/PWGDQ/Core/HistogramsLibrary.cxx index 4134b84d953..d2c662898ce 100644 --- a/PWGDQ/Core/HistogramsLibrary.cxx +++ b/PWGDQ/Core/HistogramsLibrary.cxx @@ -168,6 +168,7 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h hm->AddHistogram(histClass, "TPCoccupMedianTimeShortA", "TPC occupancy from pileup, median time, A-side, short time range", false, 100, -20.0, 20.0, VarManager::kNTPCmedianTimeShortA); hm->AddHistogram(histClass, "TPCoccupMedianTimeShortC", "TPC occupancy from pileup, median time, C-side, short time range", false, 100, -20.0, 20.0, VarManager::kNTPCmedianTimeShortC); hm->AddHistogram(histClass, "TPCoccupMedianTimeShortAvsC", "TPC occupancy from pileup, median time, A-side vs C-side, short time range", false, 100, -20.0, 20.0, VarManager::kNTPCmedianTimeShortA, 100, -20.0, 20.0, VarManager::kNTPCmedianTimeShortC); + hm->AddHistogram(histClass, "TPCoccupContribLongA_TrackOccup", "TPC occupancy from pileup, n-contrib, A-side, long time range vs common track occup", false, 100, 0.0, 10000.0, VarManager::kNTPCcontribLongA, 100, 0.0, 10000.0, VarManager::kTrackOccupancyInTimeRange); hm->AddHistogram(histClass, "NcontribReal_centT0C", "Ncontrib vs Cent", false, 100, 0, 100, VarManager::kCentFT0C, 4000, 0, 4000, VarManager::kVtxNcontribReal); hm->AddHistogram(histClass, "globalTracks_centT0C", "globalTracks vs Cent", false, 100, 0, 100, VarManager::kCentFT0C, 4000, 0, 4000, VarManager::kMultA); hm->AddHistogram(histClass, "ITSTPCTracks_centT0C", "ITSTPCTracks vs Cent", false, 100, 0, 100, VarManager::kCentFT0C, 4000, 0, 4000, VarManager::kMultAllTracksITSTPC); @@ -915,6 +916,12 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h } if (!groupStr.CompareTo("pair")) { + if (subGroupStr.Contains("cepf")) { + hm->AddHistogram(histClass, "Mass", "", false, 300, 0.0, 12.0, VarManager::kMass); + hm->AddHistogram(histClass, "Mass_Pt", "", false, 300, 0.0, 12.0, VarManager::kMass, 10, 0.0, 20.0, VarManager::kPt); + hm->AddHistogram(histClass, "Mass_Y", "", false, 300, 0.0, 12.0, VarManager::kMass, 100, -5.0, 5.0, VarManager::kRap); + hm->AddHistogram(histClass, "Y_Pt", "", false, 100, -5.0, 5.0, VarManager::kRap, 20, 0.0, 20.0, VarManager::kPt); + } if (subGroupStr.Contains("mult_pvcontrib")) { hm->AddHistogram(histClass, "Mass_VtxNcontribReal", "Mass vs VtxNcontribReal", false, 200, 2.0, 5.0, VarManager::kMass, 200, 0, 200.0, VarManager::kVtxNcontribReal); } @@ -946,6 +953,7 @@ void o2::aod::dqhistograms::DefineHistograms(HistogramManager* hm, const char* h if (subGroupStr.Contains("mult")) { hm->AddHistogram(histClass, "Mass_Pt_MultFV0A", "", false, 200, 0.0, 5.0, VarManager::kMass, 40, 0.0, 40.0, VarManager::kPt, 100, 0.0, 25000.0, VarManager::kMultFV0A); hm->AddHistogram(histClass, "Mass_VtxNcontribReal", "Mass vs VtxNcontribReal", false, 200, 0.0, 5.0, VarManager::kMass, 200, 0, 200.0, VarManager::kVtxNcontribReal); + hm->AddHistogram(histClass, "Mass_VtxNcontribReal_VtxZ", "Mass vs VtxNcontribReal vs VtxZ", false, 200, 2.0, 5.0, VarManager::kMass, 150, 0, 150.0, VarManager::kVtxNcontribReal, 20, -10.0, 10.0, VarManager::kVtxZ); hm->AddHistogram(histClass, "VtxZ_VtxNcontribReal", "VtxZ vs VtxNcontribReal", false, 240, -12.0, 12.0, VarManager::kVtxZ, 200, 0, 200.0, VarManager::kVtxNcontribReal); } if (subGroupStr.Contains("polarization")) { diff --git a/PWGDQ/Core/MCSignalLibrary.cxx b/PWGDQ/Core/MCSignalLibrary.cxx index 7872429efb8..614dcc3a2c4 100644 --- a/PWGDQ/Core/MCSignalLibrary.cxx +++ b/PWGDQ/Core/MCSignalLibrary.cxx @@ -126,6 +126,11 @@ MCSignal* o2::aod::dqmcsignals::GetMCSignal(const char* name) signal = new MCSignal(name, "Inclusive jpsi", {prong}, {-1}); return signal; } + if (!nameStr.compare("Helium3")) { + MCProng prong(1, {1000020030}, {true}, {false}, {0}, {0}, {false}); + signal = new MCSignal(name, "Helium3", {prong}, {-1}); + return signal; + } if (!nameStr.compare("Helium3Primary")) { MCProng prong(1, {1000020030}, {true}, {false}, {0}, {0}, {false}); prong.SetSourceBit(0, MCProng::kPhysicalPrimary); diff --git a/PWGDQ/Core/VarManager.h b/PWGDQ/Core/VarManager.h index 95269681f6c..5a193eb0415 100644 --- a/PWGDQ/Core/VarManager.h +++ b/PWGDQ/Core/VarManager.h @@ -2197,6 +2197,7 @@ void VarManager::FillTrack(T const& track, float* values) if constexpr ((fillMap & MuonRealign) > 0) { values[kMuonChi2] = track.chi2(); + values[kMuonTrackType] = track.trackType(); } if (fgUsedVars[kM11REFoverMpsingle]) { diff --git a/PWGDQ/DataModel/ReducedInfoTables.h b/PWGDQ/DataModel/ReducedInfoTables.h index 5a0f9809734..ca79b6becb3 100644 --- a/PWGDQ/DataModel/ReducedInfoTables.h +++ b/PWGDQ/DataModel/ReducedInfoTables.h @@ -905,7 +905,7 @@ DECLARE_SOA_COLUMN(Pt, pt, float); //! DECLARE_SOA_COLUMN(Eta, eta, float); //! DECLARE_SOA_COLUMN(Phi, phi, float); //! DECLARE_SOA_COLUMN(Sign, sign, int); //! -DECLARE_SOA_COLUMN(McDecision, mcDecision, uint32_t); //! +DECLARE_SOA_COLUMN(McDecision, mcDecision, uint16_t); //! } // namespace fwdpid DECLARE_SOA_TABLE(FwdPidsAll, "AOD", "RTFWDPIDALL", //! diff --git a/PWGDQ/TableProducer/tableMaker.cxx b/PWGDQ/TableProducer/tableMaker.cxx index 87390938f17..74545704593 100644 --- a/PWGDQ/TableProducer/tableMaker.cxx +++ b/PWGDQ/TableProducer/tableMaker.cxx @@ -290,7 +290,7 @@ struct TableMaker { context.mOptions.get("processFullWithCent") || context.mOptions.get("processFullWithCovAndEventFilter") || context.mOptions.get("processFullWithCovMultsAndEventFilter") || context.mOptions.get("processMuonOnlyWithCovAndCentMults") || context.mOptions.get("processMuonOnlyWithCov") || context.mOptions.get("processMuonOnlyWithCovAndEventFilter") || context.mOptions.get("processAmbiguousMuonOnlyWithCov") || - context.mOptions.get("processMuonsAndMFT") || context.mOptions.get("processMuonsAndMFTWithFilter") || context.mOptions.get("processMuonMLOnly")); + context.mOptions.get("processMuonsAndMFT") || context.mOptions.get("processMuonsAndMFTWithFilter") || context.mOptions.get("processMuonMLOnly") || context.mOptions.get("processAssociatedMuonOnlyWithCov") || context.mOptions.get("processAssociatedRealignedMuonOnlyWithCov")); if (enableBarrelHistos) { if (fDoDetailedQA) { diff --git a/PWGDQ/TableProducer/tableMaker_withAssoc.cxx b/PWGDQ/TableProducer/tableMaker_withAssoc.cxx index 1d71d8b362e..7adb6fbf23c 100644 --- a/PWGDQ/TableProducer/tableMaker_withAssoc.cxx +++ b/PWGDQ/TableProducer/tableMaker_withAssoc.cxx @@ -360,7 +360,7 @@ struct TableMaker { // Check whether we have to define barrel or muon histograms bool enableBarrelHistos = (context.mOptions.get("processPPWithFilter") || context.mOptions.get("processPPWithFilterBarrelOnly") || context.mOptions.get("processPPBarrelOnly") || context.mOptions.get("processPbPb") || context.mOptions.get("processPbPbBarrelOnly") || context.mOptions.get("processPbPbBarrelOnlyWithV0Bits") || context.mOptions.get("processPbPbBarrelOnlyWithV0BitsNoTOF")) || - context.mOptions.get("processPbPbWithFilterBarrelOnly"); + context.mOptions.get("processPbPbWithFilterBarrelOnly") || context.mOptions.get("processPPBarrelOnlyWithV0s"); bool enableMuonHistos = (context.mOptions.get("processPPWithFilter") || context.mOptions.get("processPPWithFilterMuonOnly") || context.mOptions.get("processPPWithFilterMuonMFT") || context.mOptions.get("processPPMuonOnly") || context.mOptions.get("processPPMuonMFT") || context.mOptions.get("processPPMuonMFTWithMultsExtra") || context.mOptions.get("processPbPb") || context.mOptions.get("processPbPbMuonOnly") || context.mOptions.get("processPbPbMuonMFT")); diff --git a/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx b/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx index 99f508a8b1e..c028f581567 100644 --- a/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx +++ b/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx @@ -2013,30 +2013,28 @@ struct AnalysisSameEventPairing { } if (fHasTwoProngGenMCsignals) { - for (auto& event : mcEvents) { - auto groupedMCTracks = mcTracks.sliceBy(perReducedMcEvent, event.globalIndex()); - groupedMCTracks.bindInternalIndicesTo(&mcTracks); - for (auto& [t1, t2] : combinations(groupedMCTracks, groupedMCTracks)) { - auto t1_raw = groupedMCTracks.rawIteratorAt(t1.globalIndex()); - auto t2_raw = groupedMCTracks.rawIteratorAt(t2.globalIndex()); - for (auto& sig : fGenMCSignals) { - if (sig->GetNProngs() != 2) { // NOTE: 2-prong signals required here - continue; - } - if (sig->CheckSignal(true, t1_raw, t2_raw)) { - mcDecision |= (static_cast(1) << isig); - VarManager::FillPairMC(t1, t2); - fHistMan->FillHistClass(Form("MCTruthGenPair_%s", sig->GetName()), VarManager::fgValues); - if (useMiniTree.fConfigMiniTree) { - // WARNING! To be checked - dileptonMiniTreeGen(mcDecision, event.impactParameter(), t1.pt(), t1.eta(), t1.phi(), t2.pt(), t2.eta(), t2.phi()); - } - } - isig++; - } // end loop over MC signals - } // end loop over pairs - } // end loop over events + uint32_t mcDecision = 0; + int isig = 0; + for (auto& [t1, t2] : combinations(mcTracks, mcTracks)) { + auto t1_raw = mcTracks.rawIteratorAt(t1.globalIndex()); + auto t2_raw = mcTracks.rawIteratorAt(t2.globalIndex()); + for (auto& sig : fGenMCSignals) { + if (sig->GetNProngs() != 2) { // NOTE: 2-prong signals required here + continue; + } + if (sig->CheckSignal(true, t1_raw, t2_raw)) { + mcDecision |= (static_cast(1) << isig); + VarManager::FillPairMC(t1, t2); + fHistMan->FillHistClass(Form("MCTruthGenPair_%s", sig->GetName()), VarManager::fgValues); + if (useMiniTree.fConfigMiniTree) { + // WARNING! To be checked + dileptonMiniTreeGen(mcDecision, -999, t1.pt(), t1.eta(), t1.phi(), t2.pt(), t2.eta(), t2.phi()); + } + } + isig++; + // cout << "I am Here" <; -using MyBarrelTracksSelected = soa::Join; +using MyBarrelTracksTPCPID = soa::Join; + using MyBarrelTracksAssocSelected = soa::Join; // As the kinelatic values must be re-computed for the tracks everytime it is associated to a collision, the selection is done not on the tracks, but on the track-collision association using MyMuons = soa::Join; using MyMuonsAssocSelected = soa::Join; // As the kinelatic values must be re-computed for the muons tracks everytime it is associated to a collision, the selection is done not on the muon, but on the muon-collision association -constexpr static uint32_t gkEventFillMap = VarManager::ObjTypes::BC | VarManager::ObjTypes::Collision; +constexpr static uint32_t gkEventFillMap = VarManager::ObjTypes::Collision; constexpr static uint32_t gkTrackFillMap = VarManager::ObjTypes::Track | VarManager::ObjTypes::TrackExtra | VarManager::ObjTypes::TrackDCA | VarManager::ObjTypes::TrackPID; +constexpr static uint32_t gkTrackFillMapTPCPID = VarManager::ObjTypes::Track | VarManager::ObjTypes::TrackExtra | VarManager::ObjTypes::TrackDCA | VarManager::ObjTypes::TrackTPCPID; constexpr static uint32_t gkMuonFillMap = VarManager::ObjTypes::Muon | VarManager::ObjTypes::MuonCov; -void DefineHistograms(HistogramManager* histMan, TString histClasses); +void DefineHistograms(HistogramManager* histMan, TString histClasses, TString subgroups = ""); + +template +void PrintBitMap(TMap map, int nbits) +{ + for (int i = 0; i < nbits; i++) { + cout << ((map & (TMap(1) << i)) > 0 ? "1" : "0"); + } +} struct DQEventSelectionTask { Produces eventSel; @@ -129,6 +137,7 @@ struct DQEventSelectionTask { Configurable fConfigEventCuts{"cfgEventCuts", "eventStandard", "Comma separated list of event cuts; multiple cuts are applied with a logical AND"}; Configurable fConfigQA{"cfgWithQA", false, "If true, fill QA histograms"}; + Configurable fConfigHistClasses{"cfgHistClasses", "vtxpp", "Comma separated list of histogram groups to be filled"}; // TODO: configure the histogram classes to be filled by QA void init(o2::framework::InitContext&) @@ -150,14 +159,14 @@ struct DQEventSelectionTask { fHistMan->SetUseDefaultVariableNames(kTRUE); fHistMan->SetDefaultVarNames(VarManager::fgVariableNames, VarManager::fgVariableUnits); - DefineHistograms(fHistMan, "Event_BeforeCuts;Event_AfterCuts;"); // define all histograms + DefineHistograms(fHistMan, "Event_BeforeCuts;Event_AfterCuts;", fConfigHistClasses.value); // define all histograms VarManager::SetUseVars(fHistMan->GetUsedVars()); // provide the list of required variables so that VarManager knows what to fill fOutputList.setObject(fHistMan->GetMainHistogramList()); } } template - void runEventSelection(TEvent const& collision, aod::BCs const& /*bcs*/) + void runEventSelection(TEvent const& collision) { // Reset the Values array VarManager::ResetValues(0, VarManager::kNEventWiseVariables); @@ -176,9 +185,9 @@ struct DQEventSelectionTask { } } - void processEventSelection(MyEvents::iterator const& collision, aod::BCs const& bcs) + void processEventSelection(MyEvents::iterator const& collision) { - runEventSelection(collision, bcs); + runEventSelection(collision); } void processDummy(MyEvents&) @@ -199,7 +208,8 @@ struct DQBarrelTrackSelection { Configurable fConfigCuts{"cfgBarrelTrackCuts", "jpsiPID1", "Comma separated list of barrel track cuts"}; Configurable fConfigCutsForEMu{"cfgBarrelTrackCutsForEMu", "jpsiPID1", "Comma separated list of barrel track cuts"}; Configurable fConfigQA{"cfgWithQA", false, "If true, fill QA histograms"}; - Configurable fPropTrack{"cfgPropTrack", false, "Propgate tracks to associated collision to recalculate DCA and momentum vector"}; + Configurable fConfigHistClasses{"cfgHistClasses", "its,tpcpid,dca", "If true, fill QA histograms"}; + Configurable fPropTrack{"cfgPropTrack", true, "Propgate tracks to associated collision to recalculate DCA and momentum vector"}; Configurable fConfigCcdbUrl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; Configurable fConfigCcdbPathTPC{"ccdb-path-tpc", "Users/i/iarsene/Calib/TPCpostCalib", "base path to the ccdb object"}; Configurable fConfigNoLaterThan{"ccdb-no-later-than", std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(), "latest acceptable timestamp of creation for the object"}; @@ -255,18 +265,15 @@ struct DQBarrelTrackSelection { fCutHistNames.push_back(Form("TrackBarrel_%s", cut.GetName())); } - DefineHistograms(fHistMan, cutNames.Data()); // define all histograms + DefineHistograms(fHistMan, cutNames.Data(), fConfigHistClasses.value); // define all histograms VarManager::SetUseVars(fHistMan->GetUsedVars()); // provide the list of required variables so that VarManager knows what to fill fOutputList.setObject(fHistMan->GetMainHistogramList()); // CCDB configuration - if (fConfigComputeTPCpostCalib) { - fCCDB->setURL(fConfigCcdbUrl.value); - fCCDB->setCaching(true); - fCCDB->setLocalObjectValidityChecking(); - // Not later than now objects - fCCDB->setCreatedNotAfter(fConfigNoLaterThan.value); - } + fCCDB->setURL(fConfigCcdbUrl.value); + fCCDB->setCaching(true); + fCCDB->setLocalObjectValidityChecking(); + fCCDB->setCreatedNotAfter(fConfigNoLaterThan.value); } } @@ -277,8 +284,14 @@ struct DQBarrelTrackSelection { auto bc = bcs.begin(); // check just the first bc to get the run number if (fCurrentRun != bc.runNumber()) { fCurrentRun = bc.runNumber(); - o2::parameters::GRPMagField* grpo = fCCDB->getForTimeStamp("GLO/Config/GRPMagField", bc.timestamp()); - o2::base::Propagator::initFieldFromGRP(grpo); + + o2::parameters::GRPMagField* grpmag = fCCDB->getForTimeStamp("GLO/Config/GRPMagField", bc.timestamp()); + if (grpmag != nullptr) { + VarManager::SetMagneticField(grpmag->getNominalL3Field()); + } else { + LOGF(fatal, "GRP object is not available in CCDB at timestamp=%llu", bc.timestamp()); + } + if (fConfigComputeTPCpostCalib) { auto calibList = fCCDB->getForTimeStamp(fConfigCcdbPathTPC.value, bc.timestamp()); VarManager::SetCalibrationObject(VarManager::kTPCElectronMean, calibList->FindObject("mean_map_electron")); @@ -292,7 +305,7 @@ struct DQBarrelTrackSelection { // material correction for track propagation // o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT; - o2::base::Propagator::MatCorrType noMatCorr = o2::base::Propagator::MatCorrType::USEMatCorrNONE; + // o2::base::Propagator::MatCorrType noMatCorr = o2::base::Propagator::MatCorrType::USEMatCorrNONE; uint32_t filterMap = static_cast(0); uint32_t filterMapEMu = static_cast(0); @@ -309,7 +322,7 @@ struct DQBarrelTrackSelection { VarManager::FillTrack(track); // compute quantities which depend on the associated collision, such as DCA if (fPropTrack && (track.collisionId() != collision.globalIndex())) { - VarManager::FillTrackCollisionMatCorr(track, collision, noMatCorr, o2::base::Propagator::Instance()); + VarManager::FillTrackCollision(track, collision); } if (fConfigQA) { fHistMan->FillHistClass("TrackBarrel_BeforeCuts", VarManager::fgValues); @@ -342,12 +355,21 @@ struct DQBarrelTrackSelection { } } + void processSelectionTPCPID(Collisions const& collisions, aod::BCsWithTimestamps const& bcs, MyBarrelTracksTPCPID const& tracks, aod::TrackAssoc const& trackAssocs) + { + for (auto& collision : collisions) { + auto trackIdsThisCollision = trackAssocs.sliceBy(barrelTrackIndicesPerCollision, collision.globalIndex()); + runTrackSelection(collision, bcs, tracks, trackIdsThisCollision); + } + } + void processDummy(MyBarrelTracks&) { // do nothing } PROCESS_SWITCH(DQBarrelTrackSelection, processSelection, "Run barrel track selection", false); + PROCESS_SWITCH(DQBarrelTrackSelection, processSelectionTPCPID, "Run barrel track selection, just TPC PID (no TOF)", false); PROCESS_SWITCH(DQBarrelTrackSelection, processDummy, "Dummy function", false); }; @@ -360,6 +382,7 @@ struct DQMuonsSelection { Configurable fConfigCuts{"cfgMuonsCuts", "muonQualityCuts", "Comma separated list of ADDITIONAL muon track cuts"}; Configurable fConfigCutsForEMu{"cfgMuonsCutsForEMu", "muonQualityCuts", "Comma separated list of ADDITIONAL muon track cuts"}; Configurable fConfigQA{"cfgWithQA", false, "If true, fill QA histograms"}; + Configurable fConfigHistClasses{"cfgHistClasses", "muon", "If true, fill QA histograms"}; Configurable fPropMuon{"cfgPropMuon", false, "Propgate muon tracks through absorber"}; Configurable fConfigCcdbUrl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; Configurable geoPath{"geoPath", "GLO/Config/GeometryAligned", "Path of the geometry file"}; @@ -417,7 +440,7 @@ struct DQMuonsSelection { fCutHistNames.push_back(Form("Muon_%s", fTrackCuts[i].GetName())); } - DefineHistograms(fHistMan, cutNames.Data()); // define all histograms + DefineHistograms(fHistMan, cutNames.Data(), fConfigHistClasses.value); // define all histograms VarManager::SetUseVars(fHistMan->GetUsedVars()); // provide the list of required variables so that VarManager knows what to fill fOutputList.setObject(fHistMan->GetMainHistogramList()); } @@ -694,7 +717,7 @@ struct DQFilterPPTask { histNames += value; histNames += ";"; } - DefineHistograms(fHistMan, histNames.Data()); + DefineHistograms(fHistMan, histNames.Data(), "cepf"); VarManager::SetUseVars(fHistMan->GetUsedVars()); fOutputList.setObject(fHistMan->GetMainHistogramList()); } @@ -722,6 +745,8 @@ struct DQFilterPPTask { VarManager::ResetValues(0, VarManager::kNVars); VarManager::FillEvent(collision); // event properties could be needed for cuts or histogramming + std::vector> taggedCollisions(fNBarrelCuts + fNMuonCuts + fNElectronMuonCuts); // collisions corresponding to selected associations or to which selected tracks are assigned in AO2D + std::vector objCountersBarrel(fNBarrelCuts, 0); // init all counters to zero uint32_t pairingMask = 0; // in order to know which of the selections actually require pairing uint32_t pairFilter = 0; @@ -731,6 +756,11 @@ struct DQFilterPPTask { for (int i = 0; i < fNBarrelCuts; ++i) { if (trackAssoc.isDQBarrelSelected() & (static_cast(1) << i)) { objCountersBarrel[i] += 1; + taggedCollisions[i][collision.globalIndex()] = 1; // add the current associated collision to the map + auto t1 = trackAssoc.template track_as(); + if (t1.has_collision()) { + taggedCollisions[i][t1.collisionId()] = 1; // add the originally assigned collision to the map + } } } } @@ -742,6 +772,7 @@ struct DQFilterPPTask { pairingMask |= (static_cast(1) << i); } objCountersBarrel[i] = 0; // reset counters for selections where pairing is needed (count pairs instead) + taggedCollisions[i].clear(); // empty the list of tagged collisions if pairing is needed (so we count just events with pairs or containing selected pair legs) } } @@ -759,6 +790,7 @@ struct DQFilterPPTask { if (pairFilter == 0) { continue; } + // construct the pair and apply pair cuts VarManager::FillPair(t1, t2); // compute pair quantities for (int icut = 0; icut < fNBarrelCuts; icut++) { @@ -775,9 +807,17 @@ struct DQFilterPPTask { if (!fBarrelPairCuts[icut].IsSelected(VarManager::fgValues)) { continue; } + + taggedCollisions[icut][collision.globalIndex()] = 1; // add the originally assigned collision to the map + if (t1.has_collision()) { + taggedCollisions[icut][t1.collisionId()] = 1; // add the originally assigned collision to the map + } + if (t2.has_collision()) { + taggedCollisions[icut][t2.collisionId()] = 1; // add the originally assigned collision to the map + } + objCountersBarrel[icut] += 1; // count the pair if (fConfigQA) { // fill histograms if QA is enabled - // cout << "=========== filling pair for collision " << collision.globalIndex() << endl; fHistMan->FillHistClass(fBarrelPairHistNames[icut].Data(), VarManager::fgValues); } } @@ -792,6 +832,11 @@ struct DQFilterPPTask { for (int i = 0; i < fNMuonCuts; ++i) { if (muon.isDQMuonSelected() & (static_cast(1) << i)) { objCountersMuon[i] += 1; + taggedCollisions[i + fNBarrelCuts][collision.globalIndex()] = 1; // add the current associated collision to the map + auto t1 = muon.template fwdtrack_as(); + if (t1.has_collision()) { + taggedCollisions[i + fNBarrelCuts][t1.collisionId()] = 1; // add the originally assigned collision to the map + } } } } @@ -804,6 +849,7 @@ struct DQFilterPPTask { pairingMask |= (static_cast(1) << i); } objCountersMuon[i] = 0; // reset counters for selections where pairing is needed (count pairs instead) + taggedCollisions[i + fNBarrelCuts].clear(); // empty the list of tagged collisions if pairing is needed (so we count just events with pairs or containing selected pair legs) } } @@ -841,6 +887,15 @@ struct DQFilterPPTask { if (!fMuonPairCuts[icut].IsSelected(VarManager::fgValues)) { continue; } + + taggedCollisions[icut + fNBarrelCuts][collision.globalIndex()] = 1; // add the originally assigned collision to the map + if (t1.has_collision()) { + taggedCollisions[icut + fNBarrelCuts][t1.collisionId()] = 1; // add the originally assigned collision to the map + } + if (t2.has_collision()) { + taggedCollisions[icut + fNBarrelCuts][t2.collisionId()] = 1; // add the originally assigned collision to the map + } + objCountersMuon[icut] += 1; if (fConfigQA) { fHistMan->FillHistClass(fMuonPairHistNames[icut].Data(), VarManager::fgValues); @@ -892,6 +947,15 @@ struct DQFilterPPTask { if (!fElectronMuonPairCuts[icut].IsSelected(VarManager::fgValues)) { continue; } + + taggedCollisions[icut + fNBarrelCuts + fNMuonCuts][collision.globalIndex()] = 1; // add the originally assigned collision to the map + if (t1.has_collision()) { + taggedCollisions[icut + fNBarrelCuts + fNMuonCuts][t1.collisionId()] = 1; // add the originally assigned collision to the map + } + if (t2.has_collision()) { + taggedCollisions[icut + fNBarrelCuts + fNMuonCuts][t2.collisionId()] = 1; // add the originally assigned collision to the map + } + objCountersElectronMuon[icut] += 1; if (fConfigQA) { fHistMan->FillHistClass(fElectronMuonPairHistNames[icut].Data(), VarManager::fgValues); @@ -906,6 +970,8 @@ struct DQFilterPPTask { for (int i = 0; i < fNBarrelCuts; i++) { if (objCountersBarrel[i] >= fBarrelNreqObjs[i]) { filter |= (static_cast(1) << i); + } else { + taggedCollisions[i].clear(); } } } @@ -913,6 +979,8 @@ struct DQFilterPPTask { for (int i = 0; i < fNMuonCuts; i++) { if (objCountersMuon[i] >= fMuonNreqObjs[i]) { filter |= (static_cast(1) << (i + fNBarrelCuts)); + } else { + taggedCollisions[i + fNBarrelCuts].clear(); } } } @@ -920,58 +988,13 @@ struct DQFilterPPTask { for (int i = 0; i < fNElectronMuonCuts; i++) { if (objCountersElectronMuon[i] >= fElectronMuonNreqObjs[i]) { filter |= (static_cast(1) << (i + fNBarrelCuts + fNMuonCuts)); + } else { + taggedCollisions[i + fNBarrelCuts + fNMuonCuts].clear(); } } } - return filter; - } - Preslice trackIndicesPerCollision = track_association::collisionId; - Preslice muonIndicesPerCollision = track_association::collisionId; - - void processFilterPP(MyEventsSelected const& collisions, - aod::BCsWithTimestamps const& bcs, - MyBarrelTracksSelected const& tracks, - MyMuons const& muons, - MyBarrelTracksAssocSelected const& trackAssocs, MyMuonsAssocSelected const& muonAssocs) - { - fFiltersMap.clear(); - fCEFPfilters.clear(); - - cout << "------------------- filterPP, n assocs barrel/muon :: " << trackAssocs.size() << " / " << muonAssocs.size() << endl; - - uint64_t barrelMask = 0; - for (int i = 0; i < fNBarrelCuts; i++) { - barrelMask |= (static_cast(1) << i); - } - uint64_t muonMask = 0; - for (int i = fNBarrelCuts; i < fNBarrelCuts + fNMuonCuts; i++) { - muonMask |= (static_cast(1) << i); - } - // Loop over collisions - // int event = 0; - int eventsFired = 0; - for (const auto& collision : collisions) { - // skip those that do not pass our selection - if (!collision.isDQEventSelected()) { - // event++; - continue; - } - // group the tracks and muons for this collision - auto groupedTrackIndices = trackAssocs.sliceBy(trackIndicesPerCollision, collision.globalIndex()); - auto groupedMuonIndices = muonAssocs.sliceBy(muonIndicesPerCollision, collision.globalIndex()); - - uint64_t filter = 0; - // if there is at least one track or muon, run the filtering function and compute triggers - if (groupedTrackIndices.size() > 0 || groupedMuonIndices.size() > 0) { - filter = runFilterPP(collision, bcs, tracks, muons, groupedTrackIndices, groupedMuonIndices); - } - if (filter == 0) { - // event++; - continue; - } - eventsFired++; - // compute the CEPF decisions (this is done in a spacial setup with exactly kNTriggersDQ configured triggers) + if (filter > 0) { std::vector decisions(kNTriggersDQ, false); // event decisions to be transmitted to CEFP for (int i = 0; i < fNBarrelCuts; i++) { if (filter & (static_cast(1) << i)) { @@ -1008,59 +1031,58 @@ struct DQFilterPPTask { } } - // Now check through the associated tracks / fwdtracks and assign the same filter to their parent collisions - // This is needed since if a collision was selected because of a track association from a neighbouring collision, - // then one needs to select also that collision in order to be able to redo the pairing at analysis time. - if (filter & barrelMask) { - for (auto& a : groupedTrackIndices) { - auto t = a.template track_as(); - if (!t.has_collision()) { - continue; - } - auto tColl = t.collisionId(); - if (tColl == collision.globalIndex()) { // track from this collision, nothing to do - continue; - } else { - if (fFiltersMap.find(tColl) == fFiltersMap.end()) { - fFiltersMap[tColl] = filter; - fCEFPfilters[tColl] = decisions; - } else { // this collision was already fired, possible via collision - track association; add as an OR the new decisions - fFiltersMap[tColl] |= filter; - for (int i = 0; i < kNTriggersDQ; i++) { - if (decisions[i]) { - fCEFPfilters[tColl][i] = true; - } - } - } + // Go through the list of tagged collisions and add also those to the maps + // The reason is that in the tagged collisions we include also those collisions which did not fired the trigger conditions, but they contain + // tracks which in other associations contributed to fired triggers in other events. + for (int iTrig = 0; iTrig < fNBarrelCuts + fNMuonCuts + fNElectronMuonCuts; iTrig++) { + for (auto& [collId, aValue] : taggedCollisions[iTrig]) { + if (fFiltersMap.find(collId) == fFiltersMap.end()) { + fFiltersMap[collId] = (static_cast(1) << iTrig); + std::vector decisionsAdds(kNTriggersDQ, false); // event decisions to be transmitted to CEFP + decisionsAdds[iTrig] = true; + fCEFPfilters[collId] = decisionsAdds; + } else { // this collision was already fired, possible via collision - track association; add as an OR the new decisions + fFiltersMap[collId] |= (static_cast(1) << iTrig); + fCEFPfilters[collId][iTrig] = true; } } } - // Do the same for muons - if (filter & muonMask) { - for (auto& a : groupedMuonIndices) { - auto t = a.template fwdtrack_as(); - if (!t.has_collision()) { - continue; - } - auto tColl = t.collisionId(); - if (tColl == collision.globalIndex()) { // track from this collision, nothing to do - continue; - } else { - if (fFiltersMap.find(tColl) == fFiltersMap.end()) { - fFiltersMap[tColl] = filter; - fCEFPfilters[tColl] = decisions; - } else { // this collision was already fired, possible via collision - track association; add as an OR the new decisions - fFiltersMap[tColl] |= filter; - for (int i = 0; i < kNTriggersDQ; i++) { - if (decisions[i]) { - fCEFPfilters[tColl][i] = true; - } - } - } - } - } + } + return filter; + } + + Preslice trackIndicesPerCollision = track_association::collisionId; + Preslice muonIndicesPerCollision = track_association::collisionId; + + void processFilterPP(MyEventsSelected const& collisions, + aod::BCsWithTimestamps const& bcs, + MyBarrelTracksTPCPID const& tracks, + MyMuons const& muons, + MyBarrelTracksAssocSelected const& trackAssocs, MyMuonsAssocSelected const& muonAssocs) + { + fFiltersMap.clear(); + fCEFPfilters.clear(); + + // Loop over collisions + int eventsFired = 0; + for (const auto& collision : collisions) { + // skip those that do not pass our selection + if (!collision.isDQEventSelected()) { + continue; } - // event++; + // group the tracks and muons for this collision + auto groupedTrackIndices = trackAssocs.sliceBy(trackIndicesPerCollision, collision.globalIndex()); + auto groupedMuonIndices = muonAssocs.sliceBy(muonIndicesPerCollision, collision.globalIndex()); + + uint64_t filter = 0; + // if there is at least one track or muon, run the filtering function and compute triggers + if (groupedTrackIndices.size() > 0 || groupedMuonIndices.size() > 0) { + filter = runFilterPP(collision, bcs, tracks, muons, groupedTrackIndices, groupedMuonIndices); + } + if (filter == 0) { + continue; + } + eventsFired++; } // At this point, we have all the non-null decisions for all collisions. @@ -1105,8 +1127,6 @@ struct DQFilterPPTask { fFiltersMap.clear(); fCEFPfilters.clear(); - cout << "------------------- filterPP, n assocs muon :: " << muonAssocs.size() << endl; - uint64_t muonMask = 0; for (int i = 0; i < fNMuonCuts; i++) { muonMask |= (static_cast(1) << i); @@ -1239,7 +1259,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) adaptAnalysisTask(cfgc)}; } -void DefineHistograms(HistogramManager* histMan, TString histClasses) +void DefineHistograms(HistogramManager* histMan, TString histClasses, TString subgroups) { // // Define here the histograms for all the classes required in analysis. @@ -1250,26 +1270,26 @@ void DefineHistograms(HistogramManager* histMan, TString histClasses) histMan->AddHistClass(classStr.Data()); if (classStr.Contains("Event")) { - dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "event", "trigger,vtxPbPb"); + dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "event", subgroups.Data()); } if (classStr.Contains("Track")) { - dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "track", "its,tpcpid,dca"); + dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "track", subgroups.Data()); } if (classStr.Contains("Muon") && !classStr.Contains("Electron")) { - dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "track", "muon"); + dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "track", subgroups.Data()); } if (classStr.Contains("Pairs")) { if (classStr.Contains("Barrel")) { - dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "pair", "vertexing-barrel"); + dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "pair", subgroups.Data()); } if (classStr.Contains("Forward")) { - dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "pair", "dimuon,vertexing-forward"); + dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "pair", subgroups.Data()); } if (classStr.Contains("ElectronMuon")) { - dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "pair", "electronmuon"); + dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "pair", subgroups.Data()); } } } diff --git a/PWGDQ/Tasks/taskFwdTrackPid.cxx b/PWGDQ/Tasks/taskFwdTrackPid.cxx index 7a135596d56..7fb6e8e3310 100644 --- a/PWGDQ/Tasks/taskFwdTrackPid.cxx +++ b/PWGDQ/Tasks/taskFwdTrackPid.cxx @@ -139,13 +139,11 @@ struct taskFwdTrackPid { template void runFwdTrackPid(TEvent const& event, Muons const& muons, MftTracks const& mftTracks) { - uint32_t mcDecision = 0; - fwdPidAllList.reserve(1); for (const auto& muon : muons) { if (muon.has_matchMFTTrack() && muon.trackType() == 0 && TMath::Abs(muon.fwdDcaX()) < fConfigMaxDCA && TMath::Abs(muon.fwdDcaY()) < fConfigMaxDCA) { auto mftTrack = muon.template matchMFTTrack_as(); - fwdPidAllList(muon.trackType(), event.posX(), event.posY(), event.posZ(), event.numContrib(), muon.pt(), muon.eta(), muon.phi(), muon.sign(), mftTrack.mftClusterSizesAndTrackFlags(), muon.fwdDcaX(), muon.fwdDcaY(), muon.chi2MatchMCHMID(), muon.chi2MatchMCHMFT(), mcDecision); + fwdPidAllList(muon.trackType(), event.posX(), event.posY(), event.posZ(), event.numContrib(), muon.pt(), muon.eta(), muon.phi(), muon.sign(), mftTrack.mftClusterSizesAndTrackFlags(), muon.fwdDcaX(), muon.fwdDcaY(), muon.chi2MatchMCHMID(), muon.chi2MatchMCHMFT(), 0); } } if constexpr (TMatchedOnly == false) { @@ -157,7 +155,7 @@ struct taskFwdTrackPid { continue; } } - fwdPidAllList(4, event.posX(), event.posY(), event.posZ(), event.numContrib(), mftTrack.pt(), mftTrack.eta(), mftTrack.phi(), mftTrack.sign(), mftTrack.mftClusterSizesAndTrackFlags(), mftTrack.fwdDcaX(), mftTrack.fwdDcaY(), -999, -999, mcDecision); + fwdPidAllList(4, event.posX(), event.posY(), event.posZ(), event.numContrib(), mftTrack.pt(), mftTrack.eta(), mftTrack.phi(), mftTrack.sign(), mftTrack.mftClusterSizesAndTrackFlags(), mftTrack.fwdDcaX(), mftTrack.fwdDcaY(), -999, -999, 0); } } } @@ -169,31 +167,16 @@ struct taskFwdTrackPid { { fwdPidAllList.reserve(1); for (const auto& muon : muons) { - uint32_t mcDecision = 0; - int isig = 0; - for (auto sig = fRecMCSignals.begin(); sig != fRecMCSignals.end(); sig++, isig++) { - if ((*sig).CheckSignal(false, muon.reducedMCTrack())) { - mcDecision |= (uint32_t(1) << isig); - } - } - if (muon.has_matchMFTTrack() && muon.trackType() == 0 && TMath::Abs(muon.fwdDcaX()) < fConfigMaxDCA && TMath::Abs(muon.fwdDcaY()) < fConfigMaxDCA) { auto mftTrack = muon.template matchMFTTrack_as(); - fwdPidAllList(muon.trackType(), event.posX(), event.posY(), event.posZ(), event.numContrib(), muon.pt(), muon.eta(), muon.phi(), muon.sign(), mftTrack.mftClusterSizesAndTrackFlags(), muon.fwdDcaX(), muon.fwdDcaY(), muon.chi2MatchMCHMID(), muon.chi2MatchMCHMFT(), mcDecision); + fwdPidAllList(muon.trackType(), event.posX(), event.posY(), event.posZ(), event.numContrib(), muon.pt(), muon.eta(), muon.phi(), muon.sign(), mftTrack.mftClusterSizesAndTrackFlags(), muon.fwdDcaX(), muon.fwdDcaY(), muon.chi2MatchMCHMID(), muon.chi2MatchMCHMFT(), muon.mcReducedFlags()); } } if constexpr (TMatchedOnly == false) { for (const auto& mftTrack : mftTracks) { - uint32_t mcDecision = 0; - int isig = 0; - for (auto sig = fRecMCSignals.begin(); sig != fRecMCSignals.end(); sig++, isig++) { - if ((*sig).CheckSignal(false, mftTrack.reducedMCTrack())) { - mcDecision |= (uint32_t(1) << isig); - } - } if (TMath::Abs(mftTrack.fwdDcaX()) < fConfigMaxDCA && TMath::Abs(mftTrack.fwdDcaY()) < fConfigMaxDCA) { - fwdPidAllList(4, event.posX(), event.posY(), event.posZ(), event.numContrib(), mftTrack.pt(), mftTrack.eta(), mftTrack.phi(), mftTrack.sign(), mftTrack.mftClusterSizesAndTrackFlags(), mftTrack.fwdDcaX(), mftTrack.fwdDcaY(), -999, -999, mcDecision); + fwdPidAllList(4, event.posX(), event.posY(), event.posZ(), event.numContrib(), mftTrack.pt(), mftTrack.eta(), mftTrack.phi(), mftTrack.sign(), mftTrack.mftClusterSizesAndTrackFlags(), mftTrack.fwdDcaX(), mftTrack.fwdDcaY(), -999, -999, mftTrack.mcReducedFlags()); } } } @@ -206,19 +189,10 @@ struct taskFwdTrackPid { for (auto& mctrack : groupedMCTracks) { VarManager::FillTrackMC(groupedMCTracks, mctrack); - for (auto& sig : fGenMCSignals) { - if (sig.GetNProngs() != 1) { // NOTE: 1-prong signals required - continue; - } - bool checked = false; - if constexpr (soa::is_soa_filtered_v) { - auto mctrack_raw = groupedMCTracks.rawIteratorAt(mctrack.globalIndex()); - checked = sig.CheckSignal(false, mctrack_raw); - } else { - checked = sig.CheckSignal(false, mctrack); - } - if (checked) { - fHistMan->FillHistClass(Form("MCTruthGen_%s", sig.GetName()), VarManager::fgValues); + int isig = 0; + for (auto sig = fGenMCSignals.begin(); sig != fGenMCSignals.end(); sig++, isig++) { + if (mctrack.mcReducedFlags() & (static_cast(1) << isig)) { + fHistMan->FillHistClass(Form("MCTruthGen_%s", sig->GetName()), VarManager::fgValues); } } } @@ -287,8 +261,7 @@ void DefineHistograms(HistogramManager* histMan, TString histClasses) if (classStr.Contains("MCTruthGen")) { dqhistograms::DefineHistograms(histMan, objArray->At(iclass)->GetName(), "mctruth"); histMan->AddHistogram(objArray->At(iclass)->GetName(), "Pt_Rapidity", "MC generator p_{T}, y distribution", false, 120, 0.0, 30.0, VarManager::kMCPt, 150, 2.5, 4.0, VarManager::kMCY); - histMan->AddHistogram(objArray->At(iclass)->GetName(), "Eta", "MC generator #eta distribution", false, 200, 2.5, 4.0, VarManager::kMCEta); - // histMan->AddHistogram(objArray->At(iclass)->GetName(), "Rapidity", "MC generator y distribution", false, 150, 2.5, 4.0, VarManager::kMCY); + histMan->AddHistogram(objArray->At(iclass)->GetName(), "Eta", "MC generator #eta distribution", false, 200, -5.0, 5.0, VarManager::kMCEta); histMan->AddHistogram(objArray->At(iclass)->GetName(), "Phi", "MC generator #varphi distribution", false, 50, 0.0, 2. * TMath::Pi(), VarManager::kMCPhi); } diff --git a/PWGEM/PhotonMeson/Tasks/HeavyNeutralMeson.cxx b/PWGEM/PhotonMeson/Tasks/HeavyNeutralMeson.cxx index 98e620e413b..56ef57a6d79 100644 --- a/PWGEM/PhotonMeson/Tasks/HeavyNeutralMeson.cxx +++ b/PWGEM/PhotonMeson/Tasks/HeavyNeutralMeson.cxx @@ -17,7 +17,6 @@ /// #include -#include #include #include @@ -27,6 +26,7 @@ #include "TRandom3.h" #include "PWGEM/PhotonMeson/Utils/HNMUtilities.h" +#include "PWGJE/DataModel/EMCALMatchedCollisions.h" #include "Common/DataModel/PIDResponse.h" #include "Common/DataModel/PIDResponseITS.h" @@ -51,14 +51,14 @@ using namespace o2::aod::pwgem::photonmeson; namespace o2::aod { using MyBCs = soa::Join; -using MyCollisions = soa::Join; +using MyCollisions = soa::Join; using MyCollision = MyCollisions::iterator; using SelectedTracks = soa::Join; } // namespace o2::aod -namespace HNMPID +namespace hnm { enum TracksPID { @@ -74,91 +74,109 @@ enum PIDLimits { kTPCMin, kNPIDLimits }; -const std::vector SpeciesName{"pion"}; // ToDo include charged pions -const std::vector PtCutsName{"Pt min", "Pt max", "P TOF thres"}; -const std::vector PidCutsName{"TPC min", "TPC max", "TPCTOF max", "ITS min", "ITS max"}; +const std::vector speciesName{"pion"}; // ToDo include charged pions +const std::vector pTCutsName{"Pt min", "Pt max", "P TOF thres"}; +const std::vector pidCutsName{"TPC min", "TPC max", "TPCTOF max", "ITS min", "ITS max"}; const float pidcutsTable[kNTracksPID][kNPIDLimits]{{-4.f, 4.f, 4.f, -99.f, 99.f}}; const float ptcutsTable[kNTracksPID][3]{{0.35f, 6.f, 0.75f}}; -const float TPCNClustersMin[1][kNTracksPID]{{80.0f}}; -const float ITSNClustersMin[1][kNTracksPID]{{4}}; +const float nClusterMinTPC[1][kNTracksPID]{{80.0f}}; +const float nClusterMinITS[1][kNTracksPID]{{4}}; -} // namespace HNMPID +} // namespace hnm struct HeavyNeutralMeson { - // PID selections - Configurable> ConfPIDCuts{"ConfPIDCuts", {HNMPID::pidcutsTable[0], HNMPID::kNTracksPID, HNMPID::kNPIDLimits, HNMPID::SpeciesName, HNMPID::PidCutsName}, "Heavy Neutral Meson PID nsigma selections"}; - Configurable> ConfPtCuts{"ConfPtCuts", {HNMPID::ptcutsTable[0], HNMPID::kNTracksPID, 3, HNMPID::SpeciesName, HNMPID::PtCutsName}, "Heavy Neutral Meson pT selections"}; - Configurable ConfTrkEta{"ConfTrkEta", 0.9, "Eta"}; - Configurable> ConfTPCNClustersMin{"ConfTPCNClustersMin", {HNMPID::TPCNClustersMin[0], 1, HNMPID::kNTracksPID, std::vector{"TPCNClusMin"}, HNMPID::SpeciesName}, "Mininum of TPC Clusters"}; - Configurable ConfTrkTPCfCls{"ConfTrkTPCfCls", 0.83, "Minimum fraction of crossed rows over findable clusters"}; - Configurable ConfTrkTPCcRowsMin{"ConfTrkTPCcRowsMin", 70, "Minimum number of crossed TPC rows"}; - Configurable ConfTrkTPCsClsSharedFrac{"ConfTrkTPCsClsSharedFrac", 1.f, "Fraction of shared TPC clusters"}; - Configurable> ConfTrkITSnclsMin{"ConfTrkITSnclsMin", {HNMPID::ITSNClustersMin[0], 1, HNMPID::kNTracksPID, std::vector{"Cut"}, HNMPID::SpeciesName}, "Minimum number of ITS clusters"}; - Configurable ConfTrkDCAxyMax{"ConfTrkDCAxyMax", 0.15, "Maximum DCA_xy"}; - Configurable ConfTrkDCAzMax{"ConfTrkDCAzMax", 0.3, "Maximum DCA_z"}; - Configurable ConfTrkMaxChi2PerClusterTPC{"ConfTrkMaxChi2PerClusterTPC", 4.0f, "Minimal track selection: max allowed chi2 per TPC cluster"}; // 4.0 is default of global tracks on 20.01.2023 - Configurable ConfTrkMaxChi2PerClusterITS{"ConfTrkMaxChi2PerClusterITS", 36.0f, "Minimal track selection: max allowed chi2 per ITS cluster"}; // 36.0 is default of global tracks on 20.01.2023 - Configurable ConfEvtSelectZvtx{"ConfEvtSelectZvtx", true, "Event selection includes max. z-Vertex"}; - Configurable ConfEvtZvtx{"ConfEvtZvtx", 10.f, "Evt sel: Max. z-Vertex (cm)"}; - Configurable ConfEvtOfflineCheck{"ConfEvtOfflineCheck", false, "Evt sel: check for offline selection"}; + // --------------------------------> Configurables <------------------------------------ + // - Event selection cuts + // - Track selection cuts + // - Cluster shifts + // - HNM mass selection windows + // ------------------------------------------------------------------------------------- + // ---> Event selection + Configurable confEvtSelectZvtx{"confEvtSelectZvtx", true, "Event selection includes max. z-Vertex"}; + Configurable confEvtZvtx{"confEvtZvtx", 10.f, "Evt sel: Max. z-Vertex (cm)"}; + Configurable confEvtRequireSel8{"confEvtRequireSel8", false, "Evt sel: check for offline selection (sel8)"}; + + // ---> Track selection + Configurable> cfgPtCuts{"cfgPtCuts", {hnm::ptcutsTable[0], 1, 3, hnm::speciesName, hnm::pTCutsName}, "Track pT selections"}; + Configurable cfgTrkEta{"cfgTrkEta", 0.9, "Eta"}; + Configurable> cfgTPCNClustersMin{"cfgTPCNClustersMin", {hnm::nClusterMinTPC[0], 1, 1, std::vector{"TPCNClusMin"}, hnm::speciesName}, "Mininum of TPC Clusters"}; + Configurable cfgTrkTPCfCls{"cfgTrkTPCfCls", 0.83, "Minimum fraction of crossed rows over findable clusters"}; + Configurable cfgTrkTPCcRowsMin{"cfgTrkTPCcRowsMin", 70, "Minimum number of crossed TPC rows"}; + Configurable cfgTrkTPCsClsSharedFrac{"cfgTrkTPCsClsSharedFrac", 1.f, "Fraction of shared TPC clusters"}; + Configurable> cfgTrkITSnclsMin{"cfgTrkITSnclsMin", {hnm::nClusterMinITS[0], 1, 1, std::vector{"Cut"}, hnm::speciesName}, "Minimum number of ITS clusters"}; + Configurable cfgTrkDCAxyMax{"cfgTrkDCAxyMax", 0.15, "Maximum DCA_xy"}; + Configurable cfgTrkDCAzMax{"cfgTrkDCAzMax", 0.3, "Maximum DCA_z"}; + Configurable cfgTrkMaxChi2PerClusterTPC{"cfgTrkMaxChi2PerClusterTPC", 4.0f, "Minimal track selection: max allowed chi2 per TPC cluster"}; // 4.0 is default of global tracks on 20.01.2023 + Configurable cfgTrkMaxChi2PerClusterITS{"cfgTrkMaxChi2PerClusterITS", 36.0f, "Minimal track selection: max allowed chi2 per ITS cluster"}; // 36.0 is default of global tracks on 20.01.2023 + + Configurable> cfgPIDCuts{"cfgPIDCuts", {hnm::pidcutsTable[0], 1, hnm::kNPIDLimits, hnm::speciesName, hnm::pidCutsName}, "Femtopartner PID nsigma selections"}; // PID selections + + // ---> Configurables to allow for a shift in eta/phi of EMCal clusters to better align with extrapolated TPC tracks + Configurable cfgDoEMCShift{"cfgDoEMCShift", false, "Apply SM-wise shift in eta and phi to EMCal clusters to align with TPC tracks"}; + Configurable> cfgEMCEtaShift{"cfgEMCEtaShift", {0.f}, "values for SM-wise shift in eta to be added to EMCal clusters to align with TPC tracks"}; + Configurable> cfgEMCPhiShift{"cfgEMCPhiShift", {0.f}, "values for SM-wise shift in phi to be added to EMCal clusters to align with TPC tracks"}; + static const int nSMs = 20; + std::array emcEtaShift = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + std::array emcPhiShift = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + + // ---> Shift the omega/eta' mass based on the difference of the reconstructed mass of the pi0/eta to its PDG mass to reduce smearing caused by EMCal/PCM in photon measurement Configurable cfgHNMMassCorrection{"cfgHNMMassCorrection", 1, "Use GG PDG mass to correct HNM mass (0 = off, 1 = subDeltaPi0, 2 = subLambda)"}; - static constexpr float defaultMassWindows[4] = {0.1, 0.17, 0.5, 6.}; - Configurable> massWindowLightNeutralMesons{"massWindowLightNeutralMesons", {defaultMassWindows, 4, {"pi0_min", "pi0_max", "eta_min", "eta_max"}}, "Mass window for selected light neutral meson decay daughters"}; - Configurable ConfDoEMCShift{"ConfDoEMCShift", false, "Apply SM-wise shift in eta and phi to EMCal clusters to align with TPC tracks"}; - Configurable> ConfEMCEtaShift{"ConfEMCEtaShift", {0.f}, "values for SM-wise shift in eta to be added to EMCal clusters to align with TPC tracks"}; - Configurable> ConfEMCPhiShift{"ConfEMCPhiShift", {0.f}, "values for SM-wise shift in phi to be added to EMCal clusters to align with TPC tracks"}; - std::array EMCEtaShift = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; - std::array EMCPhiShift = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + + // ---> Mass windows for the selection of heavy neutral mesons (also based on mass of their light neutral meson decay daughter) + static constexpr float DefaultMassWindows[2][4] = {{0., 0.4, 0.6, 1.}, {0.4, 0.8, 0.8, 1.2}}; + Configurable> cfgMassWindowOmega{"cfgMassWindowOmega", {DefaultMassWindows[0], 4, {"pi0_min", "pi0_max", "omega_min", "omega_max"}}, "Mass window for selected omegas and their decay pi0"}; + Configurable> cfgMassWindowEtaPrime{"cfgMassWindowEtaPrime", {DefaultMassWindows[1], 4, {"eta_min", "eta_max", "etaprime_min", "etaprime_max"}}, "Mass window for selected eta' and their decay eta"}; + + Configurable cfgMinGGPtOverHNMPt{"cfgMinGGPtOverHNMPt", 0., "Minimum ratio of the pT of the gamma gamma pair over the pT of the HNM (can be used to increase the S/B)"}; + + HistogramRegistry mHistManager{"HeavyNeutralMesonHistograms", {}, OutputObjHandlingPolicy::AnalysisObject}; + + // Prepare vectors for different species + std::vector vGGs; + std::vector vHNMs; + std::vector etaPrimeEMC, etaPrimePCM, omegaEMC, omegaPCM, proton, antiproton, deuteron, antideuteron, pion, antipion; + float mMassProton = constants::physics::MassProton; + float mMassDeuteron = constants::physics::MassDeuteron; + float mMassOmega = 0.782; + float mMassEtaPrime = 0.957; + float mMassPionCharged = constants::physics::MassPionCharged; + + Preslice perCollisionPCM = aod::v0photonkf::collisionId; + Preslice perCollisionEMC = aod::skimmedcluster::collisionId; template - bool isSelectedTrack(T const& track, HNMPID::TracksPID partSpecies) + bool isSelectedTrack(T const& track, hnm::TracksPID partSpecies) { - const auto pT = track.pt(); - const auto eta = track.eta(); - const auto tpcNClsF = track.tpcNClsFound(); - const auto tpcRClsC = track.tpcCrossedRowsOverFindableCls(); - const auto tpcNClsC = track.tpcNClsCrossedRows(); - const auto tpcNClsSFrac = track.tpcFractionSharedCls(); - const auto itsNCls = track.itsNCls(); - const auto dcaXY = track.dcaXY(); - const auto dcaZ = track.dcaZ(); - - if (pT < ConfPtCuts->get(partSpecies, "Pt min")) { + if (track.pt() < cfgPtCuts->get(partSpecies, "Pt min")) return false; - } - if (pT > ConfPtCuts->get(partSpecies, "Pt max")) { + if (track.pt() > cfgPtCuts->get(partSpecies, "Pt max")) return false; - } - if (std::abs(eta) > ConfTrkEta) { + if (std::abs(track.eta()) > cfgTrkEta) return false; - } - if (tpcNClsF < ConfTPCNClustersMin->get("TPCNClusMin", partSpecies)) { + if (track.tpcNClsFound() < cfgTPCNClustersMin->get("TPCNClusMin", partSpecies)) return false; - } - if (tpcRClsC < ConfTrkTPCfCls) { + if (track.tpcCrossedRowsOverFindableCls() < cfgTrkTPCfCls) return false; - } - if (tpcNClsC < ConfTrkTPCcRowsMin) { + if (track.tpcNClsCrossedRows() < cfgTrkTPCcRowsMin) return false; - } - if (tpcNClsSFrac > ConfTrkTPCsClsSharedFrac) { + if (track.tpcFractionSharedCls() > cfgTrkTPCsClsSharedFrac) return false; - } - if (itsNCls < ConfTrkITSnclsMin->get(static_cast(0), partSpecies)) { + if (track.itsNCls() < cfgTrkITSnclsMin->get(static_cast(0), partSpecies)) return false; - } - if (std::abs(dcaXY) > ConfTrkDCAxyMax) { + if (std::abs(track.dcaXY()) > cfgTrkDCAxyMax) return false; - } - if (std::abs(dcaZ) > ConfTrkDCAzMax) { + if (std::abs(track.dcaZ()) > cfgTrkDCAzMax) + return false; + if (track.tpcChi2NCl() > cfgTrkMaxChi2PerClusterTPC) + return false; + if (track.itsChi2NCl() > cfgTrkMaxChi2PerClusterITS) return false; - } return true; } template - bool isSelectedTrackPID(T const& track, HNMPID::TracksPID partSpecies) + bool isSelectedTrackPID(T const& track, hnm::TracksPID partSpecies) { bool isSelected = false; @@ -168,22 +186,15 @@ struct HeavyNeutralMeson { float nSigmaTrackTPCTOF = std::sqrt(std::pow(nSigmaTrackTPC, 2) + std::pow(nSigmaTrackTOF, 2)); - // check if track is selected - auto TPCmin = ConfPIDCuts->get(partSpecies, HNMPID::kTPCMin); - auto TPCmax = ConfPIDCuts->get(partSpecies, HNMPID::kTPCMax); - auto TPCTOFmax = ConfPIDCuts->get(partSpecies, HNMPID::kTPCTOF); - auto ITSmin = ConfPIDCuts->get(partSpecies, HNMPID::kITSmin); - auto ITSmax = ConfPIDCuts->get(partSpecies, HNMPID::kITSmax); - - if (track.p() <= ConfPtCuts->get(partSpecies, "P TOF thres")) { - if (nSigmaTrackTPC > TPCmin && - nSigmaTrackTPC < TPCmax && - nSigmaTrackITS > ITSmin && - nSigmaTrackITS < ITSmax) { + if (track.p() <= cfgPtCuts->get(partSpecies, "P TOF thres")) { + if (nSigmaTrackTPC > cfgPIDCuts->get(partSpecies, hnm::kTPCMin) && + nSigmaTrackTPC < cfgPIDCuts->get(partSpecies, hnm::kTPCMax) && + nSigmaTrackITS > cfgPIDCuts->get(partSpecies, hnm::kITSmin) && + nSigmaTrackITS < cfgPIDCuts->get(partSpecies, hnm::kITSmax)) { isSelected = true; } } else { - if (nSigmaTrackTPCTOF < TPCTOFmax) { + if (nSigmaTrackTPCTOF < cfgPIDCuts->get(partSpecies, hnm::kTPCTOF)) { isSelected = true; } } @@ -193,324 +204,289 @@ struct HeavyNeutralMeson { template bool isSelectedEvent(T const& col) { - if (ConfEvtSelectZvtx && std::abs(col.posZ()) > ConfEvtZvtx) { + if (confEvtSelectZvtx && std::abs(col.posZ()) > confEvtZvtx) { return false; } - if (ConfEvtOfflineCheck && !col.sel8()) { + if (confEvtRequireSel8 && !col.sel8()) { return false; } return true; } - // Circumvent missing of different phi mappings, enforce [0, 2 * M_PI] - // Tracks have domain [0, 2 * M_PI] - // TLorentVectors have domain [-M_PI, M_PI] - double translatePhi(double phi) - { - if (phi < 0) { - phi += 2 * M_PI; // Add 2 pi to make it positive - } - return phi; - } - - HistogramRegistry mHistManager{"HeavyNeutralMesonHistograms", {}, OutputObjHandlingPolicy::AnalysisObject}; - - std::vector vGGs; - std::vector vHNMs; - - emcal::Geometry* emcalGeom; - - // Prepare vectors for different species - std::vector pion, antipion; - void init(InitContext const&) { - emcalGeom = emcal::Geometry::GetInstanceFromRunNumber(300000); - auto hCollisionCounter = mHistManager.add("Event/hCollisionCounter", "Number of collisions;;#bf{#it{N}_{Coll}}", HistType::kTH1F, {{6, -0.5, 5.5}}); - hCollisionCounter->GetXaxis()->SetBinLabel(1, "all"); - hCollisionCounter->GetXaxis()->SetBinLabel(2, "kTVXinEMC"); - hCollisionCounter->GetXaxis()->SetBinLabel(3, "PCM #omega"); - hCollisionCounter->GetXaxis()->SetBinLabel(4, "EMC #omega"); - hCollisionCounter->GetXaxis()->SetBinLabel(5, "PCM #eta'"); - hCollisionCounter->GetXaxis()->SetBinLabel(6, "EMC #eta'"); - mHistManager.add("Event/nGGs", "Number of (selected) #gamma#gamma paris;#bf{#it{N}_{#gamma#gamma}};#bf{#it{N}_{#gamma#gamma}^{selected}}", HistType::kTH2F, {{51, -0.5, 50.5}, {51, -0.5, 50.5}}); - mHistManager.add("Event/nTracks", "Number of tracks;#bf{N_{tracks}};#bf{#it{N}_{Coll}}", HistType::kTH1F, {{51, -0.5, 50.5}}); mHistManager.add("Event/nHeavyNeutralMesons", "Number of (selected) HNM candidates;#bf{#it{N}_{HNM}};#bf{#it{N}_{HNM}^{selected}}", HistType::kTH2F, {{51, -0.5, 50.5}, {51, -0.5, 50.5}}); mHistManager.add("Event/nClustersVsV0s", "Number of clusters and V0s in the collision;#bf{#it{N}_{clusters}};#bf{#it{N}_{V0s}}", HistType::kTH2F, {{26, -0.5, 25.5}, {26, -0.5, 25.5}}); + mHistManager.add("Event/nEMCalEvents", "Number of collisions with a certain combination of EMCal triggers;;#bf{#it{N}_{collisions}}", HistType::kTH1F, {{5, -0.5, 4.5}}); + std::vector nEventTitles = {"Cells & kTVXinEMC", "Cells & L0", "Cells & !kTVXinEMC & !L0", "!Cells & kTVXinEMC", "!Cells & L0"}; + for (size_t iBin = 0; iBin < nEventTitles.size(); iBin++) + mHistManager.get(HIST("Event/nEMCalEvents"))->GetXaxis()->SetBinLabel(iBin + 1, nEventTitles[iBin].data()); + mHistManager.add("Event/fMultiplicityBefore", "Multiplicity of all processed events;#bf{#it{N}_{tracks}};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, 0, 500}}); + mHistManager.add("Event/fMultiplicityAfter", "Multiplicity after event cuts;#bf{#it{N}_{tracks}};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, 0, 500}}); + mHistManager.add("Event/fZvtxBefore", "Zvtx of all processed events;#bf{z_{vtx} (cm)};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, -15, 15}}); + mHistManager.add("Event/fZvtxAfter", "Zvtx after event cuts;#bf{z_{vtx} (cm)};#bf{#it{N}_{collisions}}", HistType::kTH1F, {{500, -15, 15}}); mHistManager.add("GG/invMassVsPt_PCM", "Invariant mass and pT of gg candidates;#bf{#it{M}_{#gamma#gamma}};#bf{#it{pT}_{#gamma#gamma}}", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}}); mHistManager.add("GG/invMassVsPt_PCMEMC", "Invariant mass and pT of gg candidates;#bf{#it{M}_{#gamma#gamma}};#bf{#it{pT}_{#gamma#gamma}}", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}}); mHistManager.add("GG/invMassVsPt_EMC", "Invariant mass and pT of gg candidates;#bf{#it{M}_{#gamma#gamma}};#bf{#it{pT}_{#gamma#gamma}}", HistType::kTH2F, {{400, 0., 0.8}, {250, 0., 25.}}); - mHistManager.add("Omega/invMassVsPt_PCM", "Invariant mass and pT of omega meson candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.6, 1.}, {250, 0., 25.}}); - mHistManager.add("Omega/invMassVsPt_PCMEMC", "Invariant mass and pT of omega meson candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.6, 1.}, {250, 0., 25.}}); - mHistManager.add("Omega/invMassVsPt_EMC", "Invariant mass and pT of omega meson candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.6, 1.}, {250, 0., 25.}}); - - mHistManager.add("EtaPrime/invMassVsPt_PCM", "Invariant mass and pT of eta' candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.8, 1.2}, {250, 0., 25.}}); - mHistManager.add("EtaPrime/invMassVsPt_PCMEMC", "Invariant mass and pT of eta' candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.8, 1.2}, {250, 0., 25.}}); - mHistManager.add("EtaPrime/invMassVsPt_EMC", "Invariant mass and pT of eta' candidates;#bf{#it{M}_{#pi^{+}#pi^{-}#gamma#gamma}};#bf{#it{pT}_{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH2F, {{400, 0.8, 1.2}, {250, 0., 25.}}); - - // event cuts - mHistManager.add("EventCuts/fMultiplicityBefore", "Multiplicity of all processed events;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - mHistManager.add("EventCuts/fMultiplicityAfter", "Multiplicity after event cuts;Mult;Entries", HistType::kTH1F, {{500, 0, 500}}); - mHistManager.add("EventCuts/fZvtxBefore", "Zvtx of all processed events;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); - mHistManager.add("EventCuts/fZvtxAfter", "Zvtx after event cuts;Z_{vtx};Entries", HistType::kTH1F, {{500, -15, 15}}); + // Momentum correlations p vs p_TPC + mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationPos", "fMomCorrelation;#bf{#it{p} (GeV/#it{c})};#bf{#it{p}_{TPC} (GeV/#it{c})}", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); + mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationNeg", "fMomCorrelation;#bf{#it{p} (GeV/#it{c})};#bf{#it{p}_{TPC} (GeV/#it{c})}", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - // mom correlations p vs pTPC - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationPos", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationNeg", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); - - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsPion", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{1000, 0.0f, 20.0f}, {1000, 0.0f, 20.0f}}}); - mHistManager.add("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiPion", "fMomCorrelation;p (GeV/c);p_{TPC} (GeV/c)", {HistType::kTH2F, {{1000, 0.0f, 20.0f}, {1000, 0.0f, 20.0f}}}); - - // all tracks - mHistManager.add("TrackCuts/TracksBefore/fPtTrackBefore", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/TracksBefore/fEtaTrackBefore", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/TracksBefore/fPhiTrackBefore", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); + // All tracks + mHistManager.add("TrackCuts/TracksBefore/fPtTrackBefore", "Transverse momentum of all processed tracks;#bf{#it{p}_{T} (GeV/#it{c})};#bf{#it{N}_{tracks}}", HistType::kTH1F, {{500, 0, 10}}); + mHistManager.add("TrackCuts/TracksBefore/fEtaTrackBefore", "Pseudorapidity of all processed tracks;#eta;#bf{#it{N}_{tracks}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("TrackCuts/TracksBefore/fPhiTrackBefore", "Azimuthal angle of all processed tracks;#phi;#bf{#it{N}_{tracks}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); // TPC signal - mHistManager.add("TrackCuts/TPCSignal/fTPCSignal", "TPCSignal;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalP", "TPCSignalP;p (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - // TPC signal anti - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAnti", "TPCSignal;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAntiP", "TPCSignalP;p (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); - - // TPC signal particles - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalPion", "fTPCSignalPion;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAntiPion", "fTPCSignalAntiPion;p_{TPC} (GeV/c);dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); - // pions - mHistManager.add("TrackCuts/Pion/fPPion", "Momentum of Pions at PV;p (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/Pion/fPTPCPion", "Momentum of Pions at TPC inner wall;p_{TPC} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/Pion/fPtPion", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/Pion/fMomCorPionDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - mHistManager.add("TrackCuts/Pion/fMomCorPionRatio", "Momentum correlation;p_{reco} (GeV/c); p_{TPC} - p_{reco} / p_{reco}", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - mHistManager.add("TrackCuts/Pion/fEtaPion", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/Pion/fPhiPion", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/Pion/fNsigmaTPCvsPPion", "NSigmaTPC Pion;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Pion/fNsigmaTOFvsPPion", "NSigmaTOF Pion;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Pion/fNsigmaTPCTOFvsPPion", "NSigmaTPCTOF Pion;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/Pion/fNsigmaTPCvsPPionP", "NSigmaTPC Pion P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Pion/fNsigmaTOFvsPPionP", "NSigmaTOF Pion P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/Pion/fNsigmaTPCTOFvsPPionP", "NSigmaTPCTOF Pion P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/Pion/fDCAxyPion", "fDCAxy Pion;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/Pion/fDCAzPion", "fDCAz Pion;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/Pion/fTPCsClsPion", "fTPCsCls Pion;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/Pion/fTPCcRowsPion", "fTPCcRows Pion;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/Pion/fTrkTPCfClsPion", "fTrkTPCfCls Pion;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - mHistManager.add("TrackCuts/Pion/fTPCnclsPion", "fTPCncls Pion;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // anti-pions - mHistManager.add("TrackCuts/AntiPion/fPtAntiPion", "Transverse momentum of all processed tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/AntiPion/fMomCorAntiPionDif", "Momentum correlation;p_{reco} (GeV/c); (p_{TPC} - p_{reco}) (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); - mHistManager.add("TrackCuts/AntiPion/fMomCorAntiPionRatio", "Momentum correlation;p_{reco} (GeV/c); |p_{TPC} - p_{reco}| (GeV/c)", {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); - mHistManager.add("TrackCuts/AntiPion/fEtaAntiPion", "Pseudorapidity of all processed tracks;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/AntiPion/fPhiAntiPion", "Azimuthal angle of all processed tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPion", "NSigmaTPC AntiPion;p_{TPC} (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPion", "NSigmaTOF AntiPion;p_{TPC} (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPion", "NSigmaTPCTOF AntiPion;p_{TPC} (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPionP", "NSigmaTPC AntiPion P;p (GeV/c);n#sigma_{TPC}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPionP", "NSigmaTOF AntiPion P;p (GeV/c);n#sigma_{TOF}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); - mHistManager.add("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPionP", "NSigmaTPCTOF AntiPion P;p (GeV/c);n#sigma_{comb}", {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); - - mHistManager.add("TrackCuts/AntiPion/fDCAxyAntiPion", "fDCAxy AntiPion;DCA_{XY};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/AntiPion/fDCAzAntiPion", "fDCAz AntiPion;DCA_{Z};Entries", HistType::kTH1F, {{500, -0.5f, 0.5f}}); - mHistManager.add("TrackCuts/AntiPion/fTPCsClsAntiPion", "fTPCsCls AntiPion;TPC Shared Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/AntiPion/fTPCcRowsAntiPion", "fTPCcRows AntiPion;TPC Crossed Rows;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - mHistManager.add("TrackCuts/AntiPion/fTrkTPCfClsAntiPion", "fTrkTPCfCls AntiPion;TPC Findable/CrossedRows;Entries", HistType::kTH1F, {{500, 0.0f, 3.0f}}); - mHistManager.add("TrackCuts/AntiPion/fTPCnclsAntiPion", "fTPCncls AntiPion;TPC Clusters;Entries", HistType::kTH1F, {{163, -1.0f, 162.0f}}); - - // HNM - // omega QA - // daughter pos before - mHistManager.add("TrackCuts/HMN/PosDaughter/fInvMass", "Invariant mass HMN Pos Daugh;M_{#pi};Entries", HistType::kTH1F, {{500, 0, 1}}); - mHistManager.add("TrackCuts/HMN/PosDaughter/fPt", "Transverse momentum HMN Pos Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/PosDaughter/fEta", "HMN Pos Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/PosDaughter/fPhi", "Azimuthal angle of HMN Pos Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // daughter neg before - mHistManager.add("TrackCuts/HMN/NegDaughter/fInvMass", "Invariant mass HMN Neg Daugh;M_{#pi};Entries", HistType::kTH1F, {{500, 0, 1}}); - mHistManager.add("TrackCuts/HMN/NegDaughter/fPt", "Transverse momentum HMN Neg Daugh tracks;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/NegDaughter/fEta", "HMN Neg Daugh Eta;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/NegDaughter/fPhi", "Azimuthal angle of HMN Neg Daugh tracks;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - // HMNCand tracks before - mHistManager.add("TrackCuts/HMN/fInvMass_tracks", "Invariant mass HMNCand;M_{#pi#pi#gammg#gamma};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/fInvMassPt_tracks", "Invariant mass HMNCand;M_{#pi^{+}#pi^{-}};pT_{#pi^{+}#pi^{-}}", HistType::kTH2F, {{5000, 0, 5}, {500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/fPt_tracks", "Transverse momentum HMNCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/fEta_tracks", "Pseudorapidity of HMNCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/fPhi_tracks", "Azimuthal angle of HMNCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/HMN/PCM/fInvMass", "Invariant mass HMNCand;M_{#pi#pi#gammg#gamma};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/PCM/fPt", "Transverse momentum HMNCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/PCM/fEta", "Pseudorapidity of HMNCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/PCM/fPhi", "Azimuthal angle of HMNCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/HMN/EMC/fInvMass", "Invariant mass HMNCand;M_{#pi#pi#gammg#gamma};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/EMC/fPt", "Transverse momentum HMNCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/EMC/fEta", "Pseudorapidity of HMNCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/EMC/fPhi", "Azimuthal angle of HMNCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - mHistManager.add("TrackCuts/HMN/PCMEMC/fInvMass", "Invariant mass HMNCand;M_{#pi#pi#gammg#gamma};Entries", HistType::kTH1F, {{5000, 0, 5}}); - mHistManager.add("TrackCuts/HMN/PCMEMC/fPt", "Transverse momentum HMNCand;p_{T} (GeV/c);Entries", HistType::kTH1F, {{500, 0, 10}}); - mHistManager.add("TrackCuts/HMN/PCMEMC/fEta", "Pseudorapidity of HMNCand;#eta;Entries", HistType::kTH1F, {{500, -2, 2}}); - mHistManager.add("TrackCuts/HMN/PCMEMC/fPhi", "Azimuthal angle of HMNCand;#phi;Entries", HistType::kTH1F, {{720, 0, TMath::TwoPi()}}); - - if (ConfDoEMCShift.value) { - for (int iSM = 0; iSM < 20; iSM++) { - EMCEtaShift[iSM] = ConfEMCEtaShift.value[iSM]; - EMCPhiShift[iSM] = ConfEMCPhiShift.value[iSM]; - LOG(info) << "SM-wise shift in eta/phi for SM " << iSM << ": " << EMCEtaShift[iSM] << " / " << EMCPhiShift[iSM]; + mHistManager.add("TrackCuts/TPCSignal/fTPCSignalTPCP", "TPCSignal;#bf{#it{p}_{TPC} (GeV/#it{c})};dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); + mHistManager.add("TrackCuts/TPCSignal/fTPCSignal", "TPCSignalP;#bf{#it{p} (GeV/#it{c})};dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); + // TPC signal antiparticles (negative charge) + mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAntiTPCP", "TPCSignal;#bf{#it{p}_{TPC} (GeV/#it{c})};dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); + mHistManager.add("TrackCuts/TPCSignal/fTPCSignalAnti", "TPCSignalP;#bf{#it{p} (GeV/#it{c})};dE/dx", {HistType::kTH2F, {{500, 0.0f, 6.0f}, {2000, -100.f, 500.f}}}); + + const int nTrackSpecies = 2; // x2 because of anti particles + const char* particleSpecies[nTrackSpecies] = {"Pion", "AntiPion"}; + const char* particleSpeciesLatex[nTrackSpecies] = {"#pi^{+}", "#pi^{-}"}; + + for (int iParticle = 0; iParticle < nTrackSpecies; iParticle++) { + mHistManager.add(Form("TrackCuts/TracksBefore/fMomCorrelationAfterCuts%s", particleSpecies[iParticle]), "fMomCorrelation;#bf{#it{p} (GeV/#it{c})};#bf{#it{p}_{TPC} (GeV/#it{c})}", {HistType::kTH2F, {{500, 0.0f, 20.0f}, {500, 0.0f, 20.0f}}}); + mHistManager.add(Form("TrackCuts/TPCSignal/fTPCSignal%s", particleSpecies[iParticle]), Form("%s TPC energy loss;#bf{#it{p}_{TPC}^{%s} (GeV/#it{c})};dE/dx", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{500, 0.0f, 6.0f}, {10000, -100.f, 500.f}}}); + + mHistManager.add(Form("TrackCuts/%s/fP", particleSpecies[iParticle]), Form("%s momentum at PV;#bf{#it{p}^{%s} (GeV/#it{c})};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, 0, 10}}); + mHistManager.add(Form("TrackCuts/%s/fPt", particleSpecies[iParticle]), Form("%s transverse momentum;#bf{#it{p}_{T}^{%s} (GeV/#it{c})};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, 0, 10}}); + mHistManager.add(Form("TrackCuts/%s/fMomCorDif", particleSpecies[iParticle]), Form("Momentum correlation;#bf{#it{p}^{%s} (GeV/#it{c})};#bf{#it{p}_{TPC}^{%s} - #it{p}^{%s} (GeV/#it{c})}", particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{500, 0, 10}, {600, -3, 3}}}); + mHistManager.add(Form("TrackCuts/%s/fMomCorRatio", particleSpecies[iParticle]), Form("Relative momentum correlation;#bf{#it{p}^{%s} (GeV/#it{c})};#bf{#it{p}_{TPC}^{%s} - #it{p}^{%s} / #it{p}^{%s}}", particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{500, 0, 10}, {200, -1, 1}}}); + mHistManager.add(Form("TrackCuts/%s/fEta", particleSpecies[iParticle]), Form("%s pseudorapidity distribution;#eta;#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add(Form("TrackCuts/%s/fPhi", particleSpecies[iParticle]), Form("%s azimuthal angle distribution;#phi;#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + + mHistManager.add(Form("TrackCuts/%s/fNsigmaTPCvsTPCP", particleSpecies[iParticle]), Form("NSigmaTPC %s;#bf{#it{p}_{TPC}^{%s} (GeV/#it{c})};n#sigma_{TPC}^{%s}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaTOFvsTPCP", particleSpecies[iParticle]), Form("NSigmaTOF %s;#bf{#it{p}_{TPC}^{%s} (GeV/#it{c})};n#sigma_{TOF}^{%s}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaTPCTOFvsTPCP", particleSpecies[iParticle]), Form("NSigmaTPCTOF %s;#bf{#it{p}_{TPC}^{%s} (GeV/#it{c})};n#sigma_{comb}^{%s}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaITSvsP", particleSpecies[iParticle]), Form("NSigmaITS %s;#bf{#it{p}^{%s} (GeV/#it{c})};n#sigma_{ITS}^{%s}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaTPCvsP", particleSpecies[iParticle]), Form("NSigmaTPC %s P;#bf{#it{p}^{%s} (GeV/#it{c})};n#sigma_{TPC}^{%s}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaTOFvsP", particleSpecies[iParticle]), Form("NSigmaTOF %s P;#bf{#it{p}^{%s} (GeV/#it{c})};n#sigma_{TOF}^{%s}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, -10.f, 10.f}}}); + mHistManager.add(Form("TrackCuts/%s/fNsigmaTPCTOFvsP", particleSpecies[iParticle]), Form("NSigmaTPCTOF %s P;#bf{#it{p}^{%s} (GeV/#it{c})};n#sigma_{comb}^{%s}", particleSpecies[iParticle], particleSpeciesLatex[iParticle], particleSpeciesLatex[iParticle]), {HistType::kTH2F, {{100, 0.0f, 10.0f}, {100, 0.f, 10.f}}}); + + mHistManager.add(Form("TrackCuts/%s/fDCAxy", particleSpecies[iParticle]), Form("fDCAxy %s;#bf{DCA_{xy}};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, -0.5f, 0.5f}}); + mHistManager.add(Form("TrackCuts/%s/fDCAz", particleSpecies[iParticle]), Form("fDCAz %s;#bf{DCA_{z}};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, -0.5f, 0.5f}}); + mHistManager.add(Form("TrackCuts/%s/fTPCsCls", particleSpecies[iParticle]), Form("fTPCsCls %s;#bf{TPC Shared Clusters};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{163, -1.0f, 162.0f}}); + mHistManager.add(Form("TrackCuts/%s/fTPCcRows", particleSpecies[iParticle]), Form("fTPCcRows %s;#bf{TPC Crossed Rows};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{163, -1.0f, 162.0f}}); + mHistManager.add(Form("TrackCuts/%s/fTrkTPCfCls", particleSpecies[iParticle]), Form("fTrkTPCfCls %s;#bf{TPC Findable/CrossedRows};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{500, 0.0f, 3.0f}}); + mHistManager.add(Form("TrackCuts/%s/fTPCncls", particleSpecies[iParticle]), Form("fTPCncls %s;#bf{TPC Clusters};#bf{#it{N}^{%s}}", particleSpecies[iParticle], particleSpeciesLatex[iParticle]), HistType::kTH1F, {{163, -1.0f, 162.0f}}); + } + + // --> HNM QA + // pi+ daughter + mHistManager.add("HNM/Before/PosDaughter/fInvMass", "Invariant mass HMN Pos Daugh;#bf{#it{M}^{#pi^{+}} (GeV/#it{c}^{2})};#bf{#it{N}^{#pi^{+}}}", HistType::kTH1F, {{200, 0, 0.2}}); + mHistManager.add("HNM/Before/PosDaughter/fPt", "Transverse momentum HMN Pos Daugh tracks;#bf{#it{p}_{T} (GeV/#it{c})};#bf{#it{N}^{#pi^{+}}}", HistType::kTH1F, {{500, 0, 10}}); + mHistManager.add("HNM/Before/PosDaughter/fEta", "HMN Pos Daugh Eta;#eta;#bf{#it{N}^{#pi^{+}}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("HNM/Before/PosDaughter/fPhi", "Azimuthal angle of HMN Pos Daugh tracks;#phi;#bf{#it{N}^{#pi^{+}}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + // pi- daughter + mHistManager.add("HNM/Before/NegDaughter/fInvMass", "Invariant mass HMN Neg Daugh;#bf{#it{M}^{#pi^{-}} (GeV/#it{c}^{2})};#bf{#it{N}^{#pi^{-}}}", HistType::kTH1F, {{200, 0, 0.2}}); + mHistManager.add("HNM/Before/NegDaughter/fPt", "Transverse momentum HMN Neg Daugh tracks;#bf{#it{p}_{T} (GeV/#it{c})};#bf{#it{N}^{#pi^{-}}}", HistType::kTH1F, {{500, 0, 10}}); + mHistManager.add("HNM/Before/NegDaughter/fEta", "HMN Neg Daugh Eta;#eta;#bf{#it{N}^{#pi^{-}}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("HNM/Before/NegDaughter/fPhi", "Azimuthal angle of HMN Neg Daugh tracks;#phi;#bf{#it{N}^{#pi^{-}}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + // Properties of the pi+pi- pair + mHistManager.add("HNM/Before/PiPlPiMi/fInvMassVsPt", "Invariant mass and pT of #pi^+pi^- pairs;#bf{#it{M}^{#pi^{+}#pi^{-}} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#pi^{+}#pi^{-}} (GeV/#it{c})}", HistType::kTH2F, {{400, 0.2, 1.}, {250, 0., 25.}}); + mHistManager.add("HNM/Before/PiPlPiMi/fEta", "Pseudorapidity of HMNCand;#eta;#bf{#it{N}^{#pi^{+}#pi^{-}}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("HNM/Before/PiPlPiMi/fPhi", "Azimuthal angle of HMNCand;#phi;#bf{#it{N}^{#pi^{+}#pi^{-}}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + + for (const auto& BeforeAfterString : {"Before", "After"}) { + for (const auto& iHNM : {"Omega", "EtaPrime"}) { + for (const auto& MethodString : {"PCM", "EMC"}) { + mHistManager.add(Form("HNM/%s/%s/%s/fInvMassVsPt", BeforeAfterString, iHNM, MethodString), "Invariant mass and pT of heavy neutral meson candidates;#bf{#it{M}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c})}", HistType::kTH2F, {{600, 0.6, 1.2}, {250, 0., 25.}}); + mHistManager.add(Form("HNM/%s/%s/%s/fEta", BeforeAfterString, iHNM, MethodString), "Pseudorapidity of HNM candidate;#eta;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add(Form("HNM/%s/%s/%s/fPhi", BeforeAfterString, iHNM, MethodString), "Azimuthal angle of HNM candidate;#phi;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + } + } + } + mHistManager.add("HNM/Before/Omega/PCMEMC/fInvMassVsPt", "Invariant mass and pT of omega meson candidates;#bf{#it{M}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c})}", HistType::kTH2F, {{600, 0.6, 1.2}, {250, 0., 25.}}); + mHistManager.add("HNM/Before/Omega/PCMEMC/fEta", "Pseudorapidity of HMNCand;#eta;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("HNM/Before/Omega/PCMEMC/fPhi", "Azimuthal angle of HMNCand;#phi;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + mHistManager.add("HNM/Before/EtaPrime/PCMEMC/fInvMassVsPt", "Invariant mass and pT of eta' meson candidates;#bf{#it{M}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c}^{2})};#bf{#it{p}_{T}^{#pi^{+}#pi^{-}#gamma#gamma} (GeV/#it{c})}", HistType::kTH2F, {{600, 0.8, 1.2}, {250, 0., 25.}}); + mHistManager.add("HNM/Before/EtaPrime/PCMEMC/fEta", "Pseudorapidity of HMNCand;#eta;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{500, -2, 2}}); + mHistManager.add("HNM/Before/EtaPrime/PCMEMC/fPhi", "Azimuthal angle of HMNCand;#phi;#bf{#it{N}^{#pi^{+}#pi^{-}#gamma#gamma}}", HistType::kTH1F, {{720, 0, constants::math::TwoPI}}); + + if (cfgDoEMCShift.value) { + for (int iSM = 0; iSM < nSMs; iSM++) { + emcEtaShift[iSM] = cfgEMCEtaShift.value[iSM]; + emcPhiShift[iSM] = cfgEMCPhiShift.value[iSM]; + LOG(info) << "SM-wise shift in eta/phi for SM " << iSM << ": " << emcEtaShift[iSM] << " / " << emcPhiShift[iSM]; } } } - Preslice perCollision_pcm = aod::v0photonkf::collisionId; - Preslice perCollision_emc = aod::skimmedcluster::collisionId; void process(aod::MyCollision const& collision, aod::MyBCs const&, aod::SkimEMCClusters const& clusters, aod::V0PhotonsKF const& v0s, aod::SelectedTracks const& tracks) { // inlcude ITS PID information auto tracksWithItsPid = soa::Attach(tracks); - mHistManager.fill(HIST("Event/hCollisionCounter"), 0.); - // QA all evts - mHistManager.fill(HIST("EventCuts/fMultiplicityBefore"), collision.multNTracksPV()); - mHistManager.fill(HIST("EventCuts/fZvtxBefore"), collision.posZ()); + mHistManager.fill(HIST("Event/fMultiplicityBefore"), collision.multNTracksPV()); + mHistManager.fill(HIST("Event/fZvtxBefore"), collision.posZ()); // Ensure evts are consistent with Sel8 and Vtx-z selection - if (!isSelectedEvent(collision)) { + if (!isSelectedEvent(collision)) return; - } // QA accepted evts - mHistManager.fill(HIST("EventCuts/fMultiplicityAfter"), collision.multNTracksPV()); - mHistManager.fill(HIST("EventCuts/fZvtxAfter"), collision.posZ()); + mHistManager.fill(HIST("Event/fMultiplicityAfter"), collision.multNTracksPV()); + mHistManager.fill(HIST("Event/fZvtxAfter"), collision.posZ()); // clean vecs - // Pions for HNM pion.clear(); antipion.clear(); vHNMs.clear(); // vGGs vector is cleared in reconstructGGs. - if (collision.foundBC_as().alias_bit(kTVXinEMC)) { - mHistManager.fill(HIST("Event/hCollisionCounter"), 1.); - } - - auto v0sInThisCollision = v0s.sliceBy(perCollision_pcm, collision.globalIndex()); - auto clustersInThisCollision = clusters.sliceBy(perCollision_emc, collision.globalIndex()); - + // ---------------------------------> EMCal event QA <---------------------------------- + // - Fill Event/nEMCalEvents histogram for EMCal event QA + // ------------------------------------------------------------------------------------- + bool bcHasEMCCells = collision.isemcreadout(); + bool iskTVXinEMC = collision.foundBC_as().alias_bit(kTVXinEMC); + bool isL0Triggered = collision.foundBC_as().alias_bit(kEMC7) || collision.foundBC_as().alias_bit(kEG1) || collision.foundBC_as().alias_bit(kEG2); + + if (bcHasEMCCells && iskTVXinEMC) + mHistManager.fill(HIST("Event/nEMCalEvents"), 0); + if (bcHasEMCCells && isL0Triggered) + mHistManager.fill(HIST("Event/nEMCalEvents"), 1); + if (bcHasEMCCells && !iskTVXinEMC && !isL0Triggered) + mHistManager.fill(HIST("Event/nEMCalEvents"), 2); + if (!bcHasEMCCells && iskTVXinEMC) + mHistManager.fill(HIST("Event/nEMCalEvents"), 3); + if (!bcHasEMCCells && isL0Triggered) + mHistManager.fill(HIST("Event/nEMCalEvents"), 4); + + // --------------------------------> Process Photons <---------------------------------- + // - Slice clusters and V0s by collision ID to get the ones in this collision + // - Store the clusters and V0s in the vGammas vector + // - Reconstruct gamma-gamma pairs + // ------------------------------------------------------------------------------------- + auto v0sInThisCollision = v0s.sliceBy(perCollisionPCM, collision.globalIndex()); + auto clustersInThisCollision = clusters.sliceBy(perCollisionEMC, collision.globalIndex()); mHistManager.fill(HIST("Event/nClustersVsV0s"), clustersInThisCollision.size(), v0sInThisCollision.size()); - mHistManager.fill(HIST("Event/nTracks"), tracksWithItsPid.size()); std::vector vGammas; - hnmutilities::storeGammasInVector(clustersInThisCollision, v0sInThisCollision, vGammas, EMCEtaShift, EMCPhiShift); + hnmutilities::storeGammasInVector(clustersInThisCollision, v0sInThisCollision, vGammas, emcEtaShift, emcPhiShift); hnmutilities::reconstructGGs(vGammas, vGGs); vGammas.clear(); processGGs(vGGs); - bool isPion = false; - + // ------------------------------> Loop over all tracks <------------------------------- + // - Sort them into vectors based on PID ((anti)protons, (anti)deuterons, (anti)pions) + // - Fill QA histograms for all tracks and per particle species + // ------------------------------------------------------------------------------------- for (const auto& track : tracksWithItsPid) { - // General QA mHistManager.fill(HIST("TrackCuts/TracksBefore/fPtTrackBefore"), track.pt()); mHistManager.fill(HIST("TrackCuts/TracksBefore/fEtaTrackBefore"), track.eta()); mHistManager.fill(HIST("TrackCuts/TracksBefore/fPhiTrackBefore"), track.phi()); - // Fill PID info - if (track.sign() > 0) { - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignal"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalP"), track.p(), track.tpcSignal()); + if (track.sign() > 0) { // All particles (positive electric charge) + mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalTPCP"), track.tpcInnerParam(), track.tpcSignal()); + mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignal"), track.p(), track.tpcSignal()); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationPos"), track.p(), track.tpcInnerParam()); } - if (track.sign() < 0) { - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAnti"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiP"), track.p(), track.tpcSignal()); + if (track.sign() < 0) { // All anti-particles (negative electric charge) + mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiTPCP"), track.tpcInnerParam(), track.tpcSignal()); + mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAnti"), track.p(), track.tpcSignal()); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationNeg"), track.p(), track.tpcInnerParam()); } - isPion = (isSelectedTrackPID(track, HNMPID::kPion) && isSelectedTrack(track, HNMPID::kPion)); + // For each track, check if it fulfills track and PID criteria to be identified as a proton, deuteron or pion + bool isPion = (isSelectedTrackPID(track, hnm::kPion) && isSelectedTrack(track, hnm::kPion)); - if (isPion) { - if (track.sign() > 0) { // part - pion.emplace_back(track.pt(), track.eta(), track.phi(), o2::constants::physics::MassPionCharged); + if (track.sign() > 0) { // Positive charge -> Particles + if (isPion) { + pion.emplace_back(track.pt(), track.eta(), track.phi(), mMassPionCharged); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsPion"), track.p(), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalPion"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/Pion/fPPion"), track.p()); - mHistManager.fill(HIST("TrackCuts/Pion/fPTPCPion"), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/Pion/fPtPion"), track.pt()); - mHistManager.fill(HIST("TrackCuts/Pion/fMomCorPionDif"), track.p(), track.tpcInnerParam() - track.p()); - mHistManager.fill(HIST("TrackCuts/Pion/fMomCorPionRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - mHistManager.fill(HIST("TrackCuts/Pion/fEtaPion"), track.eta()); - mHistManager.fill(HIST("TrackCuts/Pion/fPhiPion"), track.phi()); - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCvsPPion"), track.tpcInnerParam(), track.tpcNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTOFvsPPion"), track.tpcInnerParam(), track.tofNSigmaPi()); + + mHistManager.fill(HIST("TrackCuts/Pion/fP"), track.p()); + mHistManager.fill(HIST("TrackCuts/Pion/fPt"), track.pt()); + mHistManager.fill(HIST("TrackCuts/Pion/fMomCorDif"), track.p(), track.tpcInnerParam() - track.p()); + mHistManager.fill(HIST("TrackCuts/Pion/fMomCorRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + mHistManager.fill(HIST("TrackCuts/Pion/fEta"), track.eta()); + mHistManager.fill(HIST("TrackCuts/Pion/fPhi"), track.phi()); + + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCvsTPCP"), track.tpcInnerParam(), track.tpcNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTOFvsTPCP"), track.tpcInnerParam(), track.tofNSigmaPi()); auto nSigmaTrackTPCTOF = std::sqrt(std::pow(track.tpcNSigmaPi(), 2) + std::pow(track.tofNSigmaPi(), 2)); - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCTOFvsPPion"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCvsPPionP"), track.p(), track.tpcNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTOFvsPPionP"), track.p(), track.tofNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCTOFvsPPionP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/Pion/fDCAxyPion"), track.dcaXY()); - mHistManager.fill(HIST("TrackCuts/Pion/fDCAzPion"), track.dcaZ()); - mHistManager.fill(HIST("TrackCuts/Pion/fTPCsClsPion"), track.tpcNClsShared()); - mHistManager.fill(HIST("TrackCuts/Pion/fTPCcRowsPion"), track.tpcNClsCrossedRows()); - mHistManager.fill(HIST("TrackCuts/Pion/fTrkTPCfClsPion"), track.tpcCrossedRowsOverFindableCls()); - mHistManager.fill(HIST("TrackCuts/Pion/fTPCnclsPion"), track.tpcNClsFound()); - } else { // antipart - antipion.emplace_back(track.pt(), track.eta(), track.phi(), o2::constants::physics::MassPionCharged); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCTOFvsTPCP"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaITSvsP"), track.p(), track.itsNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCvsP"), track.p(), track.tpcNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTOFvsP"), track.p(), track.tofNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/Pion/fNsigmaTPCTOFvsP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); + + mHistManager.fill(HIST("TrackCuts/Pion/fDCAxy"), track.dcaXY()); + mHistManager.fill(HIST("TrackCuts/Pion/fDCAz"), track.dcaZ()); + mHistManager.fill(HIST("TrackCuts/Pion/fTPCsCls"), track.tpcNClsShared()); + mHistManager.fill(HIST("TrackCuts/Pion/fTPCcRows"), track.tpcNClsCrossedRows()); + mHistManager.fill(HIST("TrackCuts/Pion/fTrkTPCfCls"), track.tpcCrossedRowsOverFindableCls()); + mHistManager.fill(HIST("TrackCuts/Pion/fTPCncls"), track.tpcNClsFound()); + } + } else { // Negative charge -> Anti-particles + if (isPion) { + antipion.emplace_back(track.pt(), track.eta(), track.phi(), mMassPionCharged); mHistManager.fill(HIST("TrackCuts/TracksBefore/fMomCorrelationAfterCutsAntiPion"), track.p(), track.tpcInnerParam()); - mHistManager.fill(HIST("TrackCuts/TPCSignal/fTPCSignalAntiPion"), track.tpcInnerParam(), track.tpcSignal()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fPtAntiPion"), track.pt()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fMomCorAntiPionDif"), track.p(), track.tpcInnerParam() - track.p()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fMomCorAntiPionRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fEtaAntiPion"), track.eta()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fPhiAntiPion"), track.phi()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPion"), track.tpcInnerParam(), track.tpcNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPion"), track.tpcInnerParam(), track.tofNSigmaPi()); + + mHistManager.fill(HIST("TrackCuts/AntiPion/fP"), track.p()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fPt"), track.pt()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fMomCorDif"), track.p(), track.tpcInnerParam() - track.p()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fMomCorRatio"), track.p(), (track.tpcInnerParam() - track.p()) / track.p()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fEta"), track.eta()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fPhi"), track.phi()); + + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCvsTPCP"), track.tpcInnerParam(), track.tpcNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTOFvsTPCP"), track.tpcInnerParam(), track.tofNSigmaPi()); auto nSigmaTrackTPCTOF = std::sqrt(std::pow(track.tpcNSigmaPi(), 2) + std::pow(track.tofNSigmaPi(), 2)); - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPion"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCvsPAntiPionP"), track.p(), track.tpcNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTOFvsPAntiPionP"), track.p(), track.tofNSigmaPi()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCTOFvsPAntiPionP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); - - mHistManager.fill(HIST("TrackCuts/AntiPion/fDCAxyAntiPion"), track.dcaXY()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fDCAzAntiPion"), track.dcaZ()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCsClsAntiPion"), track.tpcNClsShared()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCcRowsAntiPion"), track.tpcNClsCrossedRows()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fTrkTPCfClsAntiPion"), track.tpcCrossedRowsOverFindableCls()); - mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCnclsAntiPion"), track.tpcNClsFound()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCTOFvsTPCP"), track.tpcInnerParam(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaITSvsP"), track.p(), track.itsNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCvsP"), track.p(), track.tpcNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTOFvsP"), track.p(), track.tofNSigmaPi()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fNsigmaTPCTOFvsP"), track.p(), std::sqrt(std::pow(track.tpcNSigmaPi() - nSigmaTrackTPCTOF, 2) + std::pow(track.tofNSigmaPi() - nSigmaTrackTPCTOF, 2))); + + mHistManager.fill(HIST("TrackCuts/AntiPion/fDCAxy"), track.dcaXY()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fDCAz"), track.dcaZ()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCsCls"), track.tpcNClsShared()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCcRows"), track.tpcNClsCrossedRows()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fTrkTPCfCls"), track.tpcCrossedRowsOverFindableCls()); + mHistManager.fill(HIST("TrackCuts/AntiPion/fTPCncls"), track.tpcNClsFound()); } } } - // reconstruct HMN candidates + // -------------------------> Reconstruct HNM candidates <------------------------------ + // - Based on the previously filled (anti)pion vectors + // - Fill QA histograms for kinematics of the pions and their combinations + // ------------------------------------------------------------------------------------- for (const auto& posPion : pion) { for (const auto& negPion : antipion) { - hnmutilities::reconstructHeavyNeutralMesons(posPion, negPion, vGGs, vHNMs); - - ROOT::Math::PtEtaPhiMVector temp = posPion + negPion; - - mHistManager.fill(HIST("TrackCuts/HMN/fInvMass_tracks"), temp.M()); - mHistManager.fill(HIST("TrackCuts/HMN/fPt_tracks"), temp.pt()); - mHistManager.fill(HIST("TrackCuts/HMN/fEta_tracks"), temp.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/fPhi_tracks"), translatePhi(temp.phi())); - - mHistManager.fill(HIST("TrackCuts/HMN/PosDaughter/fInvMass"), posPion.M()); - mHistManager.fill(HIST("TrackCuts/HMN/PosDaughter/fPt"), posPion.pt()); - mHistManager.fill(HIST("TrackCuts/HMN/PosDaughter/fEta"), posPion.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/PosDaughter/fPhi"), translatePhi(posPion.phi())); - - mHistManager.fill(HIST("TrackCuts/HMN/NegDaughter/fInvMass"), negPion.M()); - mHistManager.fill(HIST("TrackCuts/HMN/NegDaughter/fPt"), negPion.pt()); - mHistManager.fill(HIST("TrackCuts/HMN/NegDaughter/fEta"), negPion.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/NegDaughter/fPhi"), translatePhi(negPion.phi())); + ROOT::Math::PtEtaPhiMVector vecPiPlPiMi = posPion + negPion; + hnmutilities::reconstructHeavyNeutralMesons(vecPiPlPiMi, vGGs, vHNMs); + + mHistManager.fill(HIST("HNM/Before/PiPlPiMi/fInvMassVsPt"), vecPiPlPiMi.M(), vecPiPlPiMi.pt()); + mHistManager.fill(HIST("HNM/Before/PiPlPiMi/fEta"), vecPiPlPiMi.eta()); + mHistManager.fill(HIST("HNM/Before/PiPlPiMi/fPhi"), RecoDecay::constrainAngle(vecPiPlPiMi.phi())); + + mHistManager.fill(HIST("HNM/Before/PosDaughter/fInvMass"), posPion.M()); + mHistManager.fill(HIST("HNM/Before/PosDaughter/fPt"), posPion.pt()); + mHistManager.fill(HIST("HNM/Before/PosDaughter/fEta"), posPion.eta()); + mHistManager.fill(HIST("HNM/Before/PosDaughter/fPhi"), RecoDecay::constrainAngle(posPion.phi())); + + mHistManager.fill(HIST("HNM/Before/NegDaughter/fInvMass"), negPion.M()); + mHistManager.fill(HIST("HNM/Before/NegDaughter/fPt"), negPion.pt()); + mHistManager.fill(HIST("HNM/Before/NegDaughter/fEta"), negPion.eta()); + mHistManager.fill(HIST("HNM/Before/NegDaughter/fPhi"), RecoDecay::constrainAngle(negPion.phi())); } } - processHNMs(vHNMs); // Contains QA of HMN properties + // ---------------------------> Process HNM candidates <-------------------------------- + // - Fill invMassVsPt histograms separated into HNM types (based on GG mass) and gamma reco method + // ------------------------------------------------------------------------------------- + processHNMs(vHNMs); } /// \brief Loop over the GG candidates, fill the mass/pt histograms and set the isPi0/isEta flags based on the reconstructed mass @@ -528,9 +504,9 @@ struct HeavyNeutralMeson { mHistManager.fill(HIST("GG/invMassVsPt_PCMEMC"), lightMeson->m(), lightMeson->pT()); } - if (lightMeson->m() > massWindowLightNeutralMesons->get("pi0_min") && lightMeson->m() < massWindowLightNeutralMesons->get("pi0_max")) { + if (lightMeson->m() > cfgMassWindowOmega->get("pi0_min") && lightMeson->m() < cfgMassWindowOmega->get("pi0_max")) { lightMeson->isPi0 = true; - } else if (lightMeson->m() > massWindowLightNeutralMesons->get("eta_min") && lightMeson->m() < massWindowLightNeutralMesons->get("eta_max")) { + } else if (lightMeson->m() > cfgMassWindowEtaPrime->get("eta_min") && lightMeson->m() < cfgMassWindowEtaPrime->get("eta_max")) { lightMeson->isEta = true; } else { vGGs.erase(vGGs.begin() + iGG); @@ -544,47 +520,74 @@ struct HeavyNeutralMeson { void processHNMs(std::vector& vHNMs) { int nHNMsBeforeMassCuts = vHNMs.size(); + for (unsigned int iHNM = 0; iHNM < vHNMs.size(); iHNM++) { auto heavyNeutralMeson = vHNMs.at(iHNM); - float massHNM = heavyNeutralMeson.m(cfgHNMMassCorrection); + if (heavyNeutralMeson.gg->reconstructionType == photonpair::kPCMPCM) { - if (heavyNeutralMeson.gg->isPi0) - mHistManager.fill(HIST("Omega/invMassVsPt_PCM"), massHNM, heavyNeutralMeson.pT()); - else if (heavyNeutralMeson.gg->isEta) - mHistManager.fill(HIST("EtaPrime/invMassVsPt_PCM"), massHNM, heavyNeutralMeson.pT()); - // QA - mHistManager.fill(HIST("TrackCuts/HMN/PCM/fInvMass"), massHNM); - mHistManager.fill(HIST("TrackCuts/HMN/PCM/fPt"), heavyNeutralMeson.pT()); - mHistManager.fill(HIST("TrackCuts/HMN/PCM/fEta"), heavyNeutralMeson.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/PCM/fPhi"), translatePhi(heavyNeutralMeson.phi())); + if (heavyNeutralMeson.gg->isPi0) { + mHistManager.fill(HIST("HNM/Before/Omega/PCM/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/Omega/PCM/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/Omega/PCM/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } else if (heavyNeutralMeson.gg->isEta) { + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCM/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCM/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCM/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } } else if (heavyNeutralMeson.gg->reconstructionType == photonpair::kEMCEMC) { - if (heavyNeutralMeson.gg->isPi0) - mHistManager.fill(HIST("Omega/invMassVsPt_EMC"), massHNM, heavyNeutralMeson.pT()); - else if (heavyNeutralMeson.gg->isEta) - mHistManager.fill(HIST("EtaPrime/invMassVsPt_EMC"), massHNM, heavyNeutralMeson.pT()); - // QA - mHistManager.fill(HIST("TrackCuts/HMN/EMC/fInvMass"), massHNM); - mHistManager.fill(HIST("TrackCuts/HMN/EMC/fPt"), heavyNeutralMeson.pT()); - mHistManager.fill(HIST("TrackCuts/HMN/EMC/fEta"), heavyNeutralMeson.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/EMC/fPhi"), translatePhi(heavyNeutralMeson.phi())); + if (heavyNeutralMeson.gg->isPi0) { + mHistManager.fill(HIST("HNM/Before/Omega/EMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/Omega/EMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/Omega/EMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } else if (heavyNeutralMeson.gg->isEta) { + mHistManager.fill(HIST("HNM/Before/EtaPrime/EMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/EMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/EMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } } else { - if (heavyNeutralMeson.gg->isPi0) - mHistManager.fill(HIST("Omega/invMassVsPt_PCMEMC"), massHNM, heavyNeutralMeson.pT()); - else if (heavyNeutralMeson.gg->isEta) - mHistManager.fill(HIST("EtaPrime/invMassVsPt_PCMEMC"), massHNM, heavyNeutralMeson.pT()); - // QA - mHistManager.fill(HIST("TrackCuts/HMN/PCMEMC/fInvMass"), massHNM); - mHistManager.fill(HIST("TrackCuts/HMN/PCMEMC/fPt"), heavyNeutralMeson.pT()); - mHistManager.fill(HIST("TrackCuts/HMN/PCMEMC/fEta"), heavyNeutralMeson.eta()); - mHistManager.fill(HIST("TrackCuts/HMN/PCMEMC/fPhi"), translatePhi(heavyNeutralMeson.phi())); + if (heavyNeutralMeson.gg->isPi0) { + mHistManager.fill(HIST("HNM/Before/Omega/PCMEMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/Omega/PCMEMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/Omega/PCMEMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } else if (heavyNeutralMeson.gg->isEta) { + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCMEMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCMEMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/Before/EtaPrime/PCMEMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } + } + + if (heavyNeutralMeson.gg->isPi0 && massHNM > cfgMassWindowOmega->get("omega_min") && massHNM < cfgMassWindowOmega->get("omega_max") && heavyNeutralMeson.gg->pT() / heavyNeutralMeson.pT() > cfgMinGGPtOverHNMPt) { + if (heavyNeutralMeson.gg->reconstructionType == photonpair::kPCMPCM) { + omegaPCM.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), RecoDecay::constrainAngle(heavyNeutralMeson.phi()), mMassOmega); + mHistManager.fill(HIST("HNM/After/Omega/PCM/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/After/Omega/PCM/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/After/Omega/PCM/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } else if (heavyNeutralMeson.gg->reconstructionType == photonpair::kEMCEMC) { + omegaEMC.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), RecoDecay::constrainAngle(heavyNeutralMeson.phi()), mMassOmega); + mHistManager.fill(HIST("HNM/After/Omega/EMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/After/Omega/EMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/After/Omega/EMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } + } else if (heavyNeutralMeson.gg->isEta && massHNM > cfgMassWindowEtaPrime->get("etaprime_min") && massHNM < cfgMassWindowEtaPrime->get("etaprime_max") && heavyNeutralMeson.gg->pT() / heavyNeutralMeson.pT() > cfgMinGGPtOverHNMPt) { + if (heavyNeutralMeson.gg->reconstructionType == photonpair::kPCMPCM) { + etaPrimePCM.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), RecoDecay::constrainAngle(heavyNeutralMeson.phi()), mMassEtaPrime); + mHistManager.fill(HIST("HNM/After/EtaPrime/PCM/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/After/EtaPrime/PCM/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/After/EtaPrime/PCM/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } else if (heavyNeutralMeson.gg->reconstructionType == photonpair::kEMCEMC) { + etaPrimeEMC.emplace_back(heavyNeutralMeson.pT(), heavyNeutralMeson.eta(), RecoDecay::constrainAngle(heavyNeutralMeson.phi()), mMassEtaPrime); + mHistManager.fill(HIST("HNM/After/EtaPrime/EMC/fInvMassVsPt"), massHNM, heavyNeutralMeson.pT()); + mHistManager.fill(HIST("HNM/After/EtaPrime/EMC/fEta"), heavyNeutralMeson.eta()); + mHistManager.fill(HIST("HNM/After/EtaPrime/EMC/fPhi"), RecoDecay::constrainAngle(heavyNeutralMeson.phi())); + } + } else { + vHNMs.erase(vHNMs.begin() + iHNM); + iHNM--; } } mHistManager.fill(HIST("Event/nHeavyNeutralMesons"), nHNMsBeforeMassCuts, vHNMs.size()); } }; -WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& cfgc) -{ - return WorkflowSpec{adaptAnalysisTask(cfgc)}; -} +WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } diff --git a/PWGEM/PhotonMeson/Utils/HNMUtilities.h b/PWGEM/PhotonMeson/Utils/HNMUtilities.h index c784fcabc97..bb985686285 100644 --- a/PWGEM/PhotonMeson/Utils/HNMUtilities.h +++ b/PWGEM/PhotonMeson/Utils/HNMUtilities.h @@ -36,11 +36,9 @@ #include "Common/DataModel/TrackSelectionTables.h" #include "EventFiltering/filterTables.h" -using namespace o2::aod::pwgem::photonmeson; - -// -------> Struct to store photons from EMC clusters or V0s namespace o2::aod::pwgem::photonmeson::hnmutilities { +// -------> Struct to store photons from EMC clusters or V0s struct Photon { Photon(float px, float py, float pz, bool isFromConversion) : px(px), py(py), pz(pz), pt(std::sqrt(px * px + py * py)), isFromConversion(isFromConversion) { @@ -125,12 +123,13 @@ struct HeavyNeutralMeson { float phi() const { return vHeavyNeutralMeson.Phi(); } }; -float smPhiEdges[9] = {1.75, 2.1, 2.45, 2.8, 3.14, 4., 4.89, 5.24, 5.58}; +const int nSMEdges = 9; +float smPhiEdges[nSMEdges] = {1.75, 2.1, 2.45, 2.8, 3.14, 4., 4.89, 5.24, 5.58}; -unsigned short getSMNumber(float eta, float phi) +int getSMNumber(float eta, float phi) { - unsigned short smNumber = 0; - for (int iPhiInterval = 0; iPhiInterval < 9; iPhiInterval++) { + int smNumber = 0; + for (int iPhiInterval = 0; iPhiInterval < nSMEdges; iPhiInterval++) { if (phi > smPhiEdges[iPhiInterval]) smNumber = 2 * (iPhiInterval + 1); } @@ -148,7 +147,7 @@ void storeGammasInVector(C clusters, V v0s, std::vector& vPhotons, std:: for (const auto& cluster : clusters) { float eta = cluster.eta(); float phi = cluster.phi(); - unsigned short smNumber = getSMNumber(eta, phi); + int smNumber = getSMNumber(eta, phi); // LOG(info) << "Shifting in sm " << smNumber << ", eta/phi = " << eta << " / " << phi << " to eta/phi = " << eta + EMCEtaShift[getSMNumber(eta, phi)] << " / " << phi + EMCPhiShift[getSMNumber(eta, phi)]; eta += EMCEtaShift[smNumber]; phi += EMCPhiShift[smNumber]; @@ -179,31 +178,11 @@ void reconstructGGs(std::vector vPhotons, std::vector& v } } -/// \brief Reconstruct heavy neutral mesons from tracks and GG candidates and fill them into the vHNMs vector -template -void reconstructHeavyNeutralMesons(Track const& tracks, std::vector& vGGs, std::vector& vHNMs) // ToDO: Pion comb. in main code, tracks -> 4-vectors -{ - vHNMs.clear(); - for (const auto& posTrack : tracks) { - if (!posTrack.isGlobalTrack() || posTrack.sign() < 0) - continue; - for (const auto& negTrack : tracks) { - if (!negTrack.isGlobalTrack() || negTrack.sign() > 0) - continue; - for (size_t iGG = 0; iGG < vGGs.size(); iGG++) { - HeavyNeutralMeson heavyNeutralMeson(&vGGs.at(iGG), posTrack.energy(constants::physics::MassPiPlus) + negTrack.energy(constants::physics::MassPiMinus), posTrack.px() + negTrack.px(), posTrack.py() + negTrack.py(), posTrack.pz() + negTrack.pz()); - vHNMs.push_back(heavyNeutralMeson); - } - } - } -} - -/// \brief Reconstruct heavy neutral mesons from pion and antipion and GG candidates and fill them into the vHNMs vector -void reconstructHeavyNeutralMesons(ROOT::Math::PtEtaPhiMVector const& posPion, ROOT::Math::PtEtaPhiMVector const& negPion, std::vector& vGGs, std::vector& vHNMs) // ToDO: Pion comb. in main code, tracks -> 4-vectors +/// \brief Reconstruct heavy neutral mesons from the given pion, antipion and the GG candidates and add them to the vHNMs vector +void reconstructHeavyNeutralMesons(ROOT::Math::PtEtaPhiMVector const& vecPiPlPiMi, std::vector& vGGs, std::vector& vHNMs) { - const ROOT::Math::PtEtaPhiMVector trackSum = posPion + negPion; for (size_t iGG = 0; iGG < vGGs.size(); iGG++) { - HeavyNeutralMeson heavyNeutralMeson(&vGGs.at(iGG), trackSum.E(), trackSum.Px(), trackSum.Py(), trackSum.Pz()); + HeavyNeutralMeson heavyNeutralMeson(&vGGs.at(iGG), vecPiPlPiMi.E(), vecPiPlPiMi.Px(), vecPiPlPiMi.Py(), vecPiPlPiMi.Pz()); vHNMs.push_back(heavyNeutralMeson); } } diff --git a/PWGHF/D2H/Tasks/taskSigmac.cxx b/PWGHF/D2H/Tasks/taskSigmac.cxx index b7d77b1fea6..e7083d7283e 100644 --- a/PWGHF/D2H/Tasks/taskSigmac.cxx +++ b/PWGHF/D2H/Tasks/taskSigmac.cxx @@ -15,6 +15,8 @@ /// /// \author Mattia Faggin , University and INFN PADOVA +#include + #include "CommonConstants/PhysicsConstants.h" #include "Framework/AnalysisTask.h" #include "Framework/HistogramRegistry.h" @@ -39,9 +41,15 @@ struct HfTaskSigmac { /// consider the new parametrization of the fiducial acceptance (to be seen for reco signal in MC) Configurable yCandGenMax{"yCandGenMax", -1, "Maximum generated Sc rapidity"}; Configurable yCandRecoMax{"yCandRecoMax", -1, "Maximum Sc candidate rapidity"}; + Configurable enableTHn{"enableTHn", false, "enable the usage of THn for Λc+ and Σc0,++"}; + + HfHelper hfHelper; + bool isMc; + static constexpr std::size_t NDaughters{2u}; + + using RecoLc = soa::Join; /// THn for candidate Λc+ and Σc0,++ cut variation - Configurable enableTHn{"enableTHn", false, "enable the usage of THn for Λc+ and Σc0,++"}; ConfigurableAxis thnConfigAxisPt{"thnConfigAxisPt", {16, 0, 16}, ""}; ConfigurableAxis thnConfigAxisGenPt{"thnConfigAxisGenPt", {240, 0, 24}, "Gen pt prompt"}; ConfigurableAxis thnConfigAxisGenPtB{"thnConfigAxisGenPtB", {800, 0, 80}, "Gen pt non-prompt"}; @@ -53,8 +61,23 @@ struct HfTaskSigmac { ConfigurableAxis configAxisDeltaMassSigmaC{"configAxisDeltaMassSigmaC", {200, 0.13, 0.23}, ""}; ConfigurableAxis thnConfigAxisBdtScoreLcBkg{"thnConfigAxisBdtScoreLcBkg", {100, 0., 1.}, ""}; ConfigurableAxis thnConfigAxisBdtScoreLcNonPrompt{"thnConfigAxisBdtScoreLcNonPrompt", {100, 0., 1.}, ""}; - - HfHelper hfHelper; + const AxisSpec thnAxisMassLambdaC{configAxisMassLambdaC, "inv. mass (p K #pi) (GeV/#it{c}^{2})"}; + const AxisSpec thnAxisPtLambdaC{thnConfigAxisPt, "#it{p}_{T}(#Lambda_{c}^{+}) (GeV/#it{c})"}; + const AxisSpec thnAxisPtSigmaC{thnConfigAxisPt, "#it{p}_{T}(#Sigma_{c}^{0,++}) (GeV/#it{c})"}; + const AxisSpec thnAxisDecLength{thnConfigAxisDecLength, "decay length #Lambda_{c}^{+} (cm)"}; + const AxisSpec thnAxisDecLengthXY{thnConfigAxisDecLengthXY, "decay length XY #Lambda_{c}^{+} (cm)"}; + const AxisSpec thnAxisCPA{thnConfigAxisCPA, "cosine of pointing angle #Lambda_{c}^{+}"}; + const AxisSpec thnAxisCPAXY{thnConfigAxisCPAXY, "cosine of pointing angle XY #Lambda_{c}^{+}"}; + const AxisSpec thnAxisOriginMc{3, -0.5, 2.5, "0: none, 1: prompt, 2: non-prompt"}; + const AxisSpec thnAxisChargeSigmaC{3, -0.5, 2.5, "#Sigma_{c}-baryon charge"}; + const AxisSpec thnAxisChannel{4, -0.5, 3.5, "0: direct 1,2,3: resonant"}; + const AxisSpec thnAxisBdtScoreLcBkg{thnConfigAxisBdtScoreLcBkg, "BDT bkg score (Lc)"}; + const AxisSpec thnAxisBdtScoreLcNonPrompt{thnConfigAxisBdtScoreLcNonPrompt, "BDT non-prompt score (Lc)"}; + const AxisSpec thnAxisGenPtLambdaC{thnConfigAxisGenPt, "#it{p}_{T}^{gen}(#Lambda_{c}^{+}) (GeV/#it{c})"}; + const AxisSpec thnAxisGenPtSigmaC{thnConfigAxisGenPt, "#it{p}_{T}^{gen}(#Sigma_{c}^{0,++}) (GeV/#it{c})"}; + const AxisSpec thnAxisGenPtLambdaCBMother{thnConfigAxisGenPtB, "#it{p}_{T}^{gen}(#Lambda_{c}^{+} B mother) (GeV/#it{c})"}; + const AxisSpec thnAxisGenPtSigmaCBMother{thnConfigAxisGenPtB, "#it{p}_{T}^{gen}(#Sigma_{c}^{0,++} B mother) (GeV/#it{c})"}; + const AxisSpec thnAxisGenSigmaCSpecies = {o2::aod::hf_cand_sigmac::Species::NSpecies, -0.5f, +o2::aod::hf_cand_sigmac::Species::NSpecies - 0.5f, "bin 1: #Sigma_{c}(2455), bin 2: #Sigma_{c}(2520)"}; /// analysis histograms HistogramRegistry registry{ @@ -99,10 +122,6 @@ struct HfTaskSigmac { {"Data/hPhiLcFromSc0PlusPlus", "#Lambda_{c}^{+} #leftarrow #Sigma_{c}^{0,++} candidates; #varphi(#Lambda_{c}^{+} #leftarrow #Sigma_{c}^{0,++}); entries;", {HistType::kTH1D, {{72, 0, constants::math::TwoPI}}}}}}; //{"Data/hDeltaMassLcFromSc0PlusPlus", "#Lambda_{c}^{+} #leftarrow #Sigma_{c}^{0,++} candidates; #it{M}(pK#pi#pi) - #it{M}(pK#pi) (GeV/#it{c}^{2}); #it{p}_{T}(#Lambda_{c}^{+} #leftarrow #Sigma_{c}^{0,++}) (GeV/#it{c});", {HistType::kTH2D, {axisDeltaMassSigmaC, {36, 0., 36.}}}}}}; - using RecoLc = soa::Join; - - bool isMc; - /// @brief init function, to define the additional analysis histograms /// @param void init(InitContext&) @@ -246,37 +265,23 @@ struct HfTaskSigmac { /// THn for candidate Λc+ and Σc0,++ cut variation if (enableTHn) { - const AxisSpec thnAxisMassLambdaC{configAxisMassLambdaC, "inv. mass (p K #pi) (GeV/#it{c}^{2})"}; - const AxisSpec thnAxisPtLambdaC{thnConfigAxisPt, "#it{p}_{T}(#Lambda_{c}^{+}) (GeV/#it{c})"}; - const AxisSpec thnAxisPtSigmaC{thnConfigAxisPt, "#it{p}_{T}(#Sigma_{c}^{0,++}) (GeV/#it{c})"}; - const AxisSpec thnAxisDecLength{thnConfigAxisDecLength, "decay length #Lambda_{c}^{+} (cm)"}; - const AxisSpec thnAxisDecLengthXY{thnConfigAxisDecLengthXY, "decay length XY #Lambda_{c}^{+} (cm)"}; - const AxisSpec thnAxisCPA{thnConfigAxisCPA, "cosine of pointing angle #Lambda_{c}^{+}"}; - const AxisSpec thnAxisCPAXY{thnConfigAxisCPAXY, "cosine of pointing angle XY #Lambda_{c}^{+}"}; - const AxisSpec thnAxisOriginMc{3, -0.5, 2.5, "0: none, 1: prompt, 2: non-prompt"}; - const AxisSpec thnAxisChargeSigmaC{3, -0.5, 2.5, "#Sigma_{c}-baryon charge"}; - const AxisSpec thnAxisChannel{4, -0.5, 3.5, "0: direct 1,2,3: resonant"}; - const AxisSpec thnAxisBdtScoreLcBkg{thnConfigAxisBdtScoreLcBkg, "BDT bkg score (Lc)"}; - const AxisSpec thnAxisBdtScoreLcNonPrompt{thnConfigAxisBdtScoreLcNonPrompt, "BDT non-prompt score (Lc)"}; - const AxisSpec thnAxisGenPtLambdaC{thnConfigAxisGenPt, "#it{p}_{T}^{gen}(#Lambda_{c}^{+}) (GeV/#it{c})"}; - const AxisSpec thnAxisGenPtSigmaC{thnConfigAxisGenPt, "#it{p}_{T}^{gen}(#Sigma_{c}^{0,++}) (GeV/#it{c})"}; - const AxisSpec thnAxisGenPtLambdaCBMother{thnConfigAxisGenPtB, "#it{p}_{T}^{gen}(#Lambda_{c}^{+} B mother) (GeV/#it{c})"}; - const AxisSpec thnAxisGenPtSigmaCBMother{thnConfigAxisGenPtB, "#it{p}_{T}^{gen}(#Sigma_{c}^{0,++} B mother) (GeV/#it{c})"}; std::vector axesLambdaCWithMl = {thnAxisPtLambdaC, thnAxisMassLambdaC, thnAxisBdtScoreLcBkg, thnAxisBdtScoreLcNonPrompt, thnAxisOriginMc, thnAxisChannel}; std::vector axesSigmaCWithMl = {thnAxisPtLambdaC, axisDeltaMassSigmaC, thnAxisBdtScoreLcBkg, thnAxisBdtScoreLcNonPrompt, thnAxisOriginMc, thnAxisChannel, thnAxisPtSigmaC, thnAxisChargeSigmaC}; std::vector axesLambdaCWoMl = {thnAxisPtLambdaC, thnAxisMassLambdaC, thnAxisDecLength, thnAxisDecLengthXY, thnAxisCPA, thnAxisCPAXY, thnAxisOriginMc, thnAxisChannel}; std::vector axesSigmaCWoMl = {thnAxisPtLambdaC, axisDeltaMassSigmaC, thnAxisDecLength, thnAxisDecLengthXY, thnAxisCPA, thnAxisCPAXY, thnAxisOriginMc, thnAxisChannel, thnAxisPtSigmaC, thnAxisChargeSigmaC}; if (isMc) { - registry.add("hnLambdaCGen", "THn for Lambdac gen", HistType::kTHnSparseF, {thnAxisGenPtLambdaC, thnAxisGenPtLambdaCBMother, thnAxisOriginMc, thnAxisChannel}); - registry.add("hnSigmaCGen", "THn for Sigmac gen", HistType::kTHnSparseF, {thnAxisGenPtSigmaC, thnAxisGenPtSigmaCBMother, thnAxisOriginMc, thnAxisChannel, thnAxisGenPtLambdaC, thnAxisChargeSigmaC}); + registry.add("MC/generated/hnLambdaCGen", "THn for Lambdac gen", HistType::kTHnSparseF, {thnAxisGenPtLambdaC, thnAxisGenPtLambdaCBMother, thnAxisOriginMc, thnAxisChannel}); + registry.add("MC/generated/hnSigmaCGen", "THn for Sigmac gen", HistType::kTHnSparseF, {thnAxisGenPtSigmaC, thnAxisGenPtSigmaCBMother, thnAxisOriginMc, thnAxisChannel, thnAxisGenPtLambdaC, thnAxisChargeSigmaC, thnAxisGenSigmaCSpecies}); if (doprocessMcWithMl) { axesLambdaCWithMl.push_back(thnAxisGenPtLambdaCBMother); axesSigmaCWithMl.push_back(thnAxisGenPtSigmaCBMother); + axesSigmaCWithMl.push_back(thnAxisGenSigmaCSpecies); registry.add("hnLambdaC", "THn for Lambdac", HistType::kTHnSparseF, axesLambdaCWithMl); registry.add("hnSigmaC", "THn for Sigmac", HistType::kTHnSparseF, axesSigmaCWithMl); } else { axesLambdaCWoMl.push_back(thnAxisGenPtLambdaCBMother); axesSigmaCWoMl.push_back(thnAxisGenPtSigmaCBMother); + axesSigmaCWoMl.push_back(thnAxisGenSigmaCSpecies); registry.add("hnLambdaC", "THn for Lambdac", HistType::kTHnSparseF, axesLambdaCWoMl); registry.add("hnSigmaC", "THn for Sigmac", HistType::kTHnSparseF, axesSigmaCWoMl); } @@ -300,16 +305,16 @@ struct HfTaskSigmac { /// @param candSc Sc candidate /// @return 0: none; 1: only Λc+ → pK-π+ possible; 2: Λc+ → π+K-p possible; 3: both possible template - int isDecayToPKPiToPiKP(L& candidateLc, S& candSc) + int8_t isDecayToPKPiToPiKP(L& candidateLc, S& candSc) { - int channel = 0; + int8_t channel = 0; if ((candidateLc.isSelLcToPKPi() >= 1) && candSc.statusSpreadLcMinvPKPiFromPDG()) { // Λc+ → pK-π+ and within the requested mass to build the Σc0,++ - channel += 1; + SETBIT(channel, o2::aod::hf_cand_sigmac::Decays::PKPi); } if ((candidateLc.isSelLcToPiKP() >= 1) && candSc.statusSpreadLcMinvPiKPFromPDG()) { // Λc+ → π+K-p and within the requested mass to build the Σc0,++ - channel += 2; + SETBIT(channel, o2::aod::hf_cand_sigmac::Decays::PiKP); } return channel; /// 0: none; 1: pK-π+ only; 2: π+K-p only; 3: both possible } @@ -326,6 +331,12 @@ struct HfTaskSigmac { /// loop over the candidate Σc0,++ for (const auto& candSc : candidatesSc) { + /// rapidity selection on Σc0,++ + /// NB: since in data we cannot tag Sc(2455) and Sc(2520), then we use only Sc(2455) for y selection on reconstructed signal + if (yCandRecoMax >= 0. && std::abs(hfHelper.ySc0(candSc)) > yCandRecoMax && std::abs(hfHelper.yScPlusPlus(candSc)) > yCandRecoMax) { + continue; + } + const int8_t chargeSc = candSc.charge(); // either Σc0 or Σc++ /// get the candidate Λc+ used to build the candidate Σc0,++ @@ -333,7 +344,7 @@ struct HfTaskSigmac { const auto& candidateLc = candSc.prongLc_as(); // const int iscandidateLcpKpi = (candidateLc.isSelLcToPKPi() >= 1) && candSc.statusSpreadLcMinvPKPiFromPDG(); // Λc+ → pK-π+ and within the requested mass to build the Σc0,++ // const int iscandidateLcpiKp = (candidateLc.isSelLcToPiKP() >= 1) && candSc.statusSpreadLcMinvPiKPFromPDG(); // Λc+ → π+K-p and within the requested mass to build the Σc0,++ - const int isCandPKPiPiKP = isDecayToPKPiToPiKP(candidateLc, candSc); + const int8_t isCandPKPiPiKP = isDecayToPKPiToPiKP(candidateLc, candSc); double massSc(-1.), massLc(-1.), deltaMass(-1.); double ptSc(candSc.pt()), ptLc(candidateLc.pt()); double etaSc(candSc.eta()), etaLc(candidateLc.eta()); @@ -342,12 +353,12 @@ struct HfTaskSigmac { double decLengthLc(candidateLc.decayLength()), decLengthXYLc(candidateLc.decayLengthXY()); double cpaLc(candidateLc.cpa()), cpaXYLc(candidateLc.cpaXY()); /// candidate Λc+ → pK-π+ (and charge conjugate) within the range of M(pK-π+) chosen in the Σc0,++ builder - if (isCandPKPiPiKP == 1 || isCandPKPiPiKP == 3) { + if (TESTBIT(isCandPKPiPiKP, o2::aod::hf_cand_sigmac::Decays::PKPi)) { massSc = hfHelper.invMassScRecoLcToPKPi(candSc, candidateLc); massLc = hfHelper.invMassLcToPKPi(candidateLc); deltaMass = massSc - massLc; /// fill the histograms - if (chargeSc == 0) { + if (chargeSc == o2::aod::hf_cand_sigmac::ChargeNull) { registry.fill(HIST("Data/hPtSc0"), ptSc); registry.fill(HIST("Data/hEtaSc0"), etaSc); registry.fill(HIST("Data/hPhiSc0"), phiSc); @@ -415,12 +426,12 @@ struct HfTaskSigmac { } } /// end candidate Λc+ → pK-π+ (and charge conjugate) /// candidate Λc+ → π+K-p (and charge conjugate) within the range of M(π+K-p) chosen in the Σc0,++ builder - if (isCandPKPiPiKP == 2 || isCandPKPiPiKP == 3) { + if (TESTBIT(isCandPKPiPiKP, o2::aod::hf_cand_sigmac::Decays::PiKP)) { massSc = hfHelper.invMassScRecoLcToPiKP(candSc, candidateLc); massLc = hfHelper.invMassLcToPiKP(candidateLc); deltaMass = massSc - massLc; /// fill the histograms - if (chargeSc == 0) { + if (chargeSc == o2::aod::hf_cand_sigmac::ChargeNull) { registry.fill(HIST("Data/hPtSc0"), ptSc); registry.fill(HIST("Data/hEtaSc0"), etaSc); registry.fill(HIST("Data/hPhiSc0"), phiSc); @@ -487,7 +498,7 @@ struct HfTaskSigmac { } } } /// end candidate Λc+ → π+K-p (and charge conjugate) - } /// end loop over the candidate Σc0,++ + } /// end loop over the candidate Σc0,++ /// THn for candidate Λc+ cut variation w/o Σc0,++ mass-window cut if (enableTHn) { @@ -534,7 +545,7 @@ struct HfTaskSigmac { } } } /// end THn for candidate Λc+ cut variation w/o Σc0,++ mass-window cut - }; /// end fillHistosData + }; /// end fillHistosData /// @brief function to fill the histograms needed in analysis (MC) /// @param candidatesSc are the reconstructed candidate Σc0,++ with MC info @@ -553,9 +564,11 @@ struct HfTaskSigmac { for (const auto& particle : mcParticlesSc) { /// reject immediately particles different from Σc0,++ - bool isSc0Gen = (std::abs(particle.flagMcMatchGen()) == (1 << aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi)); - bool isScPlusPlusGen = (std::abs(particle.flagMcMatchGen()) == (1 << aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi)); - if (!isSc0Gen && !isScPlusPlusGen) + bool isSc0Gen = (std::abs(particle.flagMcMatchGen()) == BIT(aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi)); + bool isScStar0Gen = (std::abs(particle.flagMcMatchGen()) == BIT(aod::hf_cand_sigmac::DecayType::ScStar0ToPKPiPi)); + bool isScPlusPlusGen = (std::abs(particle.flagMcMatchGen()) == BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi)); + bool isScStarPlusPlusGen = (std::abs(particle.flagMcMatchGen()) == BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi)); + if (!isSc0Gen && !isScPlusPlusGen && !isScStar0Gen && !isScStarPlusPlusGen) continue; /// look for generated particles in acceptance @@ -569,8 +582,20 @@ struct HfTaskSigmac { OR consider the new parametrization of the fiducial acceptance (to be seen for reco signal in MC) */ - if (yCandGenMax >= 0. && std::abs(RecoDecay::y(particle.pVector(), o2::constants::physics::MassSigmaC0)) > yCandGenMax) { - continue; + if (yCandGenMax >= 0.) { + double mass = -1; + if (isSc0Gen) { + mass = o2::constants::physics::MassSigmaC0; + } else if (isScPlusPlusGen) { + mass = o2::constants::physics::MassSigmaCPlusPlus; + } else if (isScStar0Gen) { + mass = o2::constants::physics::MassSigmaCStar0; + } else if (isScStarPlusPlusGen) { + mass = o2::constants::physics::MassSigmaCStarPlusPlus; + } + if (mass > -1. && std::abs(RecoDecay::y(particle.pVector(), mass)) > yCandGenMax) { + continue; + } } /// Get the kinematic information of Σc0,++ and the daughters @@ -579,7 +604,7 @@ struct HfTaskSigmac { double ptGenSc(particle.pt()), etaGenSc(particle.eta()), phiGenSc(particle.phi()); double ptGenScBMother(-1.); auto arrayDaughtersIds = particle.daughtersIds(); - if (arrayDaughtersIds.size() != 2) { + if (arrayDaughtersIds.size() != NDaughters) { /// This should never happen LOG(fatal) << "generated Σc0,++ has a number of daughter particles different than 2"; continue; @@ -617,7 +642,13 @@ struct HfTaskSigmac { } /// Fill histograms - if (isSc0Gen) { + int sigmacSpecies = -1; + if (isSc0Gen || isScPlusPlusGen) { + sigmacSpecies = o2::aod::hf_cand_sigmac::Sc2455; + } else if (isScStar0Gen || isScStarPlusPlusGen) { + sigmacSpecies = o2::aod::hf_cand_sigmac::Sc2520; + } + if (isSc0Gen || isScStar0Gen) { /// Generated Σc0 and Λc+ ← Σc0 signals registry.fill(HIST("MC/generated/hPtGenSc0Sig"), ptGenSc, origin, channel); registry.fill(HIST("MC/generated/hEtaGenSc0Sig"), etaGenSc, origin, channel); @@ -639,12 +670,19 @@ struct HfTaskSigmac { registry.fill(HIST("MC/generated/hEtaGenLcFromSc0PlusPlusSig"), etaGenLc, origin, channel); registry.fill(HIST("MC/generated/hPhiGenLcFromSc0PlusPlusSig"), phiGenLc, origin, channel); /// Generated Λc+ ← Σc0,++ signal if (origin == RecoDecay::OriginType::Prompt) { - registry.fill(HIST("hnSigmaCGen"), ptGenSc, ptGenScBMother, origin, channel, ptGenLc, 0); + registry.fill(HIST("MC/generated/hnSigmaCGen"), ptGenSc, ptGenScBMother, origin, channel, ptGenLc, 0, sigmacSpecies); } else { ptGenScBMother = mcParticlesSc.rawIteratorAt(particle.idxBhadMotherPart()).pt(); - registry.fill(HIST("hnSigmaCGen"), ptGenSc, ptGenScBMother, origin, channel, ptGenLc, 0); + registry.fill(HIST("MC/generated/hnSigmaCGen"), ptGenSc, ptGenScBMother, origin, channel, ptGenLc, 0, sigmacSpecies); } - } else if (isScPlusPlusGen) { + + // debug -- uncomment if needed + // it should be solved after the implementation of ev. selection for generated SigmaC particles + // if(origin != RecoDecay::OriginType::Prompt && origin != RecoDecay::OriginType::NonPrompt) { + // LOG(info) << " --> (Sc0 gen) origin " << static_cast(origin) << ", particle.originMcGen() " << static_cast(particle.originMcGen()) << ", particle.flagMcMatchGen() " << static_cast(particle.flagMcMatchGen()) << ", pdg " << particle.pdgCode(); + //} + + } else if (isScPlusPlusGen || isScStarPlusPlusGen) { /// Generated Σc++ and Λc+ ← Σc++ signals registry.fill(HIST("MC/generated/hPtGenScPlusPlusSig"), ptGenSc, origin, channel); registry.fill(HIST("MC/generated/hEtaGenScPlusPlusSig"), etaGenSc, origin, channel); @@ -666,18 +704,24 @@ struct HfTaskSigmac { registry.fill(HIST("MC/generated/hEtaGenLcFromSc0PlusPlusSig"), etaGenLc, origin, channel); registry.fill(HIST("MC/generated/hPhiGenLcFromSc0PlusPlusSig"), phiGenLc, origin, channel); /// Generated Λc+ ← Σc0,++ signal if (origin == RecoDecay::OriginType::Prompt) { - registry.fill(HIST("hnSigmaCGen"), ptGenSc, ptGenScBMother, origin, channel, ptGenLc, 2); + registry.fill(HIST("MC/generated/hnSigmaCGen"), ptGenSc, ptGenScBMother, origin, channel, ptGenLc, 2, sigmacSpecies); } else { ptGenScBMother = mcParticlesSc.rawIteratorAt(particle.idxBhadMotherPart()).pt(); - registry.fill(HIST("hnSigmaCGen"), ptGenSc, ptGenScBMother, origin, channel, ptGenLc, 2); + registry.fill(HIST("MC/generated/hnSigmaCGen"), ptGenSc, ptGenScBMother, origin, channel, ptGenLc, 2, sigmacSpecies); } + + // debug -- uncomment if needed + // it should be solved after the implementation of ev. selection for generated SigmaC particles + // if(origin != RecoDecay::OriginType::Prompt && origin != RecoDecay::OriginType::NonPrompt) { + // LOG(info) << " --> (Sc++ gen) origin " << static_cast(origin) << ", particle.originMcGen() " << static_cast(particle.originMcGen()) << ", particle.flagMcMatchGen() " << static_cast(particle.flagMcMatchGen()) << ", pdg " << particle.pdgCode(); + //} } } /// end loop over Sc generated particles /// loop over Lc generated particles for (const auto& particle : mcParticlesLc) { - if (std::abs(particle.flagMcMatchGen()) != 1 << aod::hf_cand_3prong::DecayType::LcToPKPi) { + if (std::abs(particle.flagMcMatchGen()) != BIT(aod::hf_cand_3prong::DecayType::LcToPKPi)) { continue; } if (yCandGenMax >= 0. && std::abs(RecoDecay::y(particle.pVector(), o2::constants::physics::MassLambdaCPlus)) > yCandGenMax) { @@ -687,10 +731,10 @@ struct HfTaskSigmac { int origin = particle.originMcGen(); int channel = particle.flagMcDecayChanGen(); if (origin == RecoDecay::OriginType::Prompt) { - registry.fill(HIST("hnLambdaCGen"), ptGenLc, ptGenLcBMother, origin, channel); + registry.fill(HIST("MC/generated/hnLambdaCGen"), ptGenLc, ptGenLcBMother, origin, channel); } else { ptGenLcBMother = mcParticlesLc.rawIteratorAt(particle.idxBhadMotherPart()).pt(); - registry.fill(HIST("hnLambdaCGen"), ptGenLc, ptGenLcBMother, origin, channel); + registry.fill(HIST("MC/generated/hnLambdaCGen"), ptGenLc, ptGenLcBMother, origin, channel); } } /// end loop over Lc generated particles @@ -698,10 +742,12 @@ struct HfTaskSigmac { for (const auto& candSc : candidatesSc) { /// Candidate selected as Σc0 and/or Σc++ - if (!(candSc.hfflag() & 1 << aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && !(candSc.hfflag() & 1 << aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi)) { + if (!(candSc.hfflag() & BIT(aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi)) && !(candSc.hfflag() & BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi)) && // Σc0,++(2455) + !(candSc.hfflag() & BIT(aod::hf_cand_sigmac::DecayType::ScStar0ToPKPiPi)) && !(candSc.hfflag() & BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi))) { // Σc0,++(2520) continue; } /// rapidity selection on Σc0,++ + /// NB: since in data we cannot tag Sc(2455) and Sc(2520), then we use only Sc(2455) for y selection on reconstructed signal if (yCandRecoMax >= 0. && std::abs(hfHelper.ySc0(candSc)) > yCandRecoMax && std::abs(hfHelper.yScPlusPlus(candSc)) > yCandRecoMax) { continue; } @@ -712,14 +758,28 @@ struct HfTaskSigmac { /// get the candidate Λc+ used to build the Σc0 /// and understand which mass hypotheses are possible const auto& candidateLc = candSc.prongLc_as(); - const int isCandPKPiPiKP = isDecayToPKPiToPiKP(candidateLc, candSc); + const int8_t isCandPKPiPiKP = isDecayToPKPiToPiKP(candidateLc, candSc); // candidateLc.flagMcDecayChanRec(); - /// Reconstructed Σc0 signal - if (std::abs(candSc.flagMcMatchRec()) == 1 << aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi && (chargeSc == 0)) { + bool isTrueSc0Reco = std::abs(candSc.flagMcMatchRec()) == BIT(aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi); + bool isTrueScStar0Reco = std::abs(candSc.flagMcMatchRec()) == BIT(aod::hf_cand_sigmac::DecayType::ScStar0ToPKPiPi); + bool isTrueScPlusPlusReco = std::abs(candSc.flagMcMatchRec()) == BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi); + bool isTrueScStarPlusPlusReco = std::abs(candSc.flagMcMatchRec()) == BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi); + int sigmacSpecies = -1; + if ((isTrueSc0Reco || isTrueScStar0Reco) && (chargeSc == o2::aod::hf_cand_sigmac::ChargeNull)) { + /// Reconstructed Σc0 signal // Get the corresponding MC particle for Sc, found as the mother of the soft pion - auto indexMcScRec = RecoDecay::getMother(mcParticles, candSc.prong1_as().mcParticle(), o2::constants::physics::Pdg::kSigmaC0, true); + int indexMcScRec = -1; + if (isTrueSc0Reco) { + // Σc0(2455) + indexMcScRec = RecoDecay::getMother(mcParticles, candSc.prong1_as().mcParticle(), o2::constants::physics::Pdg::kSigmaC0, true); + sigmacSpecies = o2::aod::hf_cand_sigmac::Sc2455; + } else if (isTrueScStar0Reco) { + // Σc0(2520) + indexMcScRec = RecoDecay::getMother(mcParticles, candSc.prong1_as().mcParticle(), o2::constants::physics::Pdg::kSigmaCStar0, true); + sigmacSpecies = o2::aod::hf_cand_sigmac::Sc2520; + } auto particleSc = mcParticles.rawIteratorAt(indexMcScRec); // Get the corresponding MC particle for Lc auto arrayDaughtersLc = std::array{candidateLc.template prong0_as(), candidateLc.template prong1_as(), candidateLc.template prong2_as()}; @@ -743,7 +803,7 @@ struct HfTaskSigmac { auto channel = candidateLc.flagMcDecayChanRec(); /// 0: direct; 1: Λc± → p± K*; 2: Λc± → Δ(1232)±± K∓; 3: Λc± → Λ(1520) π± /// candidate Λc+ → pK-π+ (and charge conjugate) within the range of M(pK-π+) chosen in the Σc0,++ builder - if ((isCandPKPiPiKP == 1 || isCandPKPiPiKP == 3) && std::abs(candidateLc.template prong0_as().mcParticle().pdgCode()) == kProton) { + if ((TESTBIT(isCandPKPiPiKP, o2::aod::hf_cand_sigmac::Decays::PKPi)) && std::abs(candidateLc.template prong0_as().mcParticle().pdgCode()) == kProton) { massSc = hfHelper.invMassScRecoLcToPKPi(candSc, candidateLc); massLc = hfHelper.invMassLcToPKPi(candidateLc); deltaMass = massSc - massLc; @@ -808,16 +868,16 @@ struct HfTaskSigmac { outputMl.at(0) = candidateLc.mlProbLcToPKPi()[0]; /// bkg score outputMl.at(1) = candidateLc.mlProbLcToPKPi()[2]; /// non-prompt score } - registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, outputMl.at(0), outputMl.at(1), origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart()); + registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, outputMl.at(0), outputMl.at(1), origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart(), sigmacSpecies); } else { /// fill w/o BDT information - registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, decLengthLc, decLengthXYLc, cpaLc, cpaXYLc, origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart()); + registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, decLengthLc, decLengthXYLc, cpaLc, cpaXYLc, origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart(), sigmacSpecies); } } } /// end candidate Λc+ → pK-π+ (and charge conjugate) /// candidate Λc+ → π+K-p (and charge conjugate) within the range of M(π+K-p) chosen in the Σc0,++ builder - if ((isCandPKPiPiKP == 2 || isCandPKPiPiKP == 3) && std::abs(candidateLc.template prong0_as().mcParticle().pdgCode()) == kPiPlus) { + if ((TESTBIT(isCandPKPiPiKP, o2::aod::hf_cand_sigmac::Decays::PiKP)) && std::abs(candidateLc.template prong0_as().mcParticle().pdgCode()) == kPiPlus) { massSc = hfHelper.invMassScRecoLcToPiKP(candSc, candidateLc); massLc = hfHelper.invMassLcToPiKP(candidateLc); deltaMass = massSc - massLc; @@ -882,19 +942,28 @@ struct HfTaskSigmac { outputMl.at(0) = candidateLc.mlProbLcToPiKP()[0]; /// bkg score outputMl.at(1) = candidateLc.mlProbLcToPiKP()[2]; /// non-prompt score } - registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, outputMl.at(0), outputMl.at(1), origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart()); + registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, outputMl.at(0), outputMl.at(1), origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart(), sigmacSpecies); } else { /// fill w/o BDT information - registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, decLengthLc, decLengthXYLc, cpaLc, cpaXYLc, origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart()); + registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, decLengthLc, decLengthXYLc, cpaLc, cpaXYLc, origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart(), sigmacSpecies); } } } /// end candidate Λc+ → π+K-p (and charge conjugate) /// end reconstructed Σc0 signal - } else if (std::abs(candSc.flagMcMatchRec()) == 1 << aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi && (std::abs(chargeSc) == 2)) { + } else if ((isTrueScPlusPlusReco || isTrueScStarPlusPlusReco) && (std::abs(chargeSc) == o2::aod::hf_cand_sigmac::ChargePlusPlus)) { /// Reconstructed Σc++ signal // Get the corresponding MC particle for Sc, found as the mother of the soft pion - auto indexMcScRec = RecoDecay::getMother(mcParticles, candSc.prong1_as().mcParticle(), o2::constants::physics::Pdg::kSigmaCPlusPlus, true); + int indexMcScRec = -1; + if (isTrueScPlusPlusReco) { + // Σc0(2455) + indexMcScRec = RecoDecay::getMother(mcParticles, candSc.prong1_as().mcParticle(), o2::constants::physics::Pdg::kSigmaCPlusPlus, true); + sigmacSpecies = o2::aod::hf_cand_sigmac::Sc2455; + } else if (isTrueScStarPlusPlusReco) { + // Σc0(2520) + indexMcScRec = RecoDecay::getMother(mcParticles, candSc.prong1_as().mcParticle(), o2::constants::physics::Pdg::kSigmaCStarPlusPlus, true); + sigmacSpecies = o2::aod::hf_cand_sigmac::Sc2520; + } auto particleSc = mcParticles.rawIteratorAt(indexMcScRec); // Get the corresponding MC particle for Lc auto arrayDaughtersLc = std::array{candidateLc.template prong0_as(), candidateLc.template prong1_as(), candidateLc.template prong2_as()}; @@ -918,7 +987,7 @@ struct HfTaskSigmac { auto channel = candidateLc.flagMcDecayChanRec(); /// 0: direct; 1: Λc± → p± K*; 2: Λc± → Δ(1232)±± K∓; 3: Λc± → Λ(1520) π± /// candidate Λc+ → pK-π+ (and charge conjugate) within the range of M(pK-π+) chosen in the Σc0,++ builder - if ((isCandPKPiPiKP == 1 || isCandPKPiPiKP == 3) && std::abs(candidateLc.template prong0_as().mcParticle().pdgCode()) == kProton) { + if ((TESTBIT(isCandPKPiPiKP, o2::aod::hf_cand_sigmac::Decays::PKPi)) && std::abs(candidateLc.template prong0_as().mcParticle().pdgCode()) == kProton) { massSc = hfHelper.invMassScRecoLcToPKPi(candSc, candidateLc); massLc = hfHelper.invMassLcToPKPi(candidateLc); deltaMass = massSc - massLc; @@ -983,16 +1052,16 @@ struct HfTaskSigmac { outputMl.at(0) = candidateLc.mlProbLcToPKPi()[0]; /// bkg score outputMl.at(1) = candidateLc.mlProbLcToPKPi()[2]; /// non-prompt score } - registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, outputMl.at(0), outputMl.at(1), origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart()); + registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, outputMl.at(0), outputMl.at(1), origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart(), sigmacSpecies); } else { /// fill w/o BDT information - registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, decLengthLc, decLengthXYLc, cpaLc, cpaXYLc, origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart()); + registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, decLengthLc, decLengthXYLc, cpaLc, cpaXYLc, origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart(), sigmacSpecies); } } } /// end candidate Λc+ → pK-π+ (and charge conjugate) /// candidate Λc+ → π+K-p (and charge conjugate) within the range of M(π+K-p) chosen in the Σc0,++ builder - if ((isCandPKPiPiKP == 2 || isCandPKPiPiKP == 3) && std::abs(candidateLc.template prong0_as().mcParticle().pdgCode()) == kPiPlus) { + if ((TESTBIT(isCandPKPiPiKP, o2::aod::hf_cand_sigmac::Decays::PiKP)) && std::abs(candidateLc.template prong0_as().mcParticle().pdgCode()) == kPiPlus) { massSc = hfHelper.invMassScRecoLcToPiKP(candSc, candidateLc); massLc = hfHelper.invMassLcToPiKP(candidateLc); deltaMass = massSc - massLc; @@ -1055,15 +1124,15 @@ struct HfTaskSigmac { outputMl.at(0) = candidateLc.mlProbLcToPiKP()[0]; /// bkg score outputMl.at(1) = candidateLc.mlProbLcToPiKP()[2]; /// non-prompt score } - registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, outputMl.at(0), outputMl.at(1), origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart()); + registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, outputMl.at(0), outputMl.at(1), origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart(), sigmacSpecies); } else { /// fill w/o BDT information - registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, decLengthLc, decLengthXYLc, cpaLc, cpaXYLc, origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart()); + registry.get(HIST("hnSigmaC"))->Fill(ptLc, deltaMass, decLengthLc, decLengthXYLc, cpaLc, cpaXYLc, origin, channel, ptSc, std::abs(chargeSc), candSc.ptBhadMotherPart(), sigmacSpecies); } } } /// end candidate Λc+ → π+K-p (and charge conjugate) - } /// end reconstructed Σc++ signal + } /// end reconstructed Σc++ signal } /// end loop on reconstructed Σc0,++ diff --git a/PWGHF/DataModel/CandidateReconstructionTables.h b/PWGHF/DataModel/CandidateReconstructionTables.h index 7ee144ca397..754de37ec45 100644 --- a/PWGHF/DataModel/CandidateReconstructionTables.h +++ b/PWGHF/DataModel/CandidateReconstructionTables.h @@ -2064,7 +2064,17 @@ DECLARE_SOA_COLUMN(OriginMcGen, originMcGen, int8_t); //! particle origin, // mapping of decay types enum DecayType { Sc0ToPKPiPi = 0, - ScplusplusToPKPiPi }; + ScplusplusToPKPiPi, + ScStar0ToPKPiPi, + ScStarPlusPlusToPKPiPi }; +enum Species : int { Sc2455 = 0, + Sc2520, + NSpecies }; +enum Decays : int { PKPi = 0, + PiKP, + NDecays }; +constexpr int ChargeNull = 0; +constexpr int ChargePlusPlus = 2; } // namespace hf_cand_sigmac // declare dedicated Σc0,++ decay candidate table @@ -2293,8 +2303,8 @@ DECLARE_SOA_DYNAMIC_COLUMN(PtSoftPi, ptSoftPi, [](float pxSoftPi, float pySoftPi DECLARE_SOA_DYNAMIC_COLUMN(PVecSoftPi, pVecSoftPi, [](float px, float py, float pz) -> std::array { return std::array{px, py, pz}; }); // MC matching result: -DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); //! reconstruction level -DECLARE_SOA_COLUMN(FlagMcMatchGen, flagMcMatchGen, int8_t); //! generator level +DECLARE_SOA_COLUMN(FlagMcMatchRec, flagMcMatchRec, int8_t); //! reconstruction level +DECLARE_SOA_COLUMN(FlagMcMatchGen, flagMcMatchGen, int8_t); //! generator level DECLARE_SOA_COLUMN(FlagMcMatchRecD0, flagMcMatchRecD0, int8_t); //! reconstruction level DECLARE_SOA_COLUMN(FlagMcMatchGenD0, flagMcMatchGenD0, int8_t); //! generator level diff --git a/PWGHF/HFC/Tasks/taskCorrelationDsHadrons.cxx b/PWGHF/HFC/Tasks/taskCorrelationDsHadrons.cxx index 76c4f88c04c..fc4c059c61b 100644 --- a/PWGHF/HFC/Tasks/taskCorrelationDsHadrons.cxx +++ b/PWGHF/HFC/Tasks/taskCorrelationDsHadrons.cxx @@ -66,7 +66,8 @@ struct HfTaskCorrelationDsHadrons { Configurable> classMl{"classMl", {0, 1, 2}, "Indexes of ML scores to be stored. Three indexes max."}; Configurable> binsPtD{"binsPtD", std::vector{o2::analysis::hf_cuts_ds_to_k_k_pi::vecBinsPt}, "pT bin limits for candidate mass plots and efficiency"}; Configurable> binsPtHadron{"binsPtHadron", std::vector{0.3, 2., 4., 8., 12., 50.}, "pT bin limits for assoc particle efficiency"}; - Configurable> mlOutputPrompt{"mlOutputPrompt", {0.5, 0.5, 0.5, 0.5}, "Machine learning scores for prompt"}; + Configurable> mlOutputPromptMin{"mlOutputPromptMin", {0.5, 0.5, 0.5, 0.5}, "Machine learning scores for prompt"}; + Configurable> mlOutputPromptMax{"mlOutputPromptMax", {1.0, 1.0, 1.0, 1.0}, "Machine learning scores for prompt"}; Configurable> mlOutputBkg{"mlOutputBkg", {0.5, 0.5, 0.5, 0.5}, "Machine learning scores for bkg"}; Configurable> binsPtEfficiencyD{"binsPtEfficiencyD", std::vector{o2::analysis::hf_cuts_ds_to_k_k_pi::vecBinsPt}, "pT bin limits for D-meson efficiency"}; Configurable> binsPtEfficiencyHad{"binsPtEfficiencyHad", std::vector{0.3, 2., 4., 8., 12., 50.}, "pT bin limits for associated particle efficiency"}; @@ -266,6 +267,12 @@ struct HfTaskCorrelationDsHadrons { } } + bool isSelectedCandidate(const int ptBinD, const float bdtScorePrompt, const float bdtScoreBkg) + { + + return (ptBinD != -1 && bdtScorePrompt >= mlOutputPromptMin->at(ptBinD) && bdtScorePrompt <= mlOutputPromptMax->at(ptBinD) && bdtScoreBkg <= mlOutputBkg->at(ptBinD)); + } + void processData(DsHadronPairWithMl const& pairEntries, aod::DsCandRecoInfo const& candidates) { @@ -276,9 +283,10 @@ struct HfTaskCorrelationDsHadrons { float bdtScoreBkg = candidate.mlScoreBkg(); int ptBinD = o2::analysis::findBin(binsPtD, ptD); - if (bdtScorePrompt < mlOutputPrompt->at(ptBinD) || bdtScoreBkg > mlOutputBkg->at(ptBinD)) { + if (!isSelectedCandidate(ptBinD, bdtScorePrompt, bdtScoreBkg)) { continue; } + double efficiencyWeightD = 1.; if (applyEfficiency) { efficiencyWeightD = 1. / efficiencyD->at(o2::analysis::findBin(binsPtEfficiencyD, ptD)); @@ -306,9 +314,10 @@ struct HfTaskCorrelationDsHadrons { int poolBin = pairEntry.poolBin(); int ptBinD = o2::analysis::findBin(binsPtD, ptD); - if (bdtScorePrompt < mlOutputPrompt->at(ptBinD) || bdtScoreBkg > mlOutputBkg->at(ptBinD)) { + if (!isSelectedCandidate(ptBinD, bdtScorePrompt, bdtScoreBkg)) { continue; } + if (trackDcaXY > dcaXYTrackMax || trackDcaZ > dcaZTrackMax || trackTpcCrossedRows < nTpcCrossedRaws) { continue; } @@ -354,9 +363,10 @@ struct HfTaskCorrelationDsHadrons { int ptBinD = o2::analysis::findBin(binsPtD, ptD); bool isDsPrompt = candidate.isPrompt(); - if (bdtScorePrompt < mlOutputPrompt->at(ptBinD) || bdtScoreBkg > mlOutputBkg->at(ptBinD)) { + if (!isSelectedCandidate(ptBinD, bdtScorePrompt, bdtScoreBkg)) { continue; } + double efficiencyWeightD = 1.; if (applyEfficiency) { efficiencyWeightD = 1. / efficiencyD->at(o2::analysis::findBin(binsPtEfficiencyD, ptD)); @@ -393,9 +403,10 @@ struct HfTaskCorrelationDsHadrons { int ptBinD = o2::analysis::findBin(binsPtD, ptD); bool isPhysicalPrimary = pairEntry.isPhysicalPrimary(); - if (bdtScorePrompt < mlOutputPrompt->at(ptBinD) || bdtScoreBkg > mlOutputBkg->at(ptBinD)) { + if (!isSelectedCandidate(ptBinD, bdtScorePrompt, bdtScoreBkg)) { continue; } + if (trackDcaXY > dcaXYTrackMax || trackDcaZ > dcaZTrackMax || trackTpcCrossedRows < nTpcCrossedRaws) { continue; } @@ -415,9 +426,9 @@ struct HfTaskCorrelationDsHadrons { registry.fill(HIST("hCorrel2DVsPtSignalRegionMcRec"), deltaPhi, deltaEta, ptD, ptHadron, statusDsPrompt, poolBin, efficiencyWeight); if (isPhysicalPrimary) { registry.fill(HIST("hCorrel2DVsPtPhysicalPrimaryMcRec"), deltaPhi, deltaEta, ptD, ptHadron, statusDsPrompt, poolBin, efficiencyWeight); - if (statusDsPrompt == 1 && statusPromptHadron == 1) { + if (statusDsPrompt == 1 && statusPromptHadron == RecoDecay::OriginType::Prompt) { registry.fill(HIST("hCorrel2DVsPtSignalRegionPromptDsPromptHadronMcRec"), deltaPhi, deltaEta, ptD, ptHadron, poolBin, efficiencyWeight); - } else if (statusDsPrompt == 0 && statusPromptHadron == 2) { + } else if (statusDsPrompt == 0 && statusPromptHadron == RecoDecay::OriginType::NonPrompt) { registry.fill(HIST("hCorrel2DVsPtSignalRegionNonPromptDsNonPromptHadronMcRec"), deltaPhi, deltaEta, ptD, ptHadron, poolBin, efficiencyWeight); } } @@ -457,12 +468,12 @@ struct HfTaskCorrelationDsHadrons { registry.fill(HIST("hDeltaPhiPtIntMcGen"), deltaPhi); if (isDsPrompt) { registry.fill(HIST("hCorrel2DVsPtMcGenPrompt"), deltaPhi, deltaEta, ptD, ptHadron, poolBin); - if (statusPromptHadron == 1) { + if (statusPromptHadron == RecoDecay::OriginType::Prompt) { registry.fill(HIST("hCorrel2DVsPtMcGenPromptDsPromptHadron"), deltaPhi, deltaEta, ptD, ptHadron, poolBin); } } else { registry.fill(HIST("hCorrel2DVsPtMcGenNonPrompt"), deltaPhi, deltaEta, ptD, ptHadron, poolBin); - if (statusPromptHadron == 2) { + if (statusPromptHadron == RecoDecay::OriginType::NonPrompt) { registry.fill(HIST("hCorrel2DVsPtMcGenNonPromptDsNonPromptHadron"), deltaPhi, deltaEta, ptD, ptHadron, poolBin); } } @@ -487,9 +498,10 @@ struct HfTaskCorrelationDsHadrons { int poolBin = pairEntry.poolBin(); int ptBinD = o2::analysis::findBin(binsPtD, ptD); - if (bdtScorePrompt < mlOutputPrompt->at(ptBinD) || bdtScoreBkg > mlOutputBkg->at(ptBinD)) { + if (!isSelectedCandidate(ptBinD, bdtScorePrompt, bdtScoreBkg)) { continue; } + if (trackDcaXY > dcaXYTrackMax || trackDcaZ > dcaZTrackMax || trackTpcCrossedRows < nTpcCrossedRaws) { continue; } @@ -586,9 +598,10 @@ struct HfTaskCorrelationDsHadrons { int ptBinD = o2::analysis::findBin(binsPtD, ptD); bool isPhysicalPrimary = pairEntry.isPhysicalPrimary(); - if (bdtScorePrompt < mlOutputPrompt->at(ptBinD) || bdtScoreBkg > mlOutputBkg->at(ptBinD)) { + if (!isSelectedCandidate(ptBinD, bdtScorePrompt, bdtScoreBkg)) { continue; } + if (trackDcaXY > dcaXYTrackMax || trackDcaZ > dcaZTrackMax || trackTpcCrossedRows < nTpcCrossedRaws) { continue; } @@ -608,9 +621,9 @@ struct HfTaskCorrelationDsHadrons { registry.fill(HIST("hCorrel2DVsPtSignalRegionMcRec"), deltaPhi, deltaEta, ptD, ptHadron, statusDsPrompt, poolBin, efficiencyWeight); if (isPhysicalPrimary) { registry.fill(HIST("hCorrel2DVsPtPhysicalPrimaryMcRec"), deltaPhi, deltaEta, ptD, ptHadron, statusDsPrompt, poolBin, efficiencyWeight); - if (statusDsPrompt == 1 && statusPromptHadron == 1) { + if (statusDsPrompt == 1 && statusPromptHadron == RecoDecay::OriginType::Prompt) { registry.fill(HIST("hCorrel2DVsPtSignalRegionPromptDsPromptHadronMcRec"), deltaPhi, deltaEta, ptD, ptHadron, poolBin, efficiencyWeight); - } else if (statusDsPrompt == 0 && statusPromptHadron == 2) { + } else if (statusDsPrompt == 0 && statusPromptHadron == RecoDecay::OriginType::NonPrompt) { registry.fill(HIST("hCorrel2DVsPtSignalRegionNonPromptDsNonPromptHadronMcRec"), deltaPhi, deltaEta, ptD, ptHadron, poolBin, efficiencyWeight); } } @@ -720,7 +733,7 @@ struct HfTaskCorrelationDsHadrons { outputMl[iclass] = candidate.mlProbDsToPiKK()[classMl->at(iclass)]; } } - if (outputMl[0] < mlOutputPrompt->at(o2::analysis::findBin(binsPtD, candidate.pt())) || outputMl[2] > mlOutputBkg->at(o2::analysis::findBin(binsPtD, candidate.pt()))) { + if (outputMl[0] < mlOutputPromptMin->at(o2::analysis::findBin(binsPtD, candidate.pt())) || outputMl[0] < mlOutputPromptMax->at(o2::analysis::findBin(binsPtD, candidate.pt())) || outputMl[2] > mlOutputBkg->at(o2::analysis::findBin(binsPtD, candidate.pt()))) { continue; } @@ -802,7 +815,7 @@ struct HfTaskCorrelationDsHadrons { outputMl[iclass] = candidate.mlProbDsToPiKK()[classMl->at(iclass)]; } } - if (outputMl[0] < mlOutputPrompt->at(o2::analysis::findBin(binsPtD, candidate.pt())) || outputMl[2] > mlOutputBkg->at(o2::analysis::findBin(binsPtD, candidate.pt()))) { + if (outputMl[0] < mlOutputPromptMin->at(o2::analysis::findBin(binsPtD, candidate.pt())) || outputMl[0] < mlOutputPromptMax->at(o2::analysis::findBin(binsPtD, candidate.pt())) || outputMl[2] > mlOutputBkg->at(o2::analysis::findBin(binsPtD, candidate.pt()))) { continue; } auto collision = candidate.template collision_as>(); @@ -897,9 +910,9 @@ struct HfTaskCorrelationDsHadrons { } if (separateTrackOrigins) { int trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, mcParticle, true); - if (trackOrigin == 1) { // charm orgin + if (trackOrigin == RecoDecay::OriginType::Prompt) { // charm orgin registry.fill(HIST("hPtPrmPromptPartMcGen"), mcParticle.pt()); - } else if (trackOrigin == 2) { // beauty origin + } else if (trackOrigin == RecoDecay::OriginType::NonPrompt) { // beauty origin registry.fill(HIST("hPtPrmNonPromptPartMcGen"), mcParticle.pt()); } } @@ -938,9 +951,9 @@ struct HfTaskCorrelationDsHadrons { // check track origin if (separateTrackOrigins) { int trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, mcParticle, true); - if (trackOrigin == 1) { // charm orgin + if (trackOrigin == RecoDecay::OriginType::Prompt) { // charm orgin registry.fill(HIST("hPtPrmPromptPartMcRec"), track.pt()); - } else if (trackOrigin == 2) { // beauty origin + } else if (trackOrigin == RecoDecay::OriginType::NonPrompt) { // beauty origin registry.fill(HIST("hPtPrmNonPromptPartMcRec"), track.pt()); } } diff --git a/PWGHF/TableProducer/candidateCreatorSigmac0plusplus.cxx b/PWGHF/TableProducer/candidateCreatorSigmac0plusplus.cxx index e882dcd2dba..c3cfe2d6049 100644 --- a/PWGHF/TableProducer/candidateCreatorSigmac0plusplus.cxx +++ b/PWGHF/TableProducer/candidateCreatorSigmac0plusplus.cxx @@ -39,6 +39,7 @@ #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/DataModel/CandidateSelectionTables.h" #include "PWGHF/Utils/utilsBfieldCCDB.h" // for dca recalculation +#include "PWGHF/Utils/utilsEvSelHf.h" using namespace o2; using namespace o2::analysis; @@ -142,7 +143,8 @@ struct HfCandidateCreatorSigmac0plusplus { softPiCuts.SetMaxChi2PerClusterITS(softPiChi2Max); // ITS hitmap std::set setSoftPiItsHitMap; // = {}; - for (int idItsLayer = 0; idItsLayer < 7; idItsLayer++) { + constexpr std::size_t NLayersIts = 7; + for (std::size_t idItsLayer = 0u; idItsLayer < NLayersIts; idItsLayer++) { if (TESTBIT(softPiItsHitMap, idItsLayer)) { setSoftPiItsHitMap.insert(static_cast(idItsLayer)); } @@ -178,7 +180,7 @@ struct HfCandidateCreatorSigmac0plusplus { /// keep only the candidates flagged as possible Λc+ (and charge conj.) decaying into a charged pion, kaon and proton /// if not selected, skip it and go to the next one - if (!(candLc.hfflag() & 1 << aod::hf_cand_3prong::DecayType::LcToPKPi)) { + if (!(candLc.hfflag() & BIT(aod::hf_cand_3prong::DecayType::LcToPKPi))) { continue; } /// keep only the candidates Λc+ (and charge conj.) within the desired rapidity @@ -234,7 +236,7 @@ struct HfCandidateCreatorSigmac0plusplus { int chargeLc = candLc.template prong0_as().sign() + candLc.template prong1_as().sign() + candLc.template prong2_as().sign(); int chargeSoftPi = trackSoftPi.sign(); int8_t chargeSigmac = chargeLc + chargeSoftPi; - if (std::abs(chargeSigmac) != 0 && std::abs(chargeSigmac) != 2) { + if (std::abs(chargeSigmac) != o2::aod::hf_cand_sigmac::ChargeNull && std::abs(chargeSigmac) != o2::aod::hf_cand_sigmac::ChargePlusPlus) { /// this shall never happen LOG(fatal) << ">>> Sc candidate with charge +1 built, not possible! Charge Lc: " << chargeLc << ", charge soft pion: " << chargeSoftPi; } @@ -387,26 +389,31 @@ struct HfCandidateSigmac0plusplusMc { Produces rowMCMatchScRec; Produces rowMCMatchScGen; + o2::hf_evsel::HfEventSelectionMc hfEvSelMc; // mc event selection and monitoring + + using BCsInfo = soa::Join; using LambdacMc = soa::Join; // using LambdacMcGen = soa::Join; + using McCollisionsNoCents = soa::Join; + + PresliceUnsorted colPerMcCollision = aod::mccollisionlabel::mcCollisionId; - float zPvPosMax{1000.f}; + HistogramRegistry registry{"registry"}; /// @brief init function void init(InitContext& initContext) { const auto& workflows = initContext.services().get(); for (const DeviceSpec& device : workflows.devices) { - if (device.name.compare("hf-candidate-creator-3prong") == 0) { // here we assume that the hf-candidate-creator-3prong is in the workflow - for (const auto& option : device.options) { - if (option.name.compare("hfEvSel.zPvPosMax") == 0) { - zPvPosMax = option.defaultValue.get(); - break; - } - } + // here we assume that the hf-candidate-creator-3prong is in the workflow + // configure the ev. sel from that workflow + if (device.name.compare("hf-candidate-creator-3prong") == 0) { + hfEvSelMc.configureFromDevice(device); break; } } + + hfEvSelMc.addHistograms(registry); // particles monitoring } /// @brief dummy process function, to be run on data @@ -419,7 +426,9 @@ struct HfCandidateSigmac0plusplusMc { void processMc(aod::McParticles const& mcParticles, aod::TracksWMc const& tracks, LambdacMc const& candsLc /*, const LambdacMcGen&*/, - aod::McCollisions const&) + McCollisionsNoCents const& collInfos, + aod::McCollisions const&, + BCsInfo const&) { // Match reconstructed candidates. @@ -442,7 +451,7 @@ struct HfCandidateSigmac0plusplusMc { /// skip immediately the candidate Σc0,++ w/o a Λc+ matched to MC auto candLc = candSigmac.prongLc_as(); - if (!(std::abs(candLc.flagMcMatchRec()) == 1 << aod::hf_cand_3prong::DecayType::LcToPKPi)) { /// (*) + if (!(std::abs(candLc.flagMcMatchRec()) == BIT(aod::hf_cand_3prong::DecayType::LcToPKPi))) { /// (*) rowMCMatchScRec(flag, origin, -1.f, 0); continue; } @@ -453,25 +462,46 @@ struct HfCandidateSigmac0plusplusMc { candLc.prong2_as(), candSigmac.prong1_as()}; chargeSigmac = candSigmac.charge(); - if (chargeSigmac == 0) { + if (chargeSigmac == o2::aod::hf_cand_sigmac::ChargeNull) { /// candidate Σc0 /// 3 levels: /// 1. Σc0 → Λc+ π-,+ /// 2. Λc+ → pK-π+ direct (i) or Λc+ → resonant channel Λc± → p± K*, Λc± → Δ(1232)±± K∓ or Λc± → Λ(1520) π± (ii) /// 3. in case of (ii): resonant channel to pK-π+ + + /// look for Σc0(2455) indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, Pdg::kSigmaC0, std::array{+kProton, -kKPlus, +kPiPlus, -kPiPlus}, true, &sign, 3); if (indexRec > -1) { /// due to (*) no need to check anything for LambdaC - flag = sign * (1 << aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi); + flag = sign * BIT(aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi); + } + + /// look for Σc0(2520) + if (flag == 0) { + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, Pdg::kSigmaCStar0, std::array{+kProton, -kKPlus, +kPiPlus, -kPiPlus}, true, &sign, 3); + if (indexRec > -1) { /// due to (*) no need to check anything for LambdaC + flag = sign * BIT(aod::hf_cand_sigmac::DecayType::ScStar0ToPKPiPi); + } } - } else if (std::abs(chargeSigmac) == 2) { + + } else if (std::abs(chargeSigmac) == o2::aod::hf_cand_sigmac::ChargePlusPlus) { /// candidate Σc++ /// 3 levels: /// 1. Σc0 → Λc+ π-,+ /// 2. Λc+ → pK-π+ direct (i) or Λc+ → resonant channel Λc± → p± K*, Λc± → Δ(1232)±± K∓ or Λc± → Λ(1520) π± (ii) /// 3. in case of (ii): resonant channel to pK-π+ + + /// look for Σc++(2455) indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, Pdg::kSigmaCPlusPlus, std::array{+kProton, -kKPlus, +kPiPlus, +kPiPlus}, true, &sign, 3); if (indexRec > -1) { /// due to (*) no need to check anything for LambdaC - flag = sign * (1 << aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi); + flag = sign * BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi); + } + + /// look for Σc++(2520) + if (flag == 0) { + indexRec = RecoDecay::getMatchedMCRec(mcParticles, arrayDaughters, Pdg::kSigmaCStarPlusPlus, std::array{+kProton, -kKPlus, +kPiPlus, +kPiPlus}, true, &sign, 3); + if (indexRec > -1) { /// due to (*) no need to check anything for LambdaC + flag = sign * BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi); + } } } @@ -495,9 +525,16 @@ struct HfCandidateSigmac0plusplusMc { origin = 0; std::vector idxBhadMothers{}; + /// MC ev. selection done w/o centrality estimator + /// In case of need, readapt the code templetizing the function auto mcCollision = particle.mcCollision(); - float zPv = mcCollision.posZ(); - if (zPv < -zPvPosMax || zPv > zPvPosMax) { // to avoid counting particles in collisions with Zvtx larger than the maximum, we do not match them + float centrality{-1.f}; + uint16_t rejectionMask{0}; + const auto collSlice = collInfos.sliceBy(colPerMcCollision, mcCollision.globalIndex()); + rejectionMask = hfEvSelMc.getHfMcCollisionRejectionMask(mcCollision, collSlice, centrality); + hfEvSelMc.fillHistograms(mcCollision, rejectionMask, 0); + if (rejectionMask != 0) { + // at least one event selection not satisfied --> reject gen particles from this collision rowMCMatchScGen(flag, origin, -1); continue; } @@ -507,36 +544,63 @@ struct HfCandidateSigmac0plusplusMc { /// 2. Λc+ → pK-π+ direct (i) or Λc+ → resonant channel Λc± → p± K*, Λc± → Δ(1232)±± K∓ or Λc± → Λ(1520) π± (ii) /// 3. in case of (ii): resonant channel to pK-π+ /// → here we check level 1. first, and then levels 2. and 3. are inherited by the Λc+ → pK-π+ MC matching in candidateCreator3Prong.cxx + + /// look for Σc0,++(2455) if (RecoDecay::isMatchedMCGen(mcParticles, particle, Pdg::kSigmaC0, std::array{static_cast(Pdg::kLambdaCPlus), static_cast(kPiMinus)}, true, &sign, 1)) { - // generated Σc0 - // for (const auto& daughter : particle.daughters_as()) { + // generated Σc0(2455) for (const auto& daughter : particle.daughters_as()) { // look for Λc+ daughter decaying in pK-π+ if (std::abs(daughter.pdgCode()) != Pdg::kLambdaCPlus) continue; - // if (std::abs(daughter.flagMcMatchGen()) == (1 << aod::hf_cand_3prong::DecayType::LcToPKPi)) { if (RecoDecay::isMatchedMCGen(mcParticles, daughter, Pdg::kLambdaCPlus, std::array{+kProton, -kKPlus, +kPiPlus}, true, &sign, 2)) { /// Λc+ daughter decaying in pK-π+ found! - flag = sign * (1 << aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi); + flag = sign * BIT(aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi); break; } } } else if (RecoDecay::isMatchedMCGen(mcParticles, particle, Pdg::kSigmaCPlusPlus, std::array{static_cast(Pdg::kLambdaCPlus), static_cast(kPiPlus)}, true, &sign, 1)) { - // generated Σc++ - // for (const auto& daughter : particle.daughters_as()) { + // generated Σc++(2455) for (const auto& daughter : particle.daughters_as()) { // look for Λc+ daughter decaying in pK-π+ if (std::abs(daughter.pdgCode()) != Pdg::kLambdaCPlus) continue; - // if (std::abs(daughter.flagMcMatchGen()) == (1 << aod::hf_cand_3prong::DecayType::LcToPKPi)) { if (RecoDecay::isMatchedMCGen(mcParticles, daughter, Pdg::kLambdaCPlus, std::array{+kProton, -kKPlus, +kPiPlus}, true, &sign, 2)) { /// Λc+ daughter decaying in pK-π+ found! - flag = sign * (1 << aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi); + flag = sign * BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi); break; } } } + /// look for Σc0,++(2520) + if (flag == 0) { + if (RecoDecay::isMatchedMCGen(mcParticles, particle, Pdg::kSigmaCStar0, std::array{static_cast(Pdg::kLambdaCPlus), static_cast(kPiMinus)}, true, &sign, 1)) { + // generated Σc0(2520) + for (const auto& daughter : particle.daughters_as()) { + // look for Λc+ daughter decaying in pK-π+ + if (std::abs(daughter.pdgCode()) != Pdg::kLambdaCPlus) + continue; + if (RecoDecay::isMatchedMCGen(mcParticles, daughter, Pdg::kLambdaCPlus, std::array{+kProton, -kKPlus, +kPiPlus}, true, &sign, 2)) { + /// Λc+ daughter decaying in pK-π+ found! + flag = sign * BIT(aod::hf_cand_sigmac::DecayType::ScStar0ToPKPiPi); + break; + } + } + } else if (RecoDecay::isMatchedMCGen(mcParticles, particle, Pdg::kSigmaCStarPlusPlus, std::array{static_cast(Pdg::kLambdaCPlus), static_cast(kPiPlus)}, true, &sign, 1)) { + // generated Σc++(2520) + for (const auto& daughter : particle.daughters_as()) { + // look for Λc+ daughter decaying in pK-π+ + if (std::abs(daughter.pdgCode()) != Pdg::kLambdaCPlus) + continue; + if (RecoDecay::isMatchedMCGen(mcParticles, daughter, Pdg::kLambdaCPlus, std::array{+kProton, -kKPlus, +kPiPlus}, true, &sign, 2)) { + /// Λc+ daughter decaying in pK-π+ found! + flag = sign * BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi); + break; + } + } + } + } + /// check the origin (prompt vs. non-prompt) if (flag != 0) { origin = RecoDecay::getCharmHadronOrigin(mcParticles, particle, false, &idxBhadMothers); @@ -547,6 +611,12 @@ struct HfCandidateSigmac0plusplusMc { } else { rowMCMatchScGen(flag, origin, -1); } + + // debug + // if(origin != RecoDecay::OriginType::Prompt && origin != RecoDecay::OriginType::NonPrompt) { + // LOG(info) << " --> origin " << static_cast(origin) << ", flag " << static_cast(flag); + //} + } /// end loop over mcParticles } /// end processMc PROCESS_SWITCH(HfCandidateSigmac0plusplusMc, processMc, "Process MC", false); diff --git a/PWGJE/Tasks/dijetFinderQA.cxx b/PWGJE/Tasks/dijetFinderQA.cxx index 4f094c68cd9..4dd9292a1ac 100644 --- a/PWGJE/Tasks/dijetFinderQA.cxx +++ b/PWGJE/Tasks/dijetFinderQA.cxx @@ -48,71 +48,58 @@ struct DijetFinderQATask { HistogramRegistry registry; - Configurable setJetPtCut{"setJetPtCut", 20, "set jet pt minimum cut"}; - Configurable selectedJetsRadius{"selectedJetsRadius", 0.4, "resolution parameter for histograms without radius"}; - Configurable jetPtMax{"jetPtMax", 200., "set jet pT bin max"}; - Configurable vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"}; Configurable centralityMin{"centralityMin", -999.0, "minimum centrality"}; Configurable centralityMax{"centralityMax", 999.0, "maximum centrality"}; - Configurable jetAreaFractionMin{"jetAreaFractionMin", -99.0, "used to make a cut on the jet areas"}; - Configurable leadingConstituentPtMin{"leadingConstituentPtMin", -99.0, "minimum pT selection on jet constituent"}; - Configurable leadingConstituentPtMax{"leadingConstituentPtMax", 9999.0, "maximum pT selection on jet constituent"}; + Configurable eventSelections{"eventSelections", "sel8", "choose event selection"}; + Configurable vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"}; + Configurable trackSelections{"trackSelections", "globalTracks", "set track selections"}; Configurable trackPtMin{"trackPtMin", 0.15, "minimum pT acceptance for tracks"}; - Configurable trackPtMax{"trackPtMax", 100.0, "maximum pT acceptance for tracks"}; + Configurable trackPtMax{"trackPtMax", 1000.0, "maximum pT acceptance for tracks"}; Configurable trackEtaMin{"trackEtaMin", -0.9, "minimum eta acceptance for tracks"}; Configurable trackEtaMax{"trackEtaMax", 0.9, "maximum eta acceptance for tracks"}; + Configurable leadingConstituentPtMin{"leadingConstituentPtMin", -99.0, "minimum pT selection on jet constituent"}; + Configurable leadingConstituentPtMax{"leadingConstituentPtMax", 9999.0, "maximum pT selection on jet constituent"}; + Configurable setJetPtCut{"setJetPtCut", 20., "set jet pt minimum cut"}; + Configurable setPhiCut{"setPhiCut", 0.5, "set phicut"}; + Configurable jetR{"jetR", 0.4, "jet resolution parameter"}; + Configurable jetPtMin{"jetPtMin", 20.0, "minimum jet pT cut"}; + Configurable jetPtMax{"jetPtMax", 200., "set jet pT bin max"}; Configurable jetEtaMin{"jetEtaMin", -0.5, "minimum jet pseudorapidity"}; Configurable jetEtaMax{"jetEtaMax", 0.5, "maximum jet pseudorapidity"}; - Configurable jetPtMin{"jetPtMin", 20.0, "minimum jet pT cut"}; - Configurable jetR{"jetR", 0.4, "jet resolution parameter"}; - Configurable eventSelections{"eventSelections", "sel8", "choose event selection"}; - Configurable trackSelections{"trackSelections", "globalTracks", "set track selections"}; - Configurable checkMcCollisionIsMatched{"checkMcCollisionIsMatched", false, "0: count whole MCcollisions, 1: select MCcollisions which only have their correspond collisions"}; + Configurable jetAreaFractionMin{"jetAreaFractionMin", -99.0, "used to make a cut on the jet areas"}; - std::vector eventSelectionBits; + std::vector eventSelection; int trackSelection = -1; - std::vector jetPtBins; + std::vector dijetMassBins; void init(o2::framework::InitContext&) { - eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); + eventSelection = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); - auto jetPtTemp = 0.0; - jetPtBins.push_back(jetPtTemp); - while (jetPtTemp < jetPtMax) { - if (jetPtTemp < 100.0) { - jetPtTemp += 1.0; - jetPtBins.push_back(jetPtTemp); - } else if (jetPtTemp < 200.0) { - jetPtTemp += 5.0; - jetPtBins.push_back(jetPtTemp); - } else { - jetPtTemp += 10.0; - jetPtBins.push_back(jetPtTemp); - } + auto dijetMassTemp = 0.0; + while (dijetMassTemp <= 2 * jetPtMax) { + dijetMassBins.push_back(dijetMassTemp); + dijetMassTemp += 5.0; } - AxisSpec jetPtAxis = {jetPtBins, "M_{jj} (GeV/#it{c}^2)"}; + AxisSpec dijetMassAxis = {dijetMassBins, "M_{jj} (GeV/#it{c}^2)"}; if (doprocessDijetMCP) { - registry.add("h_part_jet_pt", "Jet pt MCP;;entries", {HistType::kTH1F, {jetPtAxis}}); - registry.add("h_part_dijet_mass", "Dijet invariant mass;;entries", {HistType::kTH1F, {jetPtAxis}}); + registry.add("h_part_dijet_mass", "Dijet invariant mass;;entries", {HistType::kTH1F, {dijetMassAxis}}); } if (doprocessDijetMCD) { - registry.add("h_detec_jet_pt", "Jet pt MCD;;entries", {HistType::kTH1F, {jetPtAxis}}); - registry.add("h_detec_dijet_mass", "Dijet invariant mass;;entries", {HistType::kTH1F, {jetPtAxis}}); + registry.add("h_detec_dijet_mass", "Dijet invariant mass;;entries", {HistType::kTH1F, {dijetMassAxis}}); } if (doprocessDijetData) { - registry.add("h_data_jet_pt", "Jet pt Data;;entries", {HistType::kTH1F, {jetPtAxis}}); - registry.add("h_data_dijet_mass", "Dijet invariant mass;;entries", {HistType::kTH1F, {jetPtAxis}}); + registry.add("h_data_dijet_mass", "Dijet invariant mass;;entries", {HistType::kTH1F, {dijetMassAxis}}); } if (doprocessDijetMCMatched) { - registry.add("h_matched_dijet_mass", "M_{jj matched};M_{jj part}; M_{jj det}", {HistType::kTH2F, {jetPtAxis, jetPtAxis}}); + registry.add("h_matched_dijet_mass", "M_{jj matched};M_{jj part}; M_{jj det}", {HistType::kTH2F, {dijetMassAxis, dijetMassAxis}}); } } @@ -120,8 +107,7 @@ struct DijetFinderQATask { Filter trackCuts = (aod::jtrack::pt >= trackPtMin && aod::jtrack::pt < trackPtMax && aod::jtrack::eta > trackEtaMin && aod::jtrack::eta < trackEtaMax); Filter eventCuts = (nabs(aod::jcollision::posZ) < vertexZCut && aod::jcollision::centrality >= centralityMin && aod::jcollision::centrality < centralityMax); Filter mcCollisionsFilter = nabs(aod::jmccollision::posZ) < vertexZCut; - Filter jetCuts = aod::jet::pt > jetPtMin&& aod::jet::r == nround(jetR.node() * 100.0f); // ********** - PresliceUnsorted> CollisionsPerMCPCollision = aod::jmccollisionlb::mcCollisionId; + Filter jetCuts = aod::jet::pt > jetPtMin&& aod::jet::r == nround(jetR.node() * 100.0f); /****************************************************************************************************************************************************************/ template @@ -160,30 +146,6 @@ struct DijetFinderQATask { return true; } - template - void fillJetPtHistogramsMCP(T const& jet) - { - if (jet.r() == round(selectedJetsRadius * 100.0f)) { - registry.fill(HIST("h_part_jet_pt"), jet.pt()); - } - } - - template - void fillJetPtHistogramsMCD(T const& jet) - { - if (jet.r() == round(selectedJetsRadius * 100.0f)) { - registry.fill(HIST("h_detec_jet_pt"), jet.pt()); - } - } - - template - void fillJetPtHistogramsData(T const& jet) - { - if (jet.r() == round(selectedJetsRadius * 100.0f)) { - registry.fill(HIST("h_data_jet_pt"), jet.pt()); - } - } - template void fillMassHistogramsMCP(T const& mass) { @@ -217,7 +179,6 @@ struct DijetFinderQATask { { std::vector> jetPtcuts; for (auto& jet : jets) { - fillJetPtHistogramsMCP(jet); jetPtcuts.push_back({jet.pt(), jet.eta(), jet.phi()}); } @@ -227,18 +188,14 @@ struct DijetFinderQATask { for (size_t i = 1; i < jetPtcuts.size() && !found_pair; i++) { auto& candidate_jet = jetPtcuts[i]; - Double_t dphi = fabs(candidate_jet[2] - leading_jet[2]); - if (dphi > M_PI) { - dphi = 2 * M_PI - dphi; - } - if (dphi > 2 * M_PI / 3) { - double pt1 = leading_jet[0]; - double pt2 = candidate_jet[0]; - double eta1 = leading_jet[1]; - double eta2 = candidate_jet[1]; - double phi1 = leading_jet[2]; - double phi2 = candidate_jet[2]; - double dijet_mass = sqrt(2 * pt1 * pt2 * (cosh(eta1 - eta2) - cos(phi1 - phi2))); + Double_t dphi = fabs(leading_jet[2] - candidate_jet[2]); + Double_t deta = fabs(leading_jet[1] - candidate_jet[1]); + Double_t condition = fabs(dphi - M_PI); + + if (condition < setPhiCut * M_PI) { + Double_t pt1 = leading_jet[0]; + Double_t pt2 = candidate_jet[0]; + Double_t dijet_mass = sqrt(2 * pt1 * pt2 * (cosh(deta) - cos(dphi))); fillMassHistogramsMCP(dijet_mass); found_pair = true; } @@ -249,12 +206,11 @@ struct DijetFinderQATask { void processDijetMCD(soa::Filtered::iterator const& collision, soa::Filtered const& jets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { return; } std::vector> jetPtcuts; for (auto& jet : jets) { - fillJetPtHistogramsMCD(jet); jetPtcuts.push_back({jet.pt(), jet.eta(), jet.phi()}); } @@ -264,18 +220,14 @@ struct DijetFinderQATask { for (size_t i = 1; i < jetPtcuts.size() && !found_pair; i++) { auto& candidate_jet = jetPtcuts[i]; - Double_t dphi = fabs(candidate_jet[2] - leading_jet[2]); - if (dphi > M_PI) { - dphi = 2 * M_PI - dphi; - } - if (dphi > 2 * M_PI / 3) { - double pt1 = leading_jet[0]; - double pt2 = candidate_jet[0]; - double eta1 = leading_jet[1]; - double eta2 = candidate_jet[1]; - double phi1 = leading_jet[2]; - double phi2 = candidate_jet[2]; - double dijet_mass = sqrt(2 * pt1 * pt2 * (cosh(eta1 - eta2) - cos(phi1 - phi2))); + Double_t dphi = fabs(leading_jet[2] - candidate_jet[2]); + Double_t deta = fabs(leading_jet[1] - candidate_jet[1]); + Double_t condition = fabs(dphi - M_PI); + + if (condition < setPhiCut * M_PI) { + Double_t pt1 = leading_jet[0]; + Double_t pt2 = candidate_jet[0]; + Double_t dijet_mass = sqrt(2 * pt1 * pt2 * (cosh(deta) - cos(dphi))); fillMassHistogramsMCD(dijet_mass); found_pair = true; } @@ -286,13 +238,12 @@ struct DijetFinderQATask { void processDijetData(soa::Filtered::iterator const& collision, soa::Filtered const& jets) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { return; } std::vector> jetPtcuts; for (auto& jet : jets) { - fillJetPtHistogramsData(jet); jetPtcuts.push_back({jet.pt(), jet.eta(), jet.phi()}); } @@ -302,18 +253,14 @@ struct DijetFinderQATask { for (size_t i = 1; i < jetPtcuts.size() && !found_pair; i++) { auto& candidate_jet = jetPtcuts[i]; - Double_t dphi = fabs(candidate_jet[2] - leading_jet[2]); - if (dphi > M_PI) { - dphi = 2 * M_PI - dphi; - } - if (dphi > 2 * M_PI / 3) { - double pt1 = leading_jet[0]; - double pt2 = candidate_jet[0]; - double eta1 = leading_jet[1]; - double eta2 = candidate_jet[1]; - double phi1 = leading_jet[2]; - double phi2 = candidate_jet[2]; - double dijet_mass = sqrt(2 * pt1 * pt2 * (cosh(eta1 - eta2) - cos(phi1 - phi2))); + Double_t dphi = fabs(leading_jet[2] - candidate_jet[2]); + Double_t deta = fabs(leading_jet[1] - candidate_jet[1]); + Double_t condition = fabs(dphi - M_PI); + + if (condition < setPhiCut * M_PI) { + Double_t pt1 = leading_jet[0]; + Double_t pt2 = candidate_jet[0]; + Double_t dijet_mass = sqrt(2 * pt1 * pt2 * (cosh(deta) - cos(dphi))); fillMassHistogramsData(dijet_mass); found_pair = true; } @@ -327,7 +274,7 @@ struct DijetFinderQATask { soa::Filtered> const& mcdjets, JetMCPTable const&, aod::JetTracks const&, aod::JetParticles const&) { - if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) { return; } @@ -355,26 +302,20 @@ struct DijetFinderQATask { auto& candidate_jet_D = jetPtcuts_D[i]; auto& candidate_jet_P = jetPtcuts_P[i]; - Double_t dphi_D = fabs(candidate_jet_D[2] - leading_jet_D[2]); - if (dphi_D > M_PI) { - dphi_D = 2 * M_PI - dphi_D; - } - if (dphi_D > 2 * M_PI / 3) { + Double_t dphi_D = fabs(leading_jet_D[2] - candidate_jet_D[2]); + Double_t deta_D = fabs(leading_jet_D[1] - candidate_jet_D[1]); + Double_t dphi_P = fabs(leading_jet_P[2] - candidate_jet_P[2]); + Double_t deta_P = fabs(leading_jet_P[1] - candidate_jet_P[1]); + Double_t condition = fabs(dphi_D - M_PI); + + if (condition < setPhiCut * M_PI) { double pt1_D = leading_jet_D[0]; double pt2_D = candidate_jet_D[0]; - double eta1_D = leading_jet_D[1]; - double eta2_D = candidate_jet_D[1]; - double phi1_D = leading_jet_D[2]; - double phi2_D = candidate_jet_D[2]; - double dijet_mass_D = sqrt(2 * pt1_D * pt2_D * (cosh(eta1_D - eta2_D) - cos(phi1_D - phi2_D))); + double dijet_mass_D = sqrt(2 * pt1_D * pt2_D * (cosh(deta_D) - cos(dphi_D))); double pt1_P = leading_jet_P[0]; double pt2_P = candidate_jet_P[0]; - double eta1_P = leading_jet_P[1]; - double eta2_P = candidate_jet_P[1]; - double phi1_P = leading_jet_P[2]; - double phi2_P = candidate_jet_P[2]; - double dijet_mass_P = sqrt(2 * pt1_P * pt2_P * (cosh(eta1_P - eta2_P) - cos(phi1_P - phi2_P))); + double dijet_mass_P = sqrt(2 * pt1_P * pt2_P * (cosh(deta_P) - cos(dphi_P))); fillMassHistogramsMCMatched(dijet_mass_P, dijet_mass_D); found_pair = true; diff --git a/PWGJE/Tasks/jetChargedV2.cxx b/PWGJE/Tasks/jetChargedV2.cxx index c88f40cb990..cb98a8bef7b 100644 --- a/PWGJE/Tasks/jetChargedV2.cxx +++ b/PWGJE/Tasks/jetChargedV2.cxx @@ -80,6 +80,7 @@ struct JetChargedV2 { Configurable> jetRadii{"jetRadii", std::vector{0.4}, "jet resolution parameters"}; Configurable vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"}; + Configurable trackDcaZmax{"trackDcaZmax", 99, "additional cut on dcaZ to PV for tracks; uniformTracks in particular don't cut on this at all"}; Configurable centralityMin{"centralityMin", -999.0, "minimum centrality"}; Configurable centralityMax{"centralityMax", 999.0, "maximum centrality"}; Configurable trackPtMin{"trackPtMin", 0.15, "minimum pT acceptance for tracks"}; @@ -96,6 +97,9 @@ struct JetChargedV2 { Configurable jetEtaMax{"jetEtaMax", 0.9, "maximum eta acceptance for jets"}; Configurable jetRadius{"jetRadius", 0.2, "jet resolution parameters"}; + Configurable localRhoFitPtMin{"localRhoFitPtMin", 0.2, "Minimum track pT used for local rho fluctuation fit"}; + Configurable localRhoFitPtMax{"localRhoFitPtMax", 5, "Maximum track pT used for local rho fluctuation fit"}; + Configurable randomConeR{"randomConeR", 0.4, "size of random Cone for estimating background fluctuations"}; Configurable trackOccupancyInTimeRangeMax{"trackOccupancyInTimeRangeMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range; only applied to reconstructed collisions (data and mcd jets), not mc collisions (mcp jets)"}; Configurable trackOccupancyInTimeRangeMin{"trackOccupancyInTimeRangeMin", -999999, "minimum occupancy of tracks in neighbouring collisions in a given time range; only applied to reconstructed collisions (data and mcd jets), not mc collisions (mcp jets)"}; @@ -173,12 +177,14 @@ struct JetChargedV2 { jetPtBins.push_back(jetPtTemp); jetPtBinsRhoAreaSub.push_back(jetPtTemp); while (jetPtTemp < jetPtMax) { - if (jetPtTemp < 100.0) { + double jetPtTempA = 100.0; + double jetPtTempB = 100.0; + if (jetPtTemp < jetPtTempA) { jetPtTemp += 1.0; jetPtBins.push_back(jetPtTemp); jetPtBinsRhoAreaSub.push_back(jetPtTemp); jetPtBinsRhoAreaSub.push_back(-jetPtTemp); - } else if (jetPtTemp < 200.0) { + } else if (jetPtTemp < jetPtTempB) { jetPtTemp += 5.0; jetPtBins.push_back(jetPtTemp); jetPtBinsRhoAreaSub.push_back(jetPtTemp); @@ -204,7 +210,18 @@ struct JetChargedV2 { eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); + //< Track efficiency plots >// registry.add("h_collisions", "event status;event status;entries", {HistType::kTH1F, {{4, 0.0, 4.0}}}); + registry.add("h2_centrality_collisions", "centrality vs collisions; centrality; collisions", {HistType::kTH2F, {{120, -10., 110.}, {4, 0.0, 4.0}}}); + registry.add("h2_centrality_track_pt", "centrality vs track pT; centrality; #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{1200, -10.0, 110.0}, {200, 0., 200.}}}); + registry.add("h2_centrality_track_eta", "centrality vs track #eta; centrality; #eta_{track}", {HistType::kTH2F, {{1200, -10.0, 110.0}, {100, -1.0, 1.0}}}); + registry.add("h2_centrality_track_phi", "centrality vs track #varphi; centrality; #varphi_{track}", {HistType::kTH2F, {{1200, -10.0, 110.0}, {160, -1.0, 7.}}}); + registry.add("h2_centrality_track_energy", "centrality vs track energy; centrality; Energy GeV", {HistType::kTH2F, {{120, -10., 110.}, {100, 0.0, 100.0}}}); + registry.add("h2_track_pt_track_sigmapt", "#sigma(#it{p}_{T})/#it{p}_{T}; #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{100, 0., 10.}, {100000, 0.0, 100.0}}}); + registry.add("h2_track_pt_high_track_sigmapt", "#sigma(#it{p}_{T})/#it{p}_{T}; #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{90, 10., 100.}, {100000, 0.0, 100.0}}}); + registry.add("h2_track_pt_track_sigma1overpt", "#sigma(1/#it{p}_{T}); #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{100, 0., 10.}, {1000, 0.0, 10.0}}}); + registry.add("h2_track_pt_high_track_sigma1overpt", "#sigma(1/#it{p}_{T}); #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{90, 10., 100.}, {1000, 0.0, 10.0}}}); + //< \sigma p_T at local rho test plot > registry.add("h_accept_Track", "all and accept track;Track;entries", {HistType::kTH1F, {{10, 0.0, 10.0}}}); registry.add("h_accept_Track_init", "all and accept track;Track;entries", {HistType::kTH1F, {{10, 0.0, 10.0}}}); @@ -251,10 +268,6 @@ struct JetChargedV2 { registry.add("h3_centrality_rhovsphi_phi", "centrality; #rho(#varphi); #Delta#varphi_{jet}", {HistType::kTH3F, {{120, -10.0, 110.0}, {200, 0.0, 200.0}, {40, 0., o2::constants::math::TwoPI}}}); //< \sigma p_T at local rho test plot | end > - registry.add("h2_centrality_track_pt", "centrality vs track pT; centrality; #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{1200, -10.0, 110.0}, {200, 0., 200.}}}); - registry.add("h2_centrality_track_eta", "centrality vs track #eta; centrality; #eta_{track}", {HistType::kTH2F, {{1200, -10.0, 110.0}, {100, -1.0, 1.0}}}); - registry.add("h2_centrality_track_phi", "centrality vs track #varphi; centrality; #varphi_{track}", {HistType::kTH2F, {{1200, -10.0, 110.0}, {160, -1.0, 7.}}}); - registry.add("h_jet_pt_rhoareasubtracted", "jet pT rhoareasubtracted;#it{p}_{T,jet} (GeV/#it{c}); entries", {HistType::kTH1F, {jetPtAxisRhoAreaSub}}); registry.add("h_jet_pt_rholocal", "jet pT rholocal;#it{p}_{T,jet} (GeV/#it{c});entries", {HistType::kTH1F, {jetPtAxisRhoAreaSub}}); @@ -270,8 +283,6 @@ struct JetChargedV2 { registry.add("h2_centrality_deltapT_RandomCornPhi_RCprocess_rhorandomconewithoutleadingjet", "#it{p}_{T,random cone} - #it{area, random cone} * #it{rho}; #Delta#varphi_{jet}", {HistType::kTH2F, {{400, -200.0, 200.0}, {100, 0., o2::constants::math::TwoPI}}}); registry.add("h3_centrality_deltapT_RandomCornPhi_localrhovsphiwithoutleadingjet", "centrality; #it{p}_{T,random cone} - #it{area, random cone} * #it{rho}(#varphi); #Delta#varphi_{jet}", {HistType::kTH3F, {{100, 0.0, 100.0}, {400, -200.0, 200.0}, {100, 0., o2::constants::math::TwoPI}}}); - registry.add("h3_centrality_deltapT_RandomCornPhi_localrhovsphiwithoutoneleadingjet", "centrality; #it{p}_{T,random cone} - #it{area, random cone} * #it{rho}(#varphi); #Delta#varphi_{jet}", {HistType::kTH3F, {{100, 0.0, 100.0}, {400, -200.0, 200.0}, {100, 0., o2::constants::math::TwoPI}}}); - registry.add("h3_centrality_deltapT_RandomCornPhi_localrhovsphiwithouttwoleadingjet", "centrality; #it{p}_{T,random cone} - #it{area, random cone} * #it{rho}(#varphi); #Delta#varphi_{jet}", {HistType::kTH3F, {{100, 0.0, 100.0}, {400, -200.0, 200.0}, {100, 0., o2::constants::math::TwoPI}}}); //< bkg sub plot | end >// //< median rho >// registry.add("h_jet_pt_in_plane_v2", "jet pT;#it{p}^{in-plane}_{T,jet} (GeV/#it{c});entries", {HistType::kTH1F, {jetPtAxisRhoAreaSub}}); @@ -331,14 +342,16 @@ struct JetChargedV2 { template bool isAcceptedJet(U const& jet) { - if (jetAreaFractionMin > -98.0) { + double jetAreaFractionMinCfgMin = -98.0; + double jetAreaFractionMinCfgMax = 9998.0; + if (jetAreaFractionMin > jetAreaFractionMinCfgMin) { if (jet.area() < jetAreaFractionMin * o2::constants::math::PI * (jet.r() / 100.0) * (jet.r() / 100.0)) { return false; } } bool checkConstituentPt = true; - bool checkConstituentMinPt = (leadingConstituentPtMin > -98.0); - bool checkConstituentMaxPt = (leadingConstituentPtMax < 9998.0); + bool checkConstituentMinPt = (leadingConstituentPtMin > jetAreaFractionMinCfgMin); + bool checkConstituentMaxPt = (leadingConstituentPtMax < jetAreaFractionMinCfgMax); if (!checkConstituentMinPt && !checkConstituentMaxPt) { checkConstituentPt = false; } @@ -374,6 +387,24 @@ struct JetChargedV2 { return false; } + template + void fillTrackHistograms(T const& collision, U const& tracks, float weight = 1.0) + { + for (auto const& track : tracks) { + if (!(jetderiveddatautilities::selectTrack(track, trackSelection) && jetderiveddatautilities::selectTrackDcaZ(track, trackDcaZmax))) { + continue; + } + registry.fill(HIST("h2_centrality_track_pt"), collision.centrality(), track.pt(), weight); + registry.fill(HIST("h2_centrality_track_eta"), collision.centrality(), track.eta(), weight); + registry.fill(HIST("h2_centrality_track_phi"), collision.centrality(), track.phi(), weight); + registry.fill(HIST("h2_centrality_track_energy"), collision.centrality(), track.energy(), weight); + registry.fill(HIST("h2_track_pt_track_sigma1overpt"), track.pt(), track.sigma1Pt(), weight); + registry.fill(HIST("h2_track_pt_track_sigmapt"), track.pt(), track.sigma1Pt() * track.pt(), weight); + registry.fill(HIST("h2_track_pt_high_track_sigma1overpt"), track.pt(), track.sigma1Pt(), weight); + registry.fill(HIST("h2_track_pt_high_track_sigmapt"), track.pt(), track.sigma1Pt() * track.pt(), weight); + } + } + void fillLeadingJetQA(double leadingJetPt, double leadingJetPhi, double leadingJetEta) { registry.fill(HIST("leadJetPt"), leadingJetPt); @@ -403,7 +434,12 @@ struct JetChargedV2 { int detInd = detId * 4 + cfgnTotalSystem * 4 * (nmode - 2); int refAInd = refAId * 4 + cfgnTotalSystem * 4 * (nmode - 2); int refBInd = refBId * 4 + cfgnTotalSystem * 4 * (nmode - 2); - if (nmode == 2) { + int cfgNmodA = 2; + int cfgNmodB = 3; + int evtPlnAngleA = 7; + int evtPlnAngleB = 3; + int evtPlnAngleC = 5; + if (nmode == cfgNmodA) { if (collision.qvecAmp()[detId] > 1e-8 || collision.qvecAmp()[refAId] < 1e-8 || collision.qvecAmp()[refBId] < 1e-8) { histosQA.fill(HIST("histQvecUncorV2"), collision.qvecRe()[detInd], collision.qvecIm()[detInd], collision.cent()); histosQA.fill(HIST("histQvecRectrV2"), collision.qvecRe()[detInd + 1], collision.qvecIm()[detInd + 1], collision.cent()); @@ -419,7 +455,7 @@ struct JetChargedV2 { histosQA.fill(HIST("histEvtPlRes_SigRefBV2"), helperEP.GetResolution(helperEP.GetEventPlane(collision.qvecRe()[detInd + 3], collision.qvecIm()[detInd + 3], nmode), helperEP.GetEventPlane(collision.qvecRe()[refBInd + 3], collision.qvecIm()[refBInd + 3], nmode), nmode), collision.cent()); histosQA.fill(HIST("histEvtPlRes_RefARefBV2"), helperEP.GetResolution(helperEP.GetEventPlane(collision.qvecRe()[refAInd + 3], collision.qvecIm()[refAInd + 3], nmode), helperEP.GetEventPlane(collision.qvecRe()[refBInd + 3], collision.qvecIm()[refBInd + 3], nmode), nmode), collision.cent()); } - } else if (nmode == 3) { + } else if (nmode == cfgNmodB) { histosQA.fill(HIST("histQvecUncorV3"), collision.qvecRe()[detInd], collision.qvecIm()[detInd], collision.cent()); histosQA.fill(HIST("histQvecRectrV3"), collision.qvecRe()[detInd + 1], collision.qvecIm()[detInd + 1], collision.cent()); histosQA.fill(HIST("histQvecTwistV3"), collision.qvecRe()[detInd + 2], collision.qvecIm()[detInd + 2], collision.cent()); @@ -435,7 +471,7 @@ struct JetChargedV2 { histosQA.fill(HIST("histEvtPlRes_RefARefBV3"), helperEP.GetResolution(helperEP.GetEventPlane(collision.qvecRe()[refAInd + 3], collision.qvecIm()[refAInd + 3], nmode), helperEP.GetEventPlane(collision.qvecRe()[refBInd + 3], collision.qvecIm()[refBInd + 3], nmode), nmode), collision.cent()); } - if (nmode == 2) { + if (nmode == cfgNmodA) { double phiMinusPsi2; if (collision.qvecAmp()[detId] < 1e-8) { continue; @@ -455,8 +491,7 @@ struct JetChargedV2 { registry.fill(HIST("h2_centrality_jet_pt_rhoareasubtracted"), collision.centrality(), jet.pt() - (collision.rho() * jet.area()), 1.0); phiMinusPsi2 = jet.phi() - ep2; - - if ((phiMinusPsi2 < o2::constants::math::PIQuarter) || (phiMinusPsi2 >= 7 * o2::constants::math::PIQuarter) || (phiMinusPsi2 >= 3 * o2::constants::math::PIQuarter && phiMinusPsi2 < 5 * o2::constants::math::PIQuarter)) { + if ((phiMinusPsi2 < o2::constants::math::PIQuarter) || (phiMinusPsi2 >= evtPlnAngleA * o2::constants::math::PIQuarter) || (phiMinusPsi2 >= evtPlnAngleB * o2::constants::math::PIQuarter && phiMinusPsi2 < evtPlnAngleC * o2::constants::math::PIQuarter)) { registry.fill(HIST("h_jet_pt_in_plane_v2"), jet.pt() - (collision.rho() * jet.area()), 1.0); registry.fill(HIST("h2_centrality_jet_pt_in_plane_v2"), collision.centrality(), jet.pt() - (collision.rho() * jet.area()), 1.0); } else { @@ -464,7 +499,7 @@ struct JetChargedV2 { registry.fill(HIST("h2_centrality_jet_pt_out_of_plane_v2"), collision.centrality(), jet.pt() - (collision.rho() * jet.area()), 1.0); } } - } else if (nmode == 3) { + } else if (nmode == cfgNmodB) { double phiMinusPsi3; float ep3 = helperEP.GetEventPlane(collision.qvecRe()[detInd], collision.qvecIm()[detInd], nmode); for (auto const& jet : jets) { @@ -479,7 +514,7 @@ struct JetChargedV2 { } phiMinusPsi3 = jet.phi() - ep3; - if ((phiMinusPsi3 < o2::constants::math::PIQuarter) || (phiMinusPsi3 >= 7 * o2::constants::math::PIQuarter) || (phiMinusPsi3 >= 3 * o2::constants::math::PIQuarter && phiMinusPsi3 < 5 * o2::constants::math::PIQuarter)) { + if ((phiMinusPsi3 < o2::constants::math::PIQuarter) || (phiMinusPsi3 >= evtPlnAngleA * o2::constants::math::PIQuarter) || (phiMinusPsi3 >= evtPlnAngleB * o2::constants::math::PIQuarter && phiMinusPsi3 < evtPlnAngleC * o2::constants::math::PIQuarter)) { registry.fill(HIST("h_jet_pt_in_plane_v3"), jet.pt() - (collision.rho() * jet.area()), 1.0); registry.fill(HIST("h2_centrality_jet_pt_in_plane_v3"), collision.centrality(), jet.pt() - (collision.rho() * jet.area()), 1.0); } else { @@ -520,7 +555,7 @@ struct JetChargedV2 { int nTrk = 0; if (jets.size() > 0) { for (auto const& track : tracks) { - if (jetderiveddatautilities::selectTrack(track, trackSelection) && (std::fabs(track.eta() - leadingJetEta) > jetRadius) && track.pt() >= 0.2 && track.pt() <= 5.) { + if (jetderiveddatautilities::selectTrack(track, trackSelection) && (std::fabs(track.eta() - leadingJetEta) > jetRadius) && track.pt() >= localRhoFitPtMin && track.pt() <= localRhoFitPtMax) { registry.fill(HIST("h_accept_Track"), 2.5); nTrk += 1; } @@ -537,7 +572,7 @@ struct JetChargedV2 { if (jets.size() > 0) { for (auto const& trackfit : tracks) { registry.fill(HIST("h_accept_Track"), 0.5); - if (jetderiveddatautilities::selectTrack(trackfit, trackSelection) && (std::fabs(trackfit.eta() - leadingJetEta) > jetRadius) && trackfit.pt() >= 0.2 && trackfit.pt() <= 5.) { + if (jetderiveddatautilities::selectTrack(trackfit, trackSelection) && (std::fabs(trackfit.eta() - leadingJetEta) > jetRadius) && trackfit.pt() >= localRhoFitPtMin && trackfit.pt() <= localRhoFitPtMax) { registry.fill(HIST("h_accept_Track_Fit"), 0.5); fitTrack += 1; } @@ -545,7 +580,7 @@ struct JetChargedV2 { for (auto const& track : tracks) { registry.fill(HIST("h_accept_Track"), 1.5); - if (jetderiveddatautilities::selectTrack(track, trackSelection) && (std::fabs(track.eta() - leadingJetEta) > jetRadius) && track.pt() >= 0.2 && track.pt() <= 5.) { + if (jetderiveddatautilities::selectTrack(track, trackSelection) && (std::fabs(track.eta() - leadingJetEta) > jetRadius) && track.pt() >= localRhoFitPtMin && track.pt() <= localRhoFitPtMax) { accptTrack += 1; registry.fill(HIST("h_accept_Track"), 2.5); hPtsumSumptFit->Fill(track.phi(), track.pt()); @@ -563,14 +598,19 @@ struct JetChargedV2 { double ep2 = 0.; double ep3 = 0.; + int cfgNmodA = 2; + int cfgNmodB = 3; + int evtPlnAngleA = 7; + int evtPlnAngleB = 3; + int evtPlnAngleC = 5; for (uint i = 0; i < cfgnMods->size(); i++) { int nmode = cfgnMods->at(i); int detInd = detId * 4 + cfgnTotalSystem * 4 * (nmode - 2); - if (nmode == 2) { + if (nmode == cfgNmodA) { if (collision.qvecAmp()[detId] > 1e-8) { ep2 = helperEP.GetEventPlane(collision.qvecRe()[detInd + 3], collision.qvecIm()[detInd + 3], nmode); } - } else if (nmode == 3) { + } else if (nmode == cfgNmodB) { if (collision.qvecAmp()[detId] > 1e-8) { ep3 = helperEP.GetEventPlane(collision.qvecRe()[detInd + 3], collision.qvecIm()[detInd + 3], nmode); } @@ -609,7 +649,8 @@ struct JetChargedV2 { temppara[2] = fFitModulationV2v3->GetParameter(2); temppara[3] = fFitModulationV2v3->GetParameter(3); temppara[4] = fFitModulationV2v3->GetParameter(4); - for (int i = 1; i <= 5; i++) { + int paraNum = 5; + for (int i = 1; i <= paraNum; i++) { registry.fill(HIST("h2_evt_fitpara"), evtnum, i - 0.5, temppara[i - 1]); } @@ -652,9 +693,13 @@ struct JetChargedV2 { registry.fill(HIST("h2_PChi2_CombinFit"), cDF, chiSqr / (static_cast(nDF))); registry.fill(HIST("Thn_PChi2_CombinFitCent"), collision.centrality(), cDF, chiSqr / (static_cast(nDF))); double evtcent = collision.centrality(); - if (evtcent >= 0 && evtcent <= 5) { + int evtCentAreaMin = 0; + int evtCentAreaMax = 5; + int evtMidAreaMin = 30; + int evtMidAreaMax = 50; + if (evtcent >= evtCentAreaMin && evtcent <= evtCentAreaMax) { registry.fill(HIST("h2_PChi2_CombinFitA"), cDF, chiSqr / (static_cast(nDF))); - } else if (evtcent >= 30 && evtcent <= 50) { + } else if (evtcent >= evtMidAreaMin && evtcent <= evtMidAreaMax) { registry.fill(HIST("h2_PChi2_CombinFitB"), cDF, chiSqr / (static_cast(nDF))); } for (uint i = 0; i < cfgnMods->size(); i++) { @@ -680,7 +725,7 @@ struct JetChargedV2 { registry.fill(HIST("h2_phi_rholocal_cent"), collision.centrality(), rholocal, 1.0); registry.fill(HIST("h3_centrality_localrho_phi"), collision.centrality(), rholocal, jet.phi() - ep2); - if (nmode == 2) { + if (nmode == cfgNmodA) { registry.fill(HIST("h_jet_pt_rholocal"), jet.pt() - (rholocal * jet.area()), 1.0); double phiMinusPsi2; @@ -692,14 +737,14 @@ struct JetChargedV2 { registry.fill(HIST("h2_phi_rholocal"), jet.phi() - ep2, rholocal, 1.0); registry.fill(HIST("h_jet_pt_inclusive_v2_rho"), jet.pt() - (rholocal * jet.area()), 1.0); - if ((phiMinusPsi2 < o2::constants::math::PIQuarter) || (phiMinusPsi2 >= 7 * o2::constants::math::PIQuarter) || (phiMinusPsi2 >= 3 * o2::constants::math::PIQuarter && phiMinusPsi2 < 5 * o2::constants::math::PIQuarter)) { + if ((phiMinusPsi2 < o2::constants::math::PIQuarter) || (phiMinusPsi2 >= evtPlnAngleA * o2::constants::math::PIQuarter) || (phiMinusPsi2 >= evtPlnAngleB * o2::constants::math::PIQuarter && phiMinusPsi2 < evtPlnAngleC * o2::constants::math::PIQuarter)) { registry.fill(HIST("h_jet_pt_in_plane_v2_rho"), jet.pt() - (rholocal * jet.area()), 1.0); registry.fill(HIST("h2_centrality_jet_pt_in_plane_v2_rho"), collision.centrality(), jet.pt() - (rholocal * jet.area()), 1.0); } else { registry.fill(HIST("h_jet_pt_out_of_plane_v2_rho"), jet.pt() - (rholocal * jet.area()), 1.0); registry.fill(HIST("h2_centrality_jet_pt_out_of_plane_v2_rho"), collision.centrality(), jet.pt() - (rholocal * jet.area()), 1.0); } - } else if (nmode == 3) { + } else if (nmode == cfgNmodB) { double phiMinusPsi3; if (collision.qvecAmp()[detId] < 1e-8) { continue; @@ -707,7 +752,7 @@ struct JetChargedV2 { ep3 = helperEP.GetEventPlane(collision.qvecRe()[detInd], collision.qvecIm()[detInd], nmode); phiMinusPsi3 = jet.phi() - ep3; - if ((phiMinusPsi3 < o2::constants::math::PIQuarter) || (phiMinusPsi3 >= 7 * o2::constants::math::PIQuarter) || (phiMinusPsi3 >= 3 * o2::constants::math::PIQuarter && phiMinusPsi3 < 5 * o2::constants::math::PIQuarter)) { + if ((phiMinusPsi3 < o2::constants::math::PIQuarter) || (phiMinusPsi3 >= evtPlnAngleA * o2::constants::math::PIQuarter) || (phiMinusPsi3 >= evtPlnAngleB * o2::constants::math::PIQuarter && phiMinusPsi3 < evtPlnAngleC * o2::constants::math::PIQuarter)) { registry.fill(HIST("h_jet_pt_in_plane_v3_rho"), jet.pt() - (rholocal * jet.area()), 1.0); registry.fill(HIST("h2_centrality_jet_pt_in_plane_v3_rho"), collision.centrality(), jet.pt() - (rholocal * jet.area()), 1.0); } else { @@ -723,12 +768,11 @@ struct JetChargedV2 { float randomConeEta = randomNumber.Uniform(trackEtaMin + randomConeR, trackEtaMax - randomConeR); float randomConePhi = randomNumber.Uniform(0.0, o2::constants::math::TwoPI); float randomConePt = 0; - double integralValueRC = fFitModulationV2v3->Integral(randomConePhi - randomConeR, randomConePhi + randomConeR); double rholocalRC = collision.rho() / (2 * randomConeR * temppara[0]) * integralValueRC; int nmode = cfgnMods->at(i); - if (nmode == 2) { + if (nmode == cfgNmodA) { double rcPhiPsi2; rcPhiPsi2 = randomConePhi - ep2; @@ -745,17 +789,24 @@ struct JetChargedV2 { // removing the leading jet from the random cone if (jets.size() > 0) { // if there are no jets in the acceptance (from the jetfinder cuts) then there can be no leading jet - float dPhiLeadingJet = RecoDecay::constrainAngle(jets.iteratorAt(0).phi() - randomConePhi, static_cast(-o2::constants::math::PI)); - float dEtaLeadingJet = jets.iteratorAt(0).eta() - randomConeEta; + float leadingJetEta = jets.iteratorAt(0).eta(); + float leadingJetPhi = jets.iteratorAt(0).phi(); + float etaBandWidth = 2 * randomConeR; bool jetWasInCone = false; - while (std::sqrt(dEtaLeadingJet * dEtaLeadingJet + dPhiLeadingJet * dPhiLeadingJet) < jets.iteratorAt(0).r() / 100.0 + randomConeR) { - jetWasInCone = true; + do { randomConeEta = randomNumber.Uniform(trackEtaMin + randomConeR, trackEtaMax - randomConeR); randomConePhi = randomNumber.Uniform(0.0, o2::constants::math::TwoPI); - dPhiLeadingJet = RecoDecay::constrainAngle(jets.iteratorAt(0).phi() - randomConePhi, static_cast(-o2::constants::math::PI)); - dEtaLeadingJet = jets.iteratorAt(0).eta() - randomConeEta; - } + + float dEta = randomConeEta - leadingJetEta; + float dPhi = RecoDecay::constrainAngle(randomConePhi - leadingJetPhi, static_cast(-o2::constants::math::PI)); + + if (std::abs(dEta) > etaBandWidth && std::sqrt(dEta * dEta + dPhi * dPhi) > randomConeR + jets.iteratorAt(0).r() / 100.0) { + break; + } + jetWasInCone = true; + } while (true); + if (jetWasInCone) { randomConePt = 0.0; for (auto const& track : tracks) { @@ -771,27 +822,7 @@ struct JetChargedV2 { } registry.fill(HIST("h3_centrality_deltapT_RandomCornPhi_localrhovsphiwithoutleadingjet"), collision.centrality(), randomConePt - o2::constants::math::PI * randomConeR * randomConeR * rholocalRC, rcPhiPsi2, 1.0); registry.fill(HIST("h3_centrality_deltapT_RandomCornPhi_rhorandomconewithoutleadingjet"), collision.centrality(), randomConePt - o2::constants::math::PI * randomConeR * randomConeR * collision.rho(), rcPhiPsi2, 1.0); - - // randomised eta,phi for tracks, to assess part of fluctuations coming from statistically independently emitted particles, removing tracks from 2 leading jets - double randomConePtWithoutOneLeadJet = 0; - double randomConePtWithoutTwoLeadJet = 0; - for (auto const& track : tracks) { - if (jetderiveddatautilities::selectTrack(track, trackSelection)) { - float dPhi = RecoDecay::constrainAngle(randomNumber.Uniform(0.0, o2::constants::math::TwoPI) - randomConePhi, static_cast(-o2::constants::math::PI)); - float dEta = randomNumber.Uniform(trackEtaMin, trackEtaMax) - randomConeEta; - if (std::sqrt(dEta * dEta + dPhi * dPhi) < randomConeR) { - if (!trackIsInJet(track, jets.iteratorAt(0))) { - randomConePtWithoutOneLeadJet += track.pt(); - if (!trackIsInJet(track, jets.iteratorAt(1))) { - randomConePtWithoutTwoLeadJet += track.pt(); - } - } - } - } - } - registry.fill(HIST("h3_centrality_deltapT_RandomCornPhi_localrhovsphiwithoutoneleadingjet"), collision.centrality(), randomConePtWithoutOneLeadJet - o2::constants::math::PI * randomConeR * randomConeR * rholocalRC, rcPhiPsi2, 1.0); - registry.fill(HIST("h3_centrality_deltapT_RandomCornPhi_localrhovsphiwithouttwoleadingjet"), collision.centrality(), randomConePtWithoutTwoLeadJet - o2::constants::math::PI * randomConeR * randomConeR * rholocalRC, rcPhiPsi2, 1.0); - } else if (nmode == 3) { + } else if (nmode == cfgNmodB) { continue; } } @@ -819,8 +850,9 @@ struct JetChargedV2 { int nmode = cfgnMods->at(i); int detInd = detId * 4 + cfgnTotalSystem * 4 * (nmode - 2); - - if (nmode == 2) { + int cfgNmodA = 2; + int cfgNmodB = 3; + if (nmode == cfgNmodA) { double rcPhiPsi2; float evtPl2 = helperEP.GetEventPlane(collision.qvecRe()[detInd], collision.qvecIm()[detInd], nmode); rcPhiPsi2 = randomConePhi - evtPl2; @@ -861,7 +893,7 @@ struct JetChargedV2 { } } registry.fill(HIST("h2_centrality_deltapT_RandomCornPhi_RCprocess_rhorandomconewithoutleadingjet"), randomConePt - o2::constants::math::PI * randomConeR * randomConeR * collision.rho(), rcPhiPsi2, 1.0); - } else if (nmode == 3) { + } else if (nmode == cfgNmodB) { continue; } } @@ -869,24 +901,23 @@ struct JetChargedV2 { PROCESS_SWITCH(JetChargedV2, processRandomConeDataV2, "QA for random cone estimation of background fluctuations in data", true); void processTracksQA(soa::Filtered>::iterator const& collision, - soa::Filtered const& tracks) + soa::Filtered> const& tracks) { - if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { - return; - } + registry.fill(HIST("h_collisions"), 0.5); + registry.fill(HIST("h2_centrality_collisions"), collision.centrality(), 0.5); if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { return; } - for (auto const& track : tracks) { - if (!jetderiveddatautilities::selectTrack(track, trackSelection)) { - continue; - } - registry.fill(HIST("h2_centrality_track_pt"), collision.centrality(), track.pt()); - registry.fill(HIST("h2_centrality_track_eta"), collision.centrality(), track.eta()); - registry.fill(HIST("h2_centrality_track_phi"), collision.centrality(), track.phi()); + registry.fill(HIST("h_collisions"), 1.5); + registry.fill(HIST("h2_centrality_collisions"), collision.centrality(), 1.5); + if (collision.trackOccupancyInTimeRange() < trackOccupancyInTimeRangeMin || trackOccupancyInTimeRangeMax < collision.trackOccupancyInTimeRange()) { + return; } + registry.fill(HIST("h_collisions"), 2.5); + registry.fill(HIST("h2_centrality_collisions"), collision.centrality(), 2.5); + fillTrackHistograms(collision, tracks); } - PROCESS_SWITCH(JetChargedV2, processTracksQA, "QA for charged tracks", true); + PROCESS_SWITCH(JetChargedV2, processTracksQA, "QA for charged tracks", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) diff --git a/PWGJE/Tasks/jetFinderQA.cxx b/PWGJE/Tasks/jetFinderQA.cxx index 106ad4b4e1e..255cecfad63 100644 --- a/PWGJE/Tasks/jetFinderQA.cxx +++ b/PWGJE/Tasks/jetFinderQA.cxx @@ -77,6 +77,8 @@ struct JetFinderQATask { Configurable trackOccupancyInTimeRangeMax{"trackOccupancyInTimeRangeMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range; only applied to reconstructed collisions (data and mcd jets), not mc collisions (mcp jets)"}; Configurable trackOccupancyInTimeRangeMin{"trackOccupancyInTimeRangeMin", -999999, "minimum occupancy of tracks in neighbouring collisions in a given time range; only applied to reconstructed collisions (data and mcd jets), not mc collisions (mcp jets)"}; Configurable skipMBGapEvents{"skipMBGapEvents", false, "flag to choose to reject min. bias gap events; jet-level rejection applied at the jet finder level, here rejection is applied for collision and track process functions"}; + Configurable intRateNBins{"intRateNBins", 50, "number of bins for interaction rate axis"}; + Configurable intRateMax{"intRateMax", 50000.0, "maximum value of interaction rate axis"}; std::vector filledJetR_Both; std::vector filledJetR_Low; @@ -136,7 +138,10 @@ struct JetFinderQATask { AxisSpec jetEtaAxis = {nBinsEta, jetEtaMin, jetEtaMax, "#eta"}; AxisSpec trackEtaAxis = {nBinsEta, trackEtaMin, trackEtaMax, "#eta"}; + AxisSpec intRateAxis = {intRateNBins, 0., intRateMax, "int. rate (kHz)"}; + if (doprocessJetsData || doprocessJetsMCD || doprocessJetsMCDWeighted) { + registry.add("h_jet_pt", "jet pT;#it{p}_{T,jet} (GeV/#it{c});entries", {HistType::kTH1F, {jetPtAxis}}); registry.add("h_jet_eta", "jet #eta;#eta_{jet};entries", {HistType::kTH1F, {jetEtaAxis}}); registry.add("h_jet_phi", "jet #varphi;#varphi_{jet};entries", {HistType::kTH1F, {{160, -1.0, 7.}}}); @@ -159,6 +164,7 @@ struct JetFinderQATask { registry.add("h_jet_ptcut", "p_{T} cut;p_{T,jet} (GeV/#it{c});N;entries", {HistType::kTH2F, {{300, 0, 300}, {20, 0, 5}}}); registry.add("h_jet_phat_weighted", "jet #hat{p};#hat{p} (GeV/#it{c});entries", {HistType::kTH1F, {{1000, 0, 1000}}}); registry.add("h3_centrality_occupancy_jet_pt", "centrality; occupancy; #it{p}_{T,jet} (GeV/#it{c})", {HistType::kTH3F, {{120, -10.0, 110.0}, {60, 0, 30000}, jetPtAxis}}); + registry.add("h2_intrate_jet_pt", "int. rate vs #it{p}_{T,jet}; int. rate (kHz); #it{p}_{T,jet} (GeV/#it{c});", {HistType::kTH2F, {intRateAxis, jetPtAxis}}); } if (doprocessJetsRhoAreaSubData || doprocessJetsRhoAreaSubMCD) { @@ -182,6 +188,7 @@ struct JetFinderQATask { registry.add("h3_jet_r_jet_pt_track_phi_rhoareasubtracted", "#it{R}_{jet};#it{p}_{T,jet} (GeV/#it{c});#varphi_{jet tracks}", {HistType::kTH3F, {{jetRadiiBins, ""}, jetPtAxisRhoAreaSub, {160, -1.0, 7.}}}); registry.add("h3_jet_r_jet_pt_jet_pt_rhoareasubtracted", "#it{R}_{jet};#it{p}_{T,jet} (GeV/#it{c});#it{p}_{T,jet} (GeV/#it{c})", {HistType::kTH3F, {{jetRadiiBins, ""}, jetPtAxis, jetPtAxisRhoAreaSub}}); registry.add("h3_centrality_occupancy_jet_pt_rhoareasubtracted", "centrality; occupancy; #it{p}_{T,jet} (GeV/#it{c})", {HistType::kTH3F, {{120, -10.0, 110.0}, {60, 0, 30000}, jetPtAxisRhoAreaSub}}); + registry.add("h2_intrate_jet_pt_rhoareasubtracted", "int. rate vs #it{p}_{T,jet}; int. rate (kHz); #it{p}_{T,jet} (GeV/#it{c});", {HistType::kTH2F, {intRateAxis, jetPtAxisRhoAreaSub}}); } if (doprocessEvtWiseConstSubJetsData || doprocessEvtWiseConstSubJetsMCD) { @@ -202,6 +209,7 @@ struct JetFinderQATask { registry.add("h3_jet_r_jet_pt_track_pt_eventwiseconstituentsubtracted", "#it{R}_{jet};#it{p}_{T,jet} (GeV/#it{c});#it{p}_{T,jet tracks} (GeV/#it{c})", {HistType::kTH3F, {{jetRadiiBins, ""}, jetPtAxis, jetPtAxis}}); registry.add("h3_jet_r_jet_pt_track_eta_eventwiseconstituentsubtracted", "#it{R}_{jet};#it{p}_{T,jet} (GeV/#it{c});#eta_{jet tracks}", {HistType::kTH3F, {{jetRadiiBins, ""}, jetPtAxis, trackEtaAxis}}); registry.add("h3_jet_r_jet_pt_track_phi_eventwiseconstituentsubtracted", "#it{R}_{jet};#it{p}_{T,jet} (GeV/#it{c});#varphi_{jet tracks}", {HistType::kTH3F, {{jetRadiiBins, ""}, jetPtAxis, {160, -1.0, 7.}}}); + registry.add("h2_intrate_jet_pt_eventwiseconstituentsubtracted", "int. rate vs #it{p}_{T,jet}; int. rate (kHz); #it{p}_{T,jet} (GeV/#it{c});", {HistType::kTH2F, {intRateAxis, jetPtAxis}}); } if (doprocessRho) { @@ -434,6 +442,7 @@ struct JetFinderQATask { registry.fill(HIST("h2_centrality_jet_phi"), centrality, jet.phi(), weight); registry.fill(HIST("h2_centrality_jet_ntracks"), centrality, jet.tracksIds().size(), weight); registry.fill(HIST("h3_centrality_occupancy_jet_pt"), centrality, occupancy, jet.pt(), weight); + registry.fill(HIST("h2_intrate_jet_pt"), jet.collision().hadronicRate(), jet.pt(), weight); } registry.fill(HIST("h3_jet_r_jet_pt_centrality"), jet.r() / 100.0, jet.pt(), centrality, weight); @@ -466,6 +475,7 @@ struct JetFinderQATask { registry.fill(HIST("h2_centrality_jet_phi_rhoareasubtracted"), centrality, jet.phi(), weight); registry.fill(HIST("h2_centrality_jet_ntracks_rhoareasubtracted"), centrality, jet.tracksIds().size(), weight); } + registry.fill(HIST("h2_intrate_jet_pt_rhoareasubtracted"), jet.collision().hadronicRate(), jet.pt() - (rho * jet.area()), weight); } registry.fill(HIST("h3_jet_r_jet_pt_centrality_rhoareasubtracted"), jet.r() / 100.0, jet.pt() - (rho * jet.area()), centrality, weight); @@ -496,6 +506,7 @@ struct JetFinderQATask { registry.fill(HIST("h2_centrality_jet_eta_eventwiseconstituentsubtracted"), centrality, jet.eta(), weight); registry.fill(HIST("h2_centrality_jet_phi_eventwiseconstituentsubtracted"), centrality, jet.phi(), weight); registry.fill(HIST("h2_centrality_jet_ntracks_eventwiseconstituentsubtracted"), centrality, jet.tracksIds().size(), weight); + registry.fill(HIST("h2_intrate_jet_pt_eventwiseconstituentsubtracted"), jet.collision().hadronicRate(), jet.pt(), weight); } registry.fill(HIST("h3_jet_r_jet_pt_centrality_eventwiseconstituentsubtracted"), jet.r() / 100.0, jet.pt(), centrality, weight); diff --git a/PWGJE/Tasks/jetSpectraCharged.cxx b/PWGJE/Tasks/jetSpectraCharged.cxx index 67495485bb6..a1adc4e2f75 100644 --- a/PWGJE/Tasks/jetSpectraCharged.cxx +++ b/PWGJE/Tasks/jetSpectraCharged.cxx @@ -69,6 +69,7 @@ struct JetSpectraCharged { Configurable pTHatMaxMCD{"pTHatMaxMCD", 999.0, "maximum fraction of hard scattering for jet acceptance in detector MC"}; Configurable pTHatMaxMCP{"pTHatMaxMCP", 999.0, "maximum fraction of hard scattering for jet acceptance in particle MC"}; Configurable pTHatExponent{"pTHatExponent", 6.0, "exponent of the event weight for the calculation of pTHat"}; + Configurable pTHatAbsoluteMin{"pTHatAbsoluteMin", -99.0, "minimum value of pTHat"}; Configurable jetPtMax{"jetPtMax", 200., "set jet pT bin max"}; Configurable jetEtaMin{"jetEtaMin", -0.7, "minimum jet pseudorapidity"}; Configurable jetEtaMax{"jetEtaMax", 0.7, "maximum jet pseudorapidity"}; @@ -293,6 +294,10 @@ struct JetSpectraCharged { template void fillJetHistograms(TJets const& jet, float centrality, float weight = 1.0) { + float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent)); + if (jet.pt() > pTHatMaxMCD * pTHat || pTHat < pTHatAbsoluteMin) { + return; + } if (jet.r() == round(selectedJetsRadius * 100.0f)) { registry.fill(HIST("h_jet_pt"), jet.pt(), weight); registry.fill(HIST("h_jet_eta"), jet.eta(), weight); @@ -313,6 +318,10 @@ struct JetSpectraCharged { template void fillJetAreaSubHistograms(TJets const& jet, float centrality, float rho, float weight = 1.0) { + float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent)); + if (jet.pt() > pTHatMaxMCD * pTHat || pTHat < pTHatAbsoluteMin) { + return; + } double jetcorrpt = jet.pt() - (rho * jet.area()); if (jet.r() == round(selectedJetsRadius * 100.0f)) { // fill jet histograms after area-based subtraction @@ -338,6 +347,10 @@ struct JetSpectraCharged { template void fillMCPHistograms(TJets const& jet, float weight = 1.0) { + float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent)); + if (jet.pt() > pTHatMaxMCP * pTHat || pTHat < pTHatAbsoluteMin) { + return; + } if (jet.r() == round(selectedJetsRadius * 100.0f)) { // fill mcp jet histograms registry.fill(HIST("h_jet_pt_part"), jet.pt(), weight); @@ -356,6 +369,10 @@ struct JetSpectraCharged { template void fillMCPAreaSubHistograms(TJets const& jet, float rho = 0.0, float weight = 1.0) { + float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent)); + if (jet.pt() > pTHatMaxMCP * pTHat || pTHat < pTHatAbsoluteMin) { + return; + } if (jet.r() == round(selectedJetsRadius * 100.0f)) { // fill mcp jet histograms double jetcorrpt = jet.pt() - (rho * jet.area()); @@ -373,6 +390,10 @@ struct JetSpectraCharged { template void fillEventWiseConstituentSubtractedHistograms(TJets const& jet, float centrality, float weight = 1.0) { + float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent)); + if (jet.pt() > pTHatMaxMCD * pTHat || pTHat < pTHatAbsoluteMin) { + return; + } if (jet.r() == round(selectedJetsRadius * 100.0f)) { registry.fill(HIST("h2_centrality_jet_pt_eventwiseconstituentsubtracted"), centrality, jet.pt(), weight); registry.fill(HIST("jet_observables_eventwiseconstituentsubtracted"), jet.pt(), jet.eta(), jet.phi(), weight); @@ -390,14 +411,14 @@ struct JetSpectraCharged { void fillMatchedHistograms(TBase const& jetMCD, float weight = 1.0) { float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent)); - if (jetMCD.pt() > pTHatMaxMCD * pTHat) { + if (jetMCD.pt() > pTHatMaxMCD * pTHat || pTHat < pTHatAbsoluteMin) { return; } // fill geometry matched histograms if (checkGeoMatched) { if (jetMCD.has_matchedJetGeo()) { for (const auto& jetMCP : jetMCD.template matchedJetGeo_as>()) { - if (jetMCP.pt() > pTHatMaxMCP * pTHat) { + if (jetMCP.pt() > pTHatMaxMCP * pTHat || pTHat < pTHatAbsoluteMin) { continue; } if (jetMCD.r() == round(selectedJetsRadius * 100.0f)) { diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index ba1a2a08351..ba3dde1e8f2 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -68,6 +68,7 @@ struct RecoilJets { Configurable trkSel{"trkSel", "globalTracks", "Set track selection"}; Configurable vertexZCut{"vertexZCut", 10., "Accepted z-vertex range"}; Configurable fracSig{"fracSig", 0.9, "Fraction of events to use for signal TT"}; + Configurable bGetMissJets{"bGetMissJets", false, "Flag to get miss histo for particle level jets"}; Configurable trkPtMin{"trkPtMin", 0.15, "Minimum pT of acceptanced tracks"}; Configurable trkPtMax{"trkPtMax", 100., "Maximum pT of acceptanced tracks"}; @@ -76,10 +77,12 @@ struct RecoilJets { Configurable jetR{"jetR", 0.4, "Jet cone radius"}; Configurable triggerMasks{"triggerMasks", "", "Relevant trigger masks: fTrackLowPt,fTrackHighPt"}; + Configurable skipMBGapEvents{"skipMBGapEvents", false, "flag to choose to reject min. bias gap events; jet-level rejection applied at the jet finder level, here rejection is applied for collision and track process functions"}; // List of configurable parameters for MC Configurable pTHatExponent{"pTHatExponent", 4.0, "Exponent of the event weight for the calculation of pTHat"}; Configurable pTHatMax{"pTHatMax", 999.0, "Maximum fraction of hard scattering for jet acceptance in MC"}; + Configurable pTHatMaxTrack{"pTHatMaxTrack", 999.0, "Maximum fraction of hard scattering for track acceptance in MC"}; // Parameters for recoil jet selection Configurable ptTTrefMin{"ptTTrefMin", 5., "Minimum pT of reference TT"}; @@ -134,8 +137,14 @@ struct RecoilJets { // List of raw and MC det. distributions if (doprocessData || doprocessMCDetLevel || doprocessMCDetLevelWeighted) { spectra.add("vertexZ", "Z vertex of collisions", kTH1F, {{60, -12., 12.}}); + spectra.add("hHasAssocMcCollision", "Has det. level coll. associat. MC coll.", kTH1F, {{2, 0.0, 2.}}); + spectra.get(HIST("hHasAssocMcCollision"))->GetXaxis()->SetBinLabel(1, "Yes"); + spectra.get(HIST("hHasAssocMcCollision"))->GetXaxis()->SetBinLabel(2, "No"); spectra.add("hTrackPtEtaPhi", "Charact. of tracks", kTH3F, {pT, pseudorap, phiAngle}); + + spectra.add("hTTSig_pT", "pT spectrum of all found TT_{Sig} cand.", kTH1F, {{40, 10., 50.}}); // needed to distinguish merged data from diff. wagons + spectra.add("hNtrig", "Total number of selected triggers per class", kTH1F, {{2, 0.0, 2.}}); spectra.get(HIST("hNtrig"))->GetXaxis()->SetBinLabel(1, "TT_{ref}"); spectra.get(HIST("hNtrig"))->GetXaxis()->SetBinLabel(2, "TT_{sig}"); @@ -161,6 +170,9 @@ struct RecoilJets { // List of MC particle level distributions if (doprocessMCPartLevel || doprocessMCPartLevelWeighted) { + spectra.add("vertexZMC", "Z vertex of jmccollision", kTH1F, {{60, -12., 12.}}); + spectra.add("ptHat", "Distribution of pT hat", kTH1F, {{500, 0.0, 100.}}); + spectra.add("hPartPtEtaPhi", "Charact. of particles", kTH3F, {pT, pseudorap, phiAngle}); spectra.add("hNtrig_Part", "Total number of selected triggers per class", kTH1F, {{2, 0.0, 2.}}); spectra.get(HIST("hNtrig_Part"))->GetXaxis()->SetBinLabel(1, "TT_{ref}"); @@ -187,26 +199,30 @@ struct RecoilJets { // Jet matching: part. vs. det. if (doprocessJetsMatched || doprocessJetsMatchedWeighted) { - spectra.add("hJetPt_PartLevel_vs_DetLevel", "Correlation jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}); + spectra.add("hJetPt_DetLevel_vs_PartLevel", "Correlation jet pT at det. vs. part. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}); // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel", "Correlation jet pT at part. vs. det. levels", kTH2F, {jetPTcorr, jetPTcorr}); - spectra.add("hJetPt_PartLevel_vs_DetLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}); + spectra.add("hJetPt_DetLevel_vs_PartLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}); // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {jetPTcorr, jetPTcorr}); - spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); - // spectra.add("hMissedJets_Corr_pT", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}); - // spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); - // spectra.add("hMissedJets_Corr_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}); - - spectra.add("hFakeJets_pT", "Det. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); - // spectra.add("hFakeJets_Corr_pT", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}); - spectra.add("hFakeJets_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); - // spectra.add("hFakeJets_Corr_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}); + if (bGetMissJets) { + spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + // spectra.add("hMissedJets_Corr_pT", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}); + spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + // spectra.add("hMissedJets_Corr_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}); + } else { + spectra.add("hFakeJets_pT", "Det. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + // spectra.add("hFakeJets_Corr_pT", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}); + spectra.add("hFakeJets_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + // spectra.add("hFakeJets_Corr_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}); + } spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}); spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}); spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}); spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}); + + spectra.add("hNumberMatchedJetsPerOneBaseJet", "# of taged jets per 1 base jet vs. jet pT", kTH2F, {{10, 0.5, 10.5}, {100, 0.0, 100.}}); } } @@ -231,11 +247,15 @@ struct RecoilJets { if (skipTrack(track)) continue; + if (bIsMC && (track.pt() > pTHatMaxTrack * pTHat)) + continue; + spectra.fill(HIST("hTrackPtEtaPhi"), track.pt(), track.eta(), track.phi(), weight); // Search for TT candidate if (bSigEv && (track.pt() > ptTTsigMin && track.pt() < ptTTsigMax)) { vPhiOfTT.push_back(track.phi()); + spectra.fill(HIST("hTTSig_pT"), track.pt(), weight); ++nTT; } @@ -301,6 +321,7 @@ struct RecoilJets { double phiTT = 0.; int nTT = 0; float pTHat = getPtHat(weight); + spectra.fill(HIST("ptHat"), pTHat, weight); auto dice = rand->Rndm(); if (dice < fracSig) @@ -316,6 +337,9 @@ struct RecoilJets { if (bParticleNeutral || !particle.isPhysicalPrimary()) continue; + if (particle.pt() > pTHatMaxTrack * pTHat) + continue; + spectra.fill(HIST("hPartPtEtaPhi"), particle.pt(), particle.eta(), particle.phi(), weight); if (bSigEv && (particle.pt() > ptTTsigMin && particle.pt() < ptTTsigMax)) { @@ -379,70 +403,36 @@ struct RecoilJets { } } - /// TODO: Add functionality to get rho for particle and detector level - template - void fillMatchedHistograms(Tracks const& tracks, DetLevelJets const& jets_det_level, PartLevelJets const& jets_part_level, float weight = 1.) + template + void fillMatchedHistograms(TracksTable const& tracks, JetsBase const& jetsBase, JetsTag const& jetsTag, float weight = 1.) { std::vector vPhiOfTT; - double phiTT = 0.; + double phiTTSig = 0.; float pTHat = getPtHat(weight); for (const auto& track : tracks) { if (skipTrack(track)) continue; + if (track.pt() > pTHatMaxTrack * pTHat) + continue; + if (track.pt() > ptTTsigMin && track.pt() < ptTTsigMax) { vPhiOfTT.push_back(track.phi()); } } - bool bTT = vPhiOfTT.size() > 0; - if (bTT) - phiTT = getPhiTT(vPhiOfTT); - - for (const auto& jet_det_level : jets_det_level) { - if (jet_det_level.pt() > pTHatMax * pTHat) - continue; + bool bIsThereTTSig = vPhiOfTT.size() > 0; - bool bRecoilJet = get<1>(isRecoilJet(jet_det_level, phiTT)) && bTT; + if (bIsThereTTSig) + phiTTSig = getPhiTT(vPhiOfTT); - if (jet_det_level.has_matchedJetGeo()) { - - const auto jetsMatchedPartLevel = jet_det_level.template matchedJetGeo_as>(); // we can add "matchedJetPt_as" later - - for (const auto& jet_matched_part_level : jetsMatchedPartLevel) { - - /* - Which histos we want: - 1) det pT vs. part. pT for inclusive jets (corrected for rho*A and not) - 2) det pT vs. part. pT for recoil jets - 3) same as (1) and (2) but 4D with dphi parts - 4) distribution of fake and miss jets - 5) pT and phi resolutions - */ - - spectra.fill(HIST("hJetPt_PartLevel_vs_DetLevel"), jet_det_level.pt(), jet_matched_part_level.pt(), weight); - spectra.fill(HIST("hJetPt_resolution"), (jet_matched_part_level.pt() - jet_det_level.pt()) / jet_matched_part_level.pt(), jet_matched_part_level.pt(), weight); - spectra.fill(HIST("hJetPhi_resolution"), jet_matched_part_level.phi() - jet_det_level.phi(), jet_matched_part_level.pt(), weight); - - if (bRecoilJet) { - spectra.fill(HIST("hJetPt_PartLevel_vs_DetLevel_RecoilJets"), jet_det_level.pt(), jet_matched_part_level.pt(), weight); - spectra.fill(HIST("hJetPt_resolution_RecoilJets"), (jet_matched_part_level.pt() - jet_det_level.pt()) / jet_matched_part_level.pt(), jet_matched_part_level.pt(), weight); - spectra.fill(HIST("hJetPhi_resolution_RecoilJets"), jet_matched_part_level.phi() - jet_det_level.phi(), jet_matched_part_level.pt(), weight); - } - } - } else { - spectra.fill(HIST("hFakeJets_pT"), jet_det_level.pt(), weight); - if (bRecoilJet) - spectra.fill(HIST("hFakeJets_pT_RecoilJets"), jet_det_level.pt(), weight); - } - } + for (const auto& jetBase : jetsBase) { + if (jetBase.pt() > pTHatMax * pTHat) + continue; - // Missed jets - for (const auto& jet_part_level : jets_part_level) { - if (!jet_part_level.has_matchedJetGeo()) { - spectra.fill(HIST("hMissedJets_pT"), jet_part_level.pt(), weight); - } + bool bIsBaseJetRecoil = get<1>(isRecoilJet(jetBase, phiTTSig)) && bIsThereTTSig; + dataForUnfolding(jetBase, jetsTag, bIsBaseJetRecoil, weight); } } @@ -462,7 +452,7 @@ struct RecoilJets { FilteredTracks const& tracks, FilteredJetsDetLevel const& jets) { - if (skipEvent(collision)) + if (skipEvent(collision) || skipMBGapEvent(collision)) return; spectra.fill(HIST("vertexZ"), collision.posZ()); @@ -475,12 +465,18 @@ struct RecoilJets { FilteredTracks const& tracks, FilteredJetsDetLevel const& jets) { - if (skipEvent(collision)) + if (skipEvent(collision) || skipMBGapEvent(collision)) return; - /// \TODO: should we implement function to check whether Collision was reconstructed (has_mcCollision() function)? Example: https://github.com/AliceO2Group/O2Physics/blob/1cba330514ab47c15c0095d8cee9633723d8e2a7/PWGJE/Tasks/v0qa.cxx#L166? auto weight = collision.mcCollision().weight(); spectra.fill(HIST("vertexZ"), collision.posZ(), weight); + + if (collision.has_mcCollision()) { + spectra.fill(HIST("hHasAssocMcCollision"), 0.5, weight); + } else { + spectra.fill(HIST("hHasAssocMcCollision"), 1.5, weight); + } + fillHistograms(collision, jets, tracks, true, weight); } PROCESS_SWITCH(RecoilJets, processMCDetLevelWeighted, "process MC detector level with event weight", false); @@ -489,7 +485,10 @@ struct RecoilJets { aod::JetParticles const& particles, FilteredJetsPartLevel const& jets) { - spectra.fill(HIST("vertexZ"), collision.posZ()); + if (skipMBGapEvent(collision)) + return; + + spectra.fill(HIST("vertexZMC"), collision.posZ()); fillMCPHistograms(collision, jets, particles); } PROCESS_SWITCH(RecoilJets, processMCPartLevel, "process MC particle level", false); @@ -498,8 +497,11 @@ struct RecoilJets { aod::JetParticles const& particles, FilteredJetsPartLevel const& jets) { + if (skipMBGapEvent(collision)) + return; + auto weight = collision.weight(); - spectra.fill(HIST("vertexZ"), collision.posZ(), weight); + spectra.fill(HIST("vertexZMC"), collision.posZ(), weight); fillMCPHistograms(collision, jets, particles, weight); } PROCESS_SWITCH(RecoilJets, processMCPartLevelWeighted, "process MC particle level with event weight", false); @@ -510,10 +512,16 @@ struct RecoilJets { FilteredMatchedJetsDetLevel const& mcdjets, FilteredMatchedJetsPartLevel const& mcpjets) { - if (skipEvent(collision)) + if (skipEvent(collision) || skipMBGapEvent(collision)) return; + auto mcpjetsPerMCCollision = mcpjets.sliceBy(partJetsPerCollision, collision.mcCollisionId()); - fillMatchedHistograms(tracks, mcdjets, mcpjetsPerMCCollision); + + if (bGetMissJets) { + fillMatchedHistograms(tracks, mcpjetsPerMCCollision, mcdjets); + } else { + fillMatchedHistograms(tracks, mcdjets, mcpjetsPerMCCollision); + } } PROCESS_SWITCH(RecoilJets, processJetsMatched, "process matching of MC jets (no weight)", false); @@ -523,13 +531,17 @@ struct RecoilJets { FilteredMatchedJetsDetLevel const& mcdjets, FilteredMatchedJetsPartLevel const& mcpjets) { - if (skipEvent(collision)) + if (skipEvent(collision) || skipMBGapEvent(collision)) return; auto mcpjetsPerMCCollision = mcpjets.sliceBy(partJetsPerCollision, collision.mcCollisionId()); auto weight = collision.mcCollision().weight(); - fillMatchedHistograms(tracks, mcdjets, mcpjetsPerMCCollision, weight); + if (bGetMissJets) { + fillMatchedHistograms(tracks, mcpjetsPerMCCollision, mcdjets, weight); + } else { + fillMatchedHistograms(tracks, mcdjets, mcpjetsPerMCCollision, weight); + } } PROCESS_SWITCH(RecoilJets, processJetsMatchedWeighted, "process matching of MC jets (weighted)", false); @@ -542,6 +554,12 @@ struct RecoilJets { return !jetderiveddatautilities::selectCollision(coll, eventSelectionBits) || !jetderiveddatautilities::selectTrigger(coll, triggerMaskBits); } + template + bool skipMBGapEvent(const Collision& coll) + { + return (skipMBGapEvents && coll.subGeneratorId()) == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap; + } + template bool skipTrack(const Track& track) { @@ -566,6 +584,55 @@ struct RecoilJets { { return 10. / (std::pow(weight, 1.0 / pTHatExponent)); } + + template + void dataForUnfolding(JetBase const& jetBase, JetsTag const&, bool bIsBaseJetRecoil, float weight = 1.0) + { + + bool bIsThereMatchedJet = jetBase.has_matchedJetGeo(); + if (bIsThereMatchedJet) { + const auto& jetsMatched = jetBase.template matchedJetGeo_as>(); + + for (const auto& jetMatched : jetsMatched) { + spectra.fill(HIST("hNumberMatchedJetsPerOneBaseJet"), jetsMatched.size(), jetMatched.pt(), weight); + + if (bGetMissJets) { + // Mean that base jet is particle level jet + spectra.fill(HIST("hJetPt_DetLevel_vs_PartLevel"), jetMatched.pt(), jetBase.pt(), weight); + spectra.fill(HIST("hJetPt_resolution"), (jetBase.pt() - jetMatched.pt()) / jetBase.pt(), jetBase.pt(), weight); + spectra.fill(HIST("hJetPhi_resolution"), jetBase.phi() - jetMatched.phi(), jetBase.pt(), weight); + + if (bIsBaseJetRecoil) { + spectra.fill(HIST("hJetPt_DetLevel_vs_PartLevel_RecoilJets"), jetMatched.pt(), jetBase.pt(), weight); + spectra.fill(HIST("hJetPt_resolution_RecoilJets"), (jetBase.pt() - jetMatched.pt()) / jetBase.pt(), jetBase.pt(), weight); + spectra.fill(HIST("hJetPhi_resolution_RecoilJets"), jetBase.phi() - jetMatched.phi(), jetBase.pt(), weight); + } + } else { + // Mean that base jet is detector level jet + spectra.fill(HIST("hJetPt_DetLevel_vs_PartLevel"), jetBase.pt(), jetMatched.pt(), weight); + spectra.fill(HIST("hJetPt_resolution"), (jetMatched.pt() - jetBase.pt()) / jetMatched.pt(), jetMatched.pt(), weight); + spectra.fill(HIST("hJetPhi_resolution"), jetMatched.phi() - jetBase.phi(), jetMatched.phi(), weight); + + if (bIsBaseJetRecoil) { + spectra.fill(HIST("hJetPt_DetLevel_vs_PartLevel_RecoilJets"), jetBase.pt(), jetMatched.pt(), weight); + spectra.fill(HIST("hJetPt_resolution_RecoilJets"), (jetMatched.pt() - jetBase.pt()) / jetMatched.pt(), jetMatched.pt(), weight); + spectra.fill(HIST("hJetPhi_resolution_RecoilJets"), jetMatched.phi() - jetBase.phi(), jetMatched.phi(), weight); + } + } + } + } else { + // No closest jet + if (bGetMissJets) { + spectra.fill(HIST("hMissedJets_pT"), jetBase.pt(), weight); + if (bIsBaseJetRecoil) + spectra.fill(HIST("hMissedJets_pT_RecoilJets"), jetBase.pt(), weight); + } else { + spectra.fill(HIST("hFakeJets_pT"), jetBase.pt(), weight); + if (bIsBaseJetRecoil) + spectra.fill(HIST("hFakeJets_pT_RecoilJets"), jetBase.pt(), weight); + } + } + } }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } diff --git a/PWGJE/Tasks/trackEfficiency.cxx b/PWGJE/Tasks/trackEfficiency.cxx index 10ff3365974..b9fde50abde 100644 --- a/PWGJE/Tasks/trackEfficiency.cxx +++ b/PWGJE/Tasks/trackEfficiency.cxx @@ -52,6 +52,7 @@ struct TrackEfficiencyJets { Configurable eventSelections{"eventSelections", "sel8", "choose event selection"}; Configurable trackSelections{"trackSelections", "globalTracks", "set track selections; other option: uniformTracks"}; + Configurable skipMBGapEvents{"skipMBGapEvents", false, "flag to choose to reject min. bias gap events"}; // Tracking efficiency process function configurables: Configurable checkPrimaryPart{"checkPrimaryPart", true, "0: doesn't check mcparticle.isPhysicalPrimary() - 1: checks particle.isPhysicalPrimary()"}; @@ -72,6 +73,10 @@ struct TrackEfficiencyJets { Configurable trackOccupancyInTimeRangeMax{"trackOccupancyInTimeRangeMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range; only applied for reconstructed tracks, not mc particles"}; Configurable trackOccupancyInTimeRangeMin{"trackOccupancyInTimeRangeMin", -999999, "minimum occupancy of tracks in neighbouring collisions in a given time range; only applied for reconstructed tracks, not mc particles"}; + Configurable> centralityBinning{"centralityBinning", {0., 10., 50., 70.}, "binning of centrality histograms"}; + Configurable intRateNBins{"intRateNBins", 50, "number of bins for interaction rate axis"}; + Configurable intRateMax{"intRateMax", 50000.0, "maximum value of interaction rate axis"}; + std::vector eventSelectionBits; int trackSelection = -1; @@ -100,6 +105,7 @@ struct TrackEfficiencyJets { registry.fill(HIST("h2_track_pt_track_sigmapt"), track.pt(), track.sigma1Pt() * track.pt(), weight); registry.fill(HIST("h2_track_pt_high_track_sigma1overpt"), track.pt(), track.sigma1Pt(), weight); registry.fill(HIST("h2_track_pt_high_track_sigmapt"), track.pt(), track.sigma1Pt() * track.pt(), weight); + registry.fill(HIST("h3_intrate_centrality_track_pt"), collision.hadronicRate(), collision.centrality(), track.pt(), weight); } } @@ -111,6 +117,7 @@ struct TrackEfficiencyJets { registry.fill(HIST("h2_centrality_particle_eta"), collision.centrality(), mcparticle.eta(), weight); registry.fill(HIST("h2_centrality_particle_phi"), collision.centrality(), mcparticle.phi(), weight); registry.fill(HIST("h2_centrality_particle_energy"), collision.centrality(), mcparticle.energy(), weight); + registry.fill(HIST("h3_intrate_centrality_particle_pt"), collision.hadronicRate(), collision.centrality(), mcparticle.pt(), weight); } } @@ -182,7 +189,8 @@ struct TrackEfficiencyJets { } if (doprocessTracks || doprocessTracksWeighted) { - AxisSpec centAxis = {121, -10., 111., "centrality (%)"}; + AxisSpec centAxis = {centralityBinning, "centrality (%)"}; + AxisSpec intRateAxis = {intRateNBins, 0., intRateMax, "int. rate (kHz)"}; registry.add("h2_centrality_track_pt", "centrality vs track pT; centrality; #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {centAxis, {200, 0., 200.}}}); registry.add("h2_centrality_track_eta", "centrality vs track #eta; centrality; #eta_{track}", {HistType::kTH2F, {centAxis, {100, -1.0, 1.0}}}); registry.add("h2_centrality_track_phi", "centrality vs track #varphi; centrality; #varphi_{track}", {HistType::kTH2F, {centAxis, {160, -1.0, 7.}}}); @@ -191,24 +199,27 @@ struct TrackEfficiencyJets { registry.add("h2_track_pt_high_track_sigmapt", "#sigma(#it{p}_{T})/#it{p}_{T}; #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{90, 10., 100.}, {100000, 0.0, 100.0}}}); registry.add("h2_track_pt_track_sigma1overpt", "#sigma(1/#it{p}_{T}); #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{100, 0., 10.}, {1000, 0.0, 10.0}}}); registry.add("h2_track_pt_high_track_sigma1overpt", "#sigma(1/#it{p}_{T}); #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {{90, 10., 100.}, {1000, 0.0, 10.0}}}); + registry.add("h3_intrate_centrality_track_pt", "interaction rate vs centrality vs track pT; int. rate; centrality; #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH3F, {intRateAxis, centAxis, {200, 0., 200.}}}); } if (doprocessParticles || doprocessParticlesWeighted) { - AxisSpec centAxis = {121, -10., 111., "centrality (%)"}; - registry.add("h2_centrality_particle_pt", "centrality vs track pT; centrality; #it{p}_{T,track} (GeV/#it{c})", {HistType::kTH2F, {centAxis, {200, 0., 200.}}}); - registry.add("h2_centrality_particle_eta", "centrality vs track #eta; centrality; #eta_{track}", {HistType::kTH2F, {centAxis, {100, -1.0, 1.0}}}); - registry.add("h2_centrality_particle_phi", "centrality vs track #varphi; centrality; #varphi_{track}", {HistType::kTH2F, {centAxis, {160, -1.0, 7.}}}); - registry.add("h2_centrality_particle_energy", "centrality vs track energy; centrality; Energy GeV", {HistType::kTH2F, {centAxis, {100, 0.0, 100.0}}}); + AxisSpec centAxis = {centralityBinning, "centrality (%)"}; + AxisSpec intRateAxis = {intRateNBins, 0., intRateMax, "int. rate (kHz)"}; + registry.add("h2_centrality_particle_pt", "centrality vs particle pT; centrality; #it{p}_{T,part} (GeV/#it{c})", {HistType::kTH2F, {centAxis, {200, 0., 200.}}}); + registry.add("h2_centrality_particle_eta", "centrality vs particle #eta; centrality; #eta_{part}", {HistType::kTH2F, {centAxis, {100, -1.0, 1.0}}}); + registry.add("h2_centrality_particle_phi", "centrality vs particle #varphi; centrality; #varphi_{part}", {HistType::kTH2F, {centAxis, {160, -1.0, 7.}}}); + registry.add("h2_centrality_particle_energy", "centrality vs particle energy; centrality; Energy GeV", {HistType::kTH2F, {centAxis, {100, 0.0, 100.0}}}); + registry.add("h3_intrate_centrality_particle_pt", "interaction rate vs centrality vs particle pT; int. rate; centrality; #it{p}_{T,part} (GeV/#it{c})", {HistType::kTH3F, {intRateAxis, centAxis, {200, 0., 200.}}}); } if (doprocessTracks || doprocessTracksWeighted) { - AxisSpec centAxis = {121, -10., 111., "centrality (%)"}; + AxisSpec centAxis = {centralityBinning, "centrality (%)"}; registry.add("h_collisions", "event status;event status;entries", {HistType::kTH1F, {{4, 0.0, 4.0}}}); registry.add("h_fakecollisions", "event status;event status;entries", {HistType::kTH1F, {{4, 0.0, 4.0}}}); registry.add("h2_centrality_collisions", "centrality vs collisions; centrality; collisions", {HistType::kTH2F, {centAxis, {4, 0.0, 4.0}}}); } if (doprocessParticles || doprocessParticlesWeighted) { - AxisSpec centAxis = {121, -10., 111., "centrality (%)"}; + AxisSpec centAxis = {centralityBinning, "centrality (%)"}; registry.add("h_mccollisions", "event status;event status;entries", {HistType::kTH1F, {{4, 0.0, 4.0}}}); registry.add("h2_centrality_mccollisions", "centrality vs mccollisions; centrality; collisions", {HistType::kTH2F, {centAxis, {4, 0.0, 4.0}}}); } @@ -258,7 +269,7 @@ struct TrackEfficiencyJets { bool hasSel8Coll = false; bool centralityCheck = false; if (acceptSplitCollisions == 2) { // check only that the first reconstructed collision passes the check - if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelectionBits, skipMBGapEvents)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collisions.begin().centrality()) && (collisions.begin().centrality() < centralityMax))) { // effect unclear if mcColl is split @@ -266,7 +277,7 @@ struct TrackEfficiencyJets { } } else { // check that at least one of the reconstructed collisions passes the checks for (auto& collision : collisions) { - if (jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collision, eventSelectionBits, skipMBGapEvents)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collision.centrality()) && (collision.centrality() < centralityMax))) { // effect unclear if mcColl is split @@ -317,7 +328,7 @@ struct TrackEfficiencyJets { return; } - if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits) || !(abs(collision.posZ()) < vertexZCut)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits, skipMBGapEvents) || !(abs(collision.posZ()) < vertexZCut)) { continue; } @@ -392,7 +403,7 @@ struct TrackEfficiencyJets { { registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h2_centrality_collisions"), collision.centrality(), 0.5); - if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits, skipMBGapEvents)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -417,7 +428,7 @@ struct TrackEfficiencyJets { float eventWeight = collision.mcCollision().weight(); registry.fill(HIST("h_collisions"), 0.5); registry.fill(HIST("h_collisions_weighted"), 0.5, eventWeight); - if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { + if (!jetderiveddatautilities::selectCollision(collision, eventSelectionBits, skipMBGapEvents)) { return; } registry.fill(HIST("h_collisions"), 1.5); @@ -451,7 +462,7 @@ struct TrackEfficiencyJets { bool hasSel8Coll = false; bool centralityCheck = false; if (acceptSplitCollisions == 2) { // check only that the first reconstructed collision passes the check - if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelectionBits, skipMBGapEvents)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collisions.begin().centrality()) && (collisions.begin().centrality() < centralityMax))) { // effect unclear if mcColl is split @@ -459,7 +470,7 @@ struct TrackEfficiencyJets { } } else { // check that at least one of the reconstructed collisions passes the checks for (auto& collision : collisions) { - if (jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collision, eventSelectionBits, skipMBGapEvents)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collision.centrality()) && (collision.centrality() < centralityMax))) { // effect unclear if mcColl is split @@ -484,6 +495,10 @@ struct TrackEfficiencyJets { soa::SmallGroups const& collisions, soa::Filtered const& mcparticles) { + if (skipMBGapEvents && mcCollision.subGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap) { + return; + } + float eventWeight = mcCollision.weight(); registry.fill(HIST("h_mccollisions"), 0.5); registry.fill(HIST("h_mccollisions_weighted"), 0.5, eventWeight); @@ -501,7 +516,7 @@ struct TrackEfficiencyJets { bool hasSel8Coll = false; bool centralityCheck = false; if (acceptSplitCollisions == 2) { // check only that the first reconstructed collision passes the check - if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collisions.begin(), eventSelectionBits, skipMBGapEvents)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collisions.begin().centrality()) && (collisions.begin().centrality() < centralityMax))) { // effect unclear if mcColl is split @@ -509,7 +524,7 @@ struct TrackEfficiencyJets { } } else { // check that at least one of the reconstructed collisions passes the checks for (auto& collision : collisions) { - if (jetderiveddatautilities::selectCollision(collision, eventSelectionBits)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split + if (jetderiveddatautilities::selectCollision(collision, eventSelectionBits, skipMBGapEvents)) { // Skipping MC events that have not a single selected reconstructed collision ; effect unclear if mcColl is split hasSel8Coll = true; } if (!checkCentrality || ((centralityMin < collision.centrality()) && (collision.centrality() < centralityMax))) { // effect unclear if mcColl is split diff --git a/PWGLF/DataModel/LFStrangenessTables.h b/PWGLF/DataModel/LFStrangenessTables.h index 6d414cb325b..bfe3a4f055d 100644 --- a/PWGLF/DataModel/LFStrangenessTables.h +++ b/PWGLF/DataModel/LFStrangenessTables.h @@ -1762,6 +1762,38 @@ DECLARE_SOA_TABLE(Tracked3BodyColls, "AOD", "TRA3BODYCOLL", //! Table joinable w using Tracked3BodyColl = Tracked3BodyColls::iterator; using AssignedTracked3Bodys = soa::Join; using AssignedTracked3Body = AssignedTracked3Bodys::iterator; + +namespace zdcneutrons +{ +// FOR DERIVED +DECLARE_SOA_INDEX_COLUMN(StraMCCollision, straMCCollision); //! +// DYNAMIC COLUMNS +DECLARE_SOA_DYNAMIC_COLUMN(Pt, pt, //! neutron transverse momentum (GeV/c) + [](float px, float py) -> float { return RecoDecay::sqrtSumOfSquares(px, py); }); +DECLARE_SOA_DYNAMIC_COLUMN(P, p, //! neutron total momentum (GeV/c) + [](float px, float py, float pz) -> float { return RecoDecay::sqrtSumOfSquares(px, py, pz); }); +DECLARE_SOA_DYNAMIC_COLUMN(Phi, phi, //! neutron phi in the range [0, 2pi) + [](float px, float py) -> float { return RecoDecay::phi(px, py); }); +DECLARE_SOA_DYNAMIC_COLUMN(Eta, eta, //! neutron pseudorapidity + [](float px, float py, float pz) -> float { return RecoDecay::eta(std::array{px, py, pz}); }); +DECLARE_SOA_DYNAMIC_COLUMN(Y, y, //! neutron rapidity + [](float pz, float e) -> float { return std::atanh(pz / e); }); +} // namespace zdcneutrons + +DECLARE_SOA_TABLE(ZDCNeutrons, "AOD", "ZDCNEUTRON", //! MC properties of the neutrons within ZDC acceptance (for UPC analysis) + mcparticle::PdgCode, mcparticle::StatusCode, mcparticle::Flags, + mcparticle::Vx, mcparticle::Vy, mcparticle::Vz, mcparticle::Vt, + mcparticle::Px, mcparticle::Py, mcparticle::Pz, mcparticle::E, + // Dynamic columns for manipulating information + zdcneutrons::Pt, + zdcneutrons::P, + zdcneutrons::Phi, + zdcneutrons::Eta, + zdcneutrons::Y); + +DECLARE_SOA_TABLE(ZDCNMCCollRefs, "AOD", "ZDCNMCCOLLREF", //! refers MC candidate back to proper MC Collision + o2::soa::Index<>, zdcneutrons::StraMCCollisionId, o2::soa::Marker<4>); + } // namespace o2::aod //______________________________________________________ diff --git a/PWGLF/TableProducer/Nuspex/hypertriton3bodyfinder.cxx b/PWGLF/TableProducer/Nuspex/hypertriton3bodyfinder.cxx index b4445a5619a..40019d82533 100644 --- a/PWGLF/TableProducer/Nuspex/hypertriton3bodyfinder.cxx +++ b/PWGLF/TableProducer/Nuspex/hypertriton3bodyfinder.cxx @@ -865,7 +865,7 @@ struct hypertriton3bodyFinder { auto ntracks = Ntracks.sliceBy(perCollisionGoodNegTracks, collision.globalIndex()); auto goodtracks = Goodtracks.sliceBy(perCollisionGoodTracks, collision.globalIndex()); - if (!cffilter.hasLD() && UseCFFilter) { + if (!cffilter.hasLD_LooseKstar() && UseCFFilter) { continue; } registry.fill(HIST("hEventCounter"), 1.5); @@ -902,7 +902,7 @@ struct hypertriton3bodyFinder { VirtualLambdaCheck(collision, v0s, 0); VirtualLambdaCheck(collision, fullv0s, 3); - if (!cffilter.hasLD() && UseCFFilter) { + if (!cffilter.hasLD_LooseKstar() && UseCFFilter) { continue; } registry.fill(HIST("hEventCounter"), 1.5); diff --git a/PWGLF/TableProducer/Strangeness/strangederivedbuilder.cxx b/PWGLF/TableProducer/Strangeness/strangederivedbuilder.cxx index 09216aa166d..6a67077dff3 100644 --- a/PWGLF/TableProducer/Strangeness/strangederivedbuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/strangederivedbuilder.cxx @@ -111,6 +111,11 @@ struct strangederivedbuilder { Produces cascmothers; // casc mother references Produces motherMCParts; // mc particles for mothers + //__________________________________________________ + // UPC specific information + Produces zdcNeutrons; // Primary neutrons within ZDC acceptance + Produces zdcNeutronsMCCollRefs; // references collisions from ZDCNeutrons + //__________________________________________________ // Q-vectors Produces StraFT0AQVs; // FT0A Q-vector @@ -1054,6 +1059,26 @@ struct strangederivedbuilder { straOrigin(origin.dataframeID()); } + void processSimulatedZDCNeutrons(soa::Join const& mcCollisions, aod::McParticles const& mcParticlesEntireTable) + { + for (const auto& mccollision : mcCollisions) { + const uint64_t mcCollIndex = mccollision.globalIndex(); + auto mcParticles = mcParticlesEntireTable.sliceBy(mcParticlePerMcCollision, mcCollIndex); + + for (const auto& mcPart : mcParticles) { + if (std::abs(mcPart.pdgCode()) == kNeutron) { // check if it is a neutron or anti-neutron + if (std::abs(mcPart.eta()) > 8.7) { // check if it is within ZDC acceptance + zdcNeutrons(mcPart.pdgCode(), mcPart.statusCode(), mcPart.flags(), + mcPart.vx(), mcPart.vy(), mcPart.vz(), mcPart.vt(), + mcPart.px(), mcPart.py(), mcPart.pz(), mcPart.e()); + + zdcNeutronsMCCollRefs(mcPart.mcCollisionId()); + } + } + } + } + } + // debug processing PROCESS_SWITCH(strangederivedbuilder, processDataframeIDs, "Produce data frame ID tags", false); @@ -1077,6 +1102,7 @@ struct strangederivedbuilder { PROCESS_SWITCH(strangederivedbuilder, processPureSimulation, "Produce pure simulated information", true); PROCESS_SWITCH(strangederivedbuilder, processReconstructedSimulation, "Produce reco-ed simulated information", true); PROCESS_SWITCH(strangederivedbuilder, processBinnedGenerated, "Produce binned generated information", false); + PROCESS_SWITCH(strangederivedbuilder, processSimulatedZDCNeutrons, "Produce generated neutrons (within ZDC acceptance) table for UPC analysis", false); // event plane information PROCESS_SWITCH(strangederivedbuilder, processFT0AQVectors, "Produce FT0A Q-vectors table", false); diff --git a/PWGLF/Tasks/GlobalEventProperties/uccZdc.cxx b/PWGLF/Tasks/GlobalEventProperties/uccZdc.cxx index 72a89b7d5de..de05a2bf275 100644 --- a/PWGLF/Tasks/GlobalEventProperties/uccZdc.cxx +++ b/PWGLF/Tasks/GlobalEventProperties/uccZdc.cxx @@ -25,6 +25,7 @@ #include #include #include +#include #include "Common/CCDB/EventSelectionParams.h" #include "Common/CCDB/TriggerAliases.h" @@ -55,17 +56,11 @@ using namespace o2::constants::math; namespace o2::aod { -using ColEvSels = - soa::Join; -using BCsRun3 = - soa::Join; -using TracksSel = soa::Join; -using SimCollisions = soa::Join; -using SimTracks = soa::Join; +using ColEvSels = soa::Join; +using BCsRun3 = soa::Join; +using TracksSel = soa::Join; +using SimCollisions = soa::Join; +using SimTracks = soa::Join; } // namespace o2::aod struct UccZdc { @@ -101,7 +96,7 @@ struct UccZdc { ConfigurableAxis binsPt{"binsPt", {VARIABLE_WIDTH, 0.0, 0.1, 0.12}, "pT binning"}; ConfigurableAxis binsCent{"binsCent", {VARIABLE_WIDTH, 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100.}, "T0C binning"}; - // Configurable event selectiond and flags ZDC + // Configurables Event Selection Configurable isNoCollInTimeRangeStrict{"isNoCollInTimeRangeStrict", true, "isNoCollInTimeRangeStrict?"}; Configurable isNoCollInTimeRangeStandard{"isNoCollInTimeRangeStandard", false, "isNoCollInTimeRangeStandard?"}; Configurable isNoCollInRofStrict{"isNoCollInRofStrict", true, "isNoCollInRofStrict?"}; @@ -110,14 +105,9 @@ struct UccZdc { Configurable isNoCollInTimeRangeNarrow{"isNoCollInTimeRangeNarrow", false, "isNoCollInTimeRangeNarrow?"}; Configurable isOccupancyCut{"isOccupancyCut", true, "Occupancy cut?"}; Configurable isApplyFT0CbasedOccupancy{"isApplyFT0CbasedOccupancy", false, "T0C Occu cut?"}; - Configurable isAmpZDC{"isAmpZDC", false, "Use amplitude ZDC?"}; - Configurable isCommPMT{"isCommPMT", false, "Use common PMT ZDC?"}; - Configurable isSumTowers{"isSumTowers", false, "Use sum of Tow ZDC?"}; Configurable isTDCcut{"isTDCcut", false, "Use TDC cut?"}; Configurable isZEMcut{"isZEMcut", true, "Use ZEM cut?"}; - Configurable isZNbasedSel{"isZNbasedSel", false, "Use ZN based Sel."}; - Configurable isZNAbasedSel{"isZNAbasedSel", false, "Use ZNA based Sel."}; - Configurable isZNCbasedSel{"isZNCbasedSel", false, "Use ZNC based Sel."}; + Configurable znBasedCut{"znBasedCut", 100, "ZN-based cut"}; Configurable zemCut{"zemCut", 1000., "ZEM cut"}; Configurable tdcCut{"tdcCut", 1., "TDC cut"}; @@ -145,12 +135,8 @@ struct UccZdc { Zem }; - // Histograms names - static constexpr std::string_view PsTitles[4] = { - ";#it{N}_{ch} (|#eta| < 0.8, Corrected);#LT[#it{p}_{T}^{(1)}]#GT;", - ";#it{N}_{ch} (|#eta| < 0.8, Corrected);#LT[#it{p}_{T}^{(2)}]#GT;", - ";#it{N}_{ch} (|#eta| < 0.8, Corrected);#LT[#it{p}_{T}^{(3)}]#GT;", - ";#it{N}_{ch} (|#eta| < 0.8, Corrected);#LT[#it{p}_{T}^{(4)}]#GT;"}; + static constexpr float zEro{0.}; + static constexpr float oneHalf{0.5}; // Filters // Filter trackFilter = ((aod::track::eta > minEta) && (aod::track::eta < maxEta) && (aod::track::pt > minPt) && (aod::track::pt < maxPt) && requireGlobalTrackInFilter()); @@ -167,12 +153,7 @@ struct UccZdc { using TheFilteredSimTracks = soa::Filtered; // Histograms: Data - HistogramRegistry registry{ - "registry", - {}, - OutputObjHandlingPolicy::AnalysisObject, - true, - true}; + HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; Service ccdb; Configurable paTH{"paTH", "Users/o/omvazque/TrackingEfficiency", "base path to the ccdb object"}; @@ -218,119 +199,114 @@ struct UccZdc { // Histograms: paritcle-level info if (doprocessZdcCollAss) { - registry.add("NchVsZpos", ";#it{N}_{ch} (|#eta| < 0.8);Vtx_{z};", - kTProfile, {{nBinsNch, minNch, maxNch}}); + registry.add("T0Ccent", ";;Entries", kTH1F, {axisCent}); registry.add("ZposVsEta", "", kTProfile, {axisZpos}); - registry.add("EtaVsPhi", ";#eta;#varphi", kTH2F, - {{{axisEta}, {100, -0.1 * PI, +2.1 * PI}}}); - registry.add("NchVsPt", ";#it{N}_{ch} (|#eta| < 0.8, Corrected);;", kTH2F, - {{{nBinsNch, minNch, maxNch}, {axisPt}}}); + registry.add("EtaVsPhi", ";#eta;#varphi", kTH2F, {{{axisEta}, {100, -0.1 * PI, +2.1 * PI}}}); registry.add("sigma1Pt", ";;#sigma(p_{T})/p_{T};", kTProfile, {axisPt}); - registry.add("dcaXYvspT", ";DCA_{xy} (cm);;", kTH2F, - {{{50, -1., 1.}, {axisPt}}}); - registry.add("ZN", ";ZNA+ZNC;Entries;", kTH1F, {{nBinsZDC, -0.5, maxZN}}); - registry.add("ZNA", ";ZNA;Entries;", kTH1F, {{nBinsZDC, -0.5, maxZN}}); - registry.add("ZPA", ";ZPA;Entries;", kTH1F, {{nBinsZDC, -0.5, maxZP}}); - registry.add("ZNC", ";ZNC;Entries;", kTH1F, {{nBinsZDC, -0.5, maxZN}}); - registry.add("ZPC", ";ZPC;Entries;", kTH1F, {{nBinsZDC, -0.5, maxZP}}); - registry.add("ZNVsZEM", ";ZEM;ZNA+ZNC;", kTH2F, - {{{60, -0.5, maxZEM}, {60, -0.5, maxZN}}}); - registry.add("ZNAVsZNC", ";ZNC;ZNA", kTH2F, - {{{30, -0.5, maxZN}, {30, -0.5, maxZN}}}); - registry.add("ZPAVsZPC", ";ZPC;ZPA;", kTH2F, - {{{100, -0.5, maxZP}, {100, -0.5, maxZP}}}); - registry.add("ZNAVsZPA", ";ZPA;ZNA;", kTH2F, - {{{20, -0.5, maxZP}, {30, -0.5, maxZN}}}); - registry.add("ZNCVsZPC", ";ZPC;ZNC;", kTH2F, - {{{20, -0.5, maxZP}, {30, -0.5, maxZN}}}); - registry.add("ZNCVstdc", ";t_{ZNC};ZNC;", kTH2F, - {{{30, -15., 15.}, {nBinsZDC, -0.5, maxZN}}}); - registry.add("ZNAVstdc", ";t_{ZNA};ZNA;", kTH2F, - {{{30, -15., 15.}, {30, -0.5, maxZN}}}); - registry.add("ZPCVstdc", ";t_{ZPC};ZPC;", kTH2F, - {{{30, -15., 15}, {20, -0.5, maxZP}}}); - registry.add("ZPAVstdc", ";t_{ZPA};ZPA;", kTH2F, - {{{30, -15., 15.}, {20, -0.5, maxZP}}}); - registry.add("ZEM1Vstdc", ";t_{ZEM1};ZEM1;", kTH2F, - {{{30, -15., 15.}, {30, -0.5, 2000.5}}}); - registry.add("ZEM2Vstdc", ";t_{ZEM2};ZEM2;", kTH2F, - {{{30, -15., 15.}, {30, -0.5, 2000.5}}}); - registry.add("debunch", ";t_{ZDC}-t_{ZDA};t_{ZDC}+t_{ZDA}", kTH2F, - {{{nBinsTDC, minTdc, maxTdc}, {nBinsTDC, minTdc, maxTdc}}}); - registry.add("NchVsFT0C", ";T0C (#times 1/100);#it{N}_{ch} (|#eta|<0.8);", kTProfile, {{nBinsAmpFT0, 0., 950.}}); - registry.add("NchVsFT0M", ";T0A+T0C (#times 1/100);#it{N}_{ch} (|#eta|<0.8);", kTProfile, {{nBinsAmpFT0, 0., 3000.}}); - registry.add("NchVsFT0A", ";T0A (#times 1/100);#it{N}_{ch} (|#eta|<0.8);", kTProfile, {{nBinsAmpFT0, 0., maxAmpFT0}}); - registry.add("NchVsFV0A", ";V0A (#times 1/100);#it{N}_{ch} (|#eta|<0.8);", kTProfile, {{nBinsAmpFV0, 0., maxAmpFV0}}); - registry.add("NchVsNPV", ";#it{N}_{PV} (|#eta|<1);#LT ITS+TPC tracks #GT (|#eta|<0.8);", kTProfile, {{nBinsNch, minNch, maxNch}}); - registry.add("NchVsITStracks", ";ITS tracks nCls >= 5;#LTITS+TPC tracks#GT (|#eta|<0.8);", kTProfile, {{nBinsNch, minNch, maxNch}}); - registry.add("ZNCVsNch", ";#it{N}_{ch} (|#eta|<0.8);ZNC;", kTH2F, - {{{nBinsNch, minNch, maxNch}, {nBinsZDC, minNch, maxZN}}}); - registry.add("ZNAVsNch", ";#it{N}_{ch} (|#eta|<0.8);ZNA;", kTH2F, - {{{nBinsNch, minNch, maxNch}, {nBinsZDC, minNch, maxZN}}}); - registry.add("ZNVsNch", ";#it{N}_{ch} (|#eta|<0.8);ZNA+ZNC;", kTH2F, - {{{nBinsNch, minNch, maxNch}, {nBinsZDC, minNch, maxZN}}}); - registry.add("ZNVsFT0A", ";T0A (#times 1/100);ZNA+ZNC;", kTH2F, - {{{nBinsAmpFT0, 0., maxAmpFT0}, {nBinsZDC, minNch, maxZN}}}); - registry.add("ZNVsFT0C", ";T0C (#times 1/100);ZNA+ZNC;", kTH2F, - {{{nBinsAmpFT0, 0., maxAmpFT0}, {nBinsZDC, minNch, maxZN}}}); - registry.add("ZNVsFT0M", ";T0A+T0C (#times 1/100);ZNA+ZNC;", kTH2F, - {{{nBinsAmpFT0, 0., 3000.}, {nBinsZDC, minNch, maxZN}}}); - registry.add("ZNDifVsNch", ";#it{N}_{ch} (|#eta|<0.8);ZNA-ZNC;", kTH2F, - {{{nBinsNch, minNch, maxNch}, {100, -50., 50.}}}); - } - - if (doprocessMCclosure || doprocessZdcCollAss) { - registry.add("NchRaw", ";#it{N}_{ch} (|#eta| < 0.8);", kTH1F, - {{nBinsNch, minNch, maxNch}}); - registry.add("Nch", ";#it{N}_{ch} (|#eta| < 0.8, Corrected);", kTH1F, - {{nBinsNch, minNch, maxNch}}); - registry.add("T0Ccent", ";;Entries", kTH1F, {axisCent}); - registry.add("NchVsOneParCorr", PsTitles[0].data(), kTProfile, - {{nBinsNch, minNch, maxNch}}); - registry.add("NchVsTwoParCorr", PsTitles[1].data(), kTProfile, - {{nBinsNch, minNch, maxNch}}); - registry.add("NchVsThreeParCorr", PsTitles[2].data(), kTProfile, - {{nBinsNch, minNch, maxNch}}); - registry.add("NchVsFourParCorr", PsTitles[3].data(), kTProfile, - {{nBinsNch, minNch, maxNch}}); + registry.add("dcaXYvspT", ";DCA_{xy} (cm);;", kTH2F, {{{50, -1., 1.}, {axisPt}}}); + + registry.add("NchRaw", ";#it{N}_{ch} (|#eta| < 0.8);", kTH1F, {{nBinsNch, minNch, maxNch}}); + registry.add("Nch", ";#it{N}_{ch} (|#eta| < 0.8, Corrected);", kTH1F, {{nBinsNch, minNch, maxNch}}); + registry.add("NchVsPt", ";#it{N}_{ch} (|#eta| < 0.8, Corrected);;", kTH2F, {{{nBinsNch, minNch, maxNch}, {axisPt}}}); + registry.add("NchVsOneParCorr", ";#it{N}_{ch} (|#eta| < 0.8, Corrected);#LT[#it{p}_{T}^{(1)}]#GT (GeV/#it{c})", kTProfile, {{nBinsNch, minNch, maxNch}}); + registry.add("NchVsOneParCorrVsZN", ";#it{N}_{ch} (|#eta| < 0.8, Corrected); ZNA+ZNC; #LT[#it{p}_{T}^{(1)}]#GT", kTProfile2D, {{{nBinsNch, minNch, maxNch}, {nBinsZDC, -0.5, maxZN}}}); + registry.add("NchVsTwoParCorrVsZN", ";#it{N}_{ch} (|#eta| < 0.8, Corrected);ZNA+ZNC;#LT[#it{p}_{T}^{(2)}]#GT", kTProfile2D, {{{nBinsNch, minNch, maxNch}, {nBinsZDC, -0.5, maxZN}}}); + registry.add("NchVsThreeParCorrVsZN", ";#it{N}_{ch} (|#eta| < 0.8, Corrected);ZNA+ZNC;#LT[#it{p}_{T}^{(3)}]#GT", kTProfile2D, {{{nBinsNch, minNch, maxNch}, {nBinsZDC, -0.5, maxZN}}}); + registry.add("NchVsFourParCorrVsZN", ";#it{N}_{ch} (|#eta| < 0.8, Corrected);ZNA+ZNC;#LT[#it{p}_{T}^{(4)}]#GT", kTProfile2D, {{{nBinsNch, minNch, maxNch}, {nBinsZDC, -0.5, maxZN}}}); } // MC Histograms - if (doprocesspTEff) { - registry.add("T0Ccent", ";;Entries", kTH1F, {axisCent}); + if (doprocessMCclosure) { + registry.add("RandomNumber", "", kTH1F, {{100, 0., 1.}}); + registry.add("EvtsDivided", ";Event type;Entries;", kTH1F, {{2, -0.5, 1.5}}); + auto hEvtsDiv = registry.get(HIST("EvtsDivided")); + auto* xEvtsDiv = hEvtsDiv->GetXaxis(); + xEvtsDiv->SetBinLabel(1, "MC closure"); + xEvtsDiv->SetBinLabel(2, "Corrections"); + + registry.add("NchGen", "MC closure;#it{N}_{ch} (|#eta| < 0.8);Entries;", kTH1F, {{nBinsNch, minNch, maxNch}}); + registry.add("NchvsOneParCorrGen", "MC closure;#it{N}_{ch} (|#eta| < 0.8);#LT[#it{p}_{T}^{(1)}]#GT (GeV/#it{c})", kTProfile, {{nBinsNch, minNch, maxNch}}); + registry.add("NchvsTwoParCorrGen", "MC closure;#it{N}_{ch} (|#eta| < 0.8);#LT[#it{p}_{T}^{(2)}]#GT", kTProfile, {{nBinsNch, minNch, maxNch}}); + registry.add("NchvsThreeParCorrGen", "MC closure;#it{N}_{ch} (|#eta| < 0.8);#LT[#it{p}_{T}^{(3)}]#GT", kTProfile, {{nBinsNch, minNch, maxNch}}); + registry.add("NchvsFourParCorrGen", "MC closure;#it{N}_{ch} (|#eta| < 0.8);#LT[#it{p}_{T}^{(4)}]#GT", kTProfile, {{nBinsNch, minNch, maxNch}}); + + registry.add("T0Ccent", "Filled at MC closure + Corrections;;Entries", kTH1F, {axisCent}); + registry.add("NchRaw", "MC closure;#it{N}_{ch} (|#eta| < 0.8);Entries;", kTH1F, {{nBinsNch, minNch, maxNch}}); + registry.add("Nch", "MC closure;#it{N}_{ch} (|#eta| < 0.8, Corrected);Entries;", kTH1F, {{nBinsNch, minNch, maxNch}}); + registry.add("NchVsOneParCorr", "MC closure;#it{N}_{ch} (|#eta| < 0.8, Corrected);#LT[#it{p}_{T}^{(1)}]#GT (GeV/#it{c})", kTProfile, {{nBinsNch, minNch, maxNch}}); + registry.add("NchVsTwoParCorr", "MC closure;#it{N}_{ch} (|#eta| < 0.8, Corrected);#LT[#it{p}_{T}^{(2)}]#GT", kTProfile, {{nBinsNch, minNch, maxNch}}); + registry.add("NchVsThreeParCorr", "MC closure;#it{N}_{ch} (|#eta| < 0.8, Corrected);#LT[#it{p}_{T}^{(3)}]#GT", kTProfile, {{nBinsNch, minNch, maxNch}}); + registry.add("NchVsFourParCorr", "MC closure;#it{N}_{ch} (|#eta| < 0.8, Corrected);#LT[#it{p}_{T}^{(4)}]#GT", kTProfile, {{nBinsNch, minNch, maxNch}}); + + // Corrections registry.add("nRecColvsCent", "", kTH2F, {{6, -0.5, 5.5}, {{axisCent}}}); - registry.add("Pt_all_ch", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("Pt_ch", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("Pt_pi", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("Pt_ka", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("Pt_pr", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("Pt_sigpos", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("Pt_signeg", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("Pt_re", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("EtaVsPhi", ";;#varphi;", kTH2F, - {{{axisEta}, {100, -0.1 * PI, +2.1 * PI}}}); + registry.add("Pt_all_ch", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("Pt_ch", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("Pt_pi", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("Pt_ka", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("Pt_pr", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("Pt_sigpos", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("Pt_signeg", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("Pt_re", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("EtaVsPhi", "Corrections;;#varphi;", kTH2F, {{{axisEta}, {100, -0.1 * PI, +2.1 * PI}}}); registry.add("hEventCounterMC", "Event counter", kTH1F, {axisEvent}); - registry.add("zPosMC", ";;Entries;", kTH1F, {axisZpos}); - registry.add("PtMC_ch", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("PtMC_pi", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("PtMC_ka", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("PtMC_pr", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("PtMC_sigpos", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("PtMC_signeg", "", kTH2F, {{axisCent}, {axisPt}}); - registry.add("PtMC_re", "", kTH2F, {{axisCent}, {axisPt}}); + registry.add("zPosMC", "Filled at MC closure + Corrections;;Entries;", kTH1F, {axisZpos}); + registry.add("PtMC_ch", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("PtMC_pi", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("PtMC_ka", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("PtMC_pr", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("PtMC_sigpos", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("PtMC_signeg", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + registry.add("PtMC_re", "Corrections;;;", kTH2F, {{axisCent}, {axisPt}}); + + auto hECMC = registry.get(HIST("hEventCounterMC")); + auto* x = hECMC->GetXaxis(); + x->SetBinLabel(1, "All"); + x->SetBinLabel(13, "VtxZ cut"); } - if (doprocessMCclosure) { - registry.add("NchGen", ";Nch;Entries;", kTH1F, - {{nBinsNch, minNch, maxNch}}); - registry.add("NchvsOneParCorrGen", PsTitles[0].data(), kTProfile, - {{nBinsNch, minNch, maxNch}}); - registry.add("NchvsTwoParCorrGen", PsTitles[1].data(), kTProfile, - {{nBinsNch, minNch, maxNch}}); - registry.add("NchvsThreeParCorrGen", PsTitles[2].data(), kTProfile, - {{nBinsNch, minNch, maxNch}}); - registry.add("NchvsFourParCorrGen", PsTitles[3].data(), kTProfile, - {{nBinsNch, minNch, maxNch}}); + if (doprocessQA) { + registry.add("T0Ccent", ";;Entries", kTH1F, {axisCent}); + + registry.add("ZNVsFT0A", ";T0A (#times 1/100);ZNA+ZNC;", kTH2F, {{{nBinsAmpFT0, 0., maxAmpFT0}, {nBinsZDC, -0.5, maxZN}}}); + registry.add("ZNVsFT0C", ";T0C (#times 1/100);ZNA+ZNC;", kTH2F, {{{nBinsAmpFT0, 0., maxAmpFT0}, {nBinsZDC, -0.5, maxZN}}}); + registry.add("ZNVsFT0M", ";T0A+T0C (#times 1/100);ZNA+ZNC;", kTH2F, {{{nBinsAmpFT0, 0., 3000.}, {nBinsZDC, -0.5, maxZN}}}); + + registry.add("ZN", ";ZNA+ZNC;Entries;", kTH1F, {{nBinsZDC, -0.5, maxZN}}); + registry.add("ZNA", ";ZNA;Entries;", kTH1F, {{nBinsZDC, -0.5, maxZN}}); + registry.add("ZPA", ";ZPA;Entries;", kTH1F, {{nBinsZDC, -0.5, maxZP}}); + registry.add("ZNC", ";ZNC;Entries;", kTH1F, {{nBinsZDC, -0.5, maxZN}}); + registry.add("ZPC", ";ZPC;Entries;", kTH1F, {{nBinsZDC, -0.5, maxZP}}); + registry.add("ZNAVsZNC", ";ZNC;ZNA", kTH2F, {{{30, -0.5, maxZN}, {30, -0.5, maxZN}}}); + registry.add("ZPAVsZPC", ";ZPC;ZPA;", kTH2F, {{{100, -0.5, maxZP}, {100, -0.5, maxZP}}}); + registry.add("ZNAVsZPA", ";ZPA;ZNA;", kTH2F, {{{20, -0.5, maxZP}, {30, -0.5, maxZN}}}); + registry.add("ZNCVsZPC", ";ZPC;ZNC;", kTH2F, {{{20, -0.5, maxZP}, {30, -0.5, maxZN}}}); + registry.add("ZNCcvsZNCsum", ";ZNC common;ZNC sum towers;", kTH2F, {{{30, -0.5, maxZN}, {30, -0.5, maxZN}}}); + registry.add("ZNAcvsZNAsum", ";ZNA common;ZNA sum towers;", kTH2F, {{{30, -0.5, maxZN}, {30, -0.5, maxZN}}}); + registry.add("ZPCcvsZPCsum", ";ZPC common;ZPC sum towers;", kTH2F, {{{30, -0.5, maxZP}, {30, -0.5, maxZP}}}); + registry.add("ZPAcvsZPAsum", ";ZPA common;ZPA sum towers;", kTH2F, {{{30, -0.5, maxZP}, {30, -0.5, maxZP}}}); + registry.add("ZNVsZEM", ";ZEM;ZNA+ZNC;", kTH2F, {{{60, -0.5, maxZEM}, {60, -0.5, maxZN}}}); + registry.add("ZNCVstdc", ";t_{ZNC};ZNC;", kTH2F, {{{30, -15., 15.}, {nBinsZDC, -0.5, maxZN}}}); + registry.add("ZNAVstdc", ";t_{ZNA};ZNA;", kTH2F, {{{30, -15., 15.}, {30, -0.5, maxZN}}}); + registry.add("ZPCVstdc", ";t_{ZPC};ZPC;", kTH2F, {{{30, -15., 15}, {20, -0.5, maxZP}}}); + registry.add("ZPAVstdc", ";t_{ZPA};ZPA;", kTH2F, {{{30, -15., 15.}, {20, -0.5, maxZP}}}); + registry.add("ZEM1Vstdc", ";t_{ZEM1};ZEM1;", kTH2F, {{{30, -15., 15.}, {30, -0.5, 2000.5}}}); + registry.add("ZEM2Vstdc", ";t_{ZEM2};ZEM2;", kTH2F, {{{30, -15., 15.}, {30, -0.5, 2000.5}}}); + registry.add("debunch", ";t_{ZDC}-t_{ZDA};t_{ZDC}+t_{ZDA}", kTH2F, {{{nBinsTDC, minTdc, maxTdc}, {nBinsTDC, minTdc, maxTdc}}}); + + registry.add("NchVsFT0C", ";T0C (#times 1/100, -3.3 < #eta < -2.1);#it{N}_{ch} (|#eta|<0.8);", kTH2F, {{{nBinsAmpFT0, 0., 950.}, {nBinsNch, minNch, maxNch}}}); + registry.add("NchVsFT0M", ";T0A+T0C (#times 1/100, -3.3 < #eta < -2.1 and 3.5 < #eta < 4.9);#it{N}_{ch} (|#eta|<0.8);", kTH2F, {{{nBinsAmpFT0, 0., 3000.}, {nBinsNch, minNch, maxNch}}}); + registry.add("NchVsFT0A", ";T0A (#times 1/100, 3.5 < #eta < 4.9);#it{N}_{ch} (|#eta|<0.8);", kTProfile, {{nBinsAmpFT0, 0., maxAmpFT0}}); + registry.add("NchVsFV0A", ";V0A (#times 1/100, 2.2 < #eta < 5);#it{N}_{ch} (|#eta|<0.8);", kTProfile, {{nBinsAmpFV0, 0., maxAmpFV0}}); + + registry.add("NchVsEt", ";#it{E}_{T} (|#eta|<0.8);#LTITS+TPC tracks#GT (|#eta|<0.8);", kTH2F, {{{nBinsNch, minNch, maxNch}, {nBinsNch, minNch, maxNch}}}); + registry.add("NchVsMeanPt", ";#it{N}_{ch} (|#eta|<0.8);#LT[#it{p}_{T}]#GT (|#eta|<0.8);", kTProfile, {{nBinsNch, minNch, maxNch}}); + registry.add("NchVsNPV", ";#it{N}_{PV} (|#eta|<1);#LT ITS+TPC tracks #GT (|#eta|<0.8);", kTProfile, {{6000, -0.5, 5999.5}}); + registry.add("NchVsITStracks", ";ITS tracks nCls >= 5;#LTITS+TPC tracks#GT (|#eta|<0.8);", kTProfile, {{6000, -0.5, 5999.5}}); + registry.add("ZNCVsNch", ";#it{N}_{ch} (|#eta|<0.8);ZNC;", kTH2F, {{{nBinsNch, minNch, maxNch}, {nBinsZDC, minNch, maxZN}}}); + registry.add("ZNAVsNch", ";#it{N}_{ch} (|#eta|<0.8);ZNA;", kTH2F, {{{nBinsNch, minNch, maxNch}, {nBinsZDC, minNch, maxZN}}}); + registry.add("ZNVsNch", ";#it{N}_{ch} (|#eta|<0.8);ZNA+ZNC;", kTH2F, {{{nBinsNch, minNch, maxNch}, {nBinsZDC, minNch, maxZN}}}); + registry.add("ZNDifVsNch", ";#it{N}_{ch} (|#eta|<0.8);ZNA-ZNC;", kTH2F, {{{nBinsNch, minNch, maxNch}, {100, -50., 50.}}}); } ccdb->setURL(uRl.value); @@ -410,12 +386,10 @@ struct UccZdc { } if (isOccupancyCut) { - auto occuValue{isApplyFT0CbasedOccupancy - ? col.ft0cOccupancyInTimeRange() - : col.trackOccupancyInTimeRange()}; - - if (occuValue < minOccCut || occuValue > maxOccCut) + auto occuValue{isApplyFT0CbasedOccupancy ? col.ft0cOccupancyInTimeRange() : col.trackOccupancyInTimeRange()}; + if (occuValue < minOccCut || occuValue > maxOccCut) { return false; + } } registry.fill(HIST("hEventCounter"), EvCutLabel::OccuCut); @@ -433,85 +407,24 @@ struct UccZdc { return true; } - void processZdcCollAss(o2::aod::ColEvSels::iterator const& collision, - o2::aod::BCsRun3 const& /*bcs*/, - aod::Zdcs const& /*zdcs*/, aod::FV0As const& /*fv0as*/, - aod::FT0s const& /*ft0s*/, - TheFilteredTracks const& tracks) + void processQA(o2::aod::ColEvSels::iterator const& collision, o2::aod::BCsRun3 const& /**/, aod::Zdcs const& /**/, aod::FV0As const& /**/, aod::FT0s const& /**/, TheFilteredTracks const& tracks) { + + // LOG(info) << " Collisions size: " << collisions.size() << " Table's size: " << collisions.tableSize() << "\n"; + const auto& foundBC = collision.foundBC_as(); + // LOG(info) << "Run number: " << foundBC.runNumber() << "\n"; if (!isEventSelected(collision)) { return; } - const auto& foundBC = collision.foundBC_as(); - if (!foundBC.has_zdc()) { // has ZDC? + // has ZDC? + if (!foundBC.has_zdc()) { return; } registry.fill(HIST("hEventCounter"), EvCutLabel::Zdc); + auto zdc = foundBC.zdc(); - float aT0A{0.0}; - float aT0C{0.0}; - float aV0A{0.0}; - float znA{0.0}; - float znC{0.0}; - float zpA{0.0}; - float zpC{0.0}; - float aZEM1{0.0}; - float aZEM2{0.0}; - float tZEM1{0.0}; - float tZEM2{0.0}; - float tZNA{0.0}; - float tZNC{0.0}; - float tZPA{0.0}; - float tZPC{0.0}; - float sumZNs{0.0}; - float sumZEMs{0.0}; - float tZDCdif{0.0}; - float tZDCsum{0.0}; - - aZEM1 = foundBC.zdc().amplitudeZEM1(); - aZEM2 = foundBC.zdc().amplitudeZEM2(); - tZEM1 = foundBC.zdc().timeZEM1(); - tZEM2 = foundBC.zdc().timeZEM2(); - tZNA = foundBC.zdc().timeZNA(); - tZNC = foundBC.zdc().timeZNC(); - tZPA = foundBC.zdc().timeZPA(); - tZPC = foundBC.zdc().timeZPC(); - tZDCdif = tZNC + tZPC - tZNA - tZPA; - tZDCsum = tZNC + tZPC + tZNA + tZPA; - - if (isAmpZDC) { - znA = foundBC.zdc().amplitudeZNA(); - znC = foundBC.zdc().amplitudeZNC(); - zpA = foundBC.zdc().amplitudeZPA(); - zpC = foundBC.zdc().amplitudeZPC(); - } else if (isCommPMT) { - znA = foundBC.zdc().energyCommonZNA(); - znC = foundBC.zdc().energyCommonZNC(); - zpA = foundBC.zdc().energyCommonZPA(); - zpC = foundBC.zdc().energyCommonZPC(); - } else if (isSumTowers) { - for (const auto& eZNA : foundBC.zdc().energySectorZNA()) - znA += eZNA; - for (const auto& eZNC : foundBC.zdc().energySectorZNC()) - znC += eZNC; - for (const auto& eZPA : foundBC.zdc().energySectorZPA()) - zpA += eZPA; - for (const auto& eZPC : foundBC.zdc().energySectorZPC()) - zpC += eZPC; - } else { - znA = -999.; - znC = -999.; - zpA = -999.; - zpC = -999.; - } - znA /= 2.81; - znC /= 2.81; - zpA /= 2.81; - zpC /= 2.81; - sumZNs = znA + znC; - sumZEMs = aZEM1 + aZEM2; - + float aT0A = 0., aT0C = 0., aV0A = 0.; if (foundBC.has_ft0()) { for (const auto& amplitude : foundBC.ft0().amplitudeA()) { aT0A += amplitude; @@ -532,6 +445,13 @@ struct UccZdc { aV0A = -999.; } + float tZNA{zdc.timeZNA()}; + float tZNC{zdc.timeZNC()}; + float tZPA{zdc.timeZPA()}; + float tZPC{zdc.timeZPC()}; + float tZDCdif{tZNC + tZPC - tZNA - tZPA}; + float tZDCsum{tZNC + tZPC + tZNA + tZPA}; + // TDC cut if (isTDCcut) { if (std::sqrt(std::pow(tZDCdif, 2.) + std::pow(tZDCsum, 2.)) > tdcCut) { @@ -540,6 +460,10 @@ struct UccZdc { registry.fill(HIST("hEventCounter"), EvCutLabel::Tdc); } + float aZEM1{zdc.amplitudeZEM1()}; + float aZEM2{zdc.amplitudeZEM2()}; + float sumZEMs{aZEM1 + aZEM2}; + // ZEM cut if (isZEMcut) { if (sumZEMs < zemCut) { @@ -548,13 +472,51 @@ struct UccZdc { registry.fill(HIST("hEventCounter"), EvCutLabel::Zem); } + float znA{zdc.amplitudeZNA()}; + float znC{zdc.amplitudeZNC()}; + float zpA{zdc.amplitudeZPA()}; + float zpC{zdc.amplitudeZPC()}; + znA /= 2.81; + znC /= 2.81; + zpA /= 2.81; + zpC /= 2.81; + + float tZEM1{zdc.timeZEM1()}; + float tZEM2{zdc.timeZEM2()}; + float sumZNs{znA + znC}; + + float sumZNC = (zdc.energySectorZNC())[0] + (zdc.energySectorZNC())[1] + (zdc.energySectorZNC())[2] + (zdc.energySectorZNC())[3]; + float sumZNA = (zdc.energySectorZNA())[0] + (zdc.energySectorZNA())[1] + (zdc.energySectorZNA())[2] + (zdc.energySectorZNA())[3]; + float sumZPC = (zdc.energySectorZPC())[0] + (zdc.energySectorZPC())[1] + (zdc.energySectorZPC())[2] + (zdc.energySectorZPC())[3]; + float sumZPA = (zdc.energySectorZPA())[0] + (zdc.energySectorZPA())[1] + (zdc.energySectorZPA())[2] + (zdc.energySectorZPA())[3]; + + int itsTracks = 0, glbTracks = 0; + float et = 0., meanpt = 0.; + for (const auto& track : tracks) { + if (track.hasITS() && track.itsNCls() >= minITSnCls) { + itsTracks++; + } + // Track Selection + if (track.isGlobalTrack()) { + glbTracks++; + meanpt += track.pt(); + et += std::sqrt(std::pow(track.pt(), 2.) + std::pow(o2::constants::physics::MassPionCharged, 2.)); + } + } + registry.fill(HIST("zPos"), collision.posZ()); registry.fill(HIST("T0Ccent"), collision.centFT0C()); - registry.fill(HIST("ZN"), znA + znC); + + registry.fill(HIST("ZNCcvsZNCsum"), sumZNC / 2.81, zdc.energyCommonZNC() / 2.81); + registry.fill(HIST("ZNAcvsZNAsum"), sumZNA / 2.81, zdc.energyCommonZNA() / 2.81); + registry.fill(HIST("ZPCcvsZPCsum"), sumZPC / 2.81, zdc.energyCommonZPC() / 2.81); + registry.fill(HIST("ZPAcvsZPAsum"), sumZPA / 2.81, zdc.energyCommonZPA() / 2.81); + registry.fill(HIST("ZNA"), znA); registry.fill(HIST("ZNC"), znC); registry.fill(HIST("ZPA"), zpA); registry.fill(HIST("ZPC"), zpC); + registry.fill(HIST("ZN"), znA + znC); registry.fill(HIST("ZNAVsZNC"), znC, znA); registry.fill(HIST("ZNAVsZPA"), zpA, znA); registry.fill(HIST("ZNCVsZPC"), zpC, znC); @@ -568,20 +530,93 @@ struct UccZdc { registry.fill(HIST("ZEM2Vstdc"), tZEM2, aZEM2); registry.fill(HIST("debunch"), tZDCdif, tZDCsum); + registry.fill(HIST("ZNVsFT0A"), aT0A / 100., sumZNs); + registry.fill(HIST("ZNVsFT0C"), aT0C / 100., sumZNs); + registry.fill(HIST("ZNVsFT0M"), (aT0A + aT0C) / 100., sumZNs); + + if (sumZNs > znBasedCut) { + return; + } + + registry.fill(HIST("NchVsFV0A"), aV0A / 100., glbTracks); + registry.fill(HIST("NchVsFT0A"), aT0A / 100., glbTracks); + registry.fill(HIST("NchVsFT0C"), aT0C / 100., glbTracks); + registry.fill(HIST("NchVsFT0M"), (aT0A + aT0C) / 100., glbTracks); + + registry.fill(HIST("NchVsEt"), et, glbTracks); + registry.fill(HIST("NchVsMeanPt"), glbTracks, meanpt / glbTracks); + registry.fill(HIST("NchVsNPV"), collision.multNTracksPVeta1(), glbTracks); + registry.fill(HIST("NchVsITStracks"), itsTracks, glbTracks); + registry.fill(HIST("ZNAVsNch"), glbTracks, znA); + registry.fill(HIST("ZNCVsNch"), glbTracks, znC); + registry.fill(HIST("ZNVsNch"), glbTracks, sumZNs); + registry.fill(HIST("ZNDifVsNch"), glbTracks, znA - znC); + } + PROCESS_SWITCH(UccZdc, processQA, "Process QA", true); + + void processZdcCollAss(o2::aod::ColEvSels::iterator const& collision, o2::aod::BCsRun3 const& /*bcs*/, aod::Zdcs const& /*zdcs*/, aod::FV0As const& /*fv0as*/, aod::FT0s const& /*ft0s*/, TheFilteredTracks const& tracks) + { + + if (!isEventSelected(collision)) { + return; + } + + const auto& foundBC = collision.foundBC_as(); + // has ZDC? + if (!foundBC.has_zdc()) { + return; + } + registry.fill(HIST("hEventCounter"), EvCutLabel::Zdc); + + if (!foundBC.has_ft0()) { + return; + } + registry.fill(HIST("hEventCounter"), EvCutLabel::TZero); + + float znA{foundBC.zdc().amplitudeZNA()}; + float znC{foundBC.zdc().amplitudeZNC()}; + float aZEM1{foundBC.zdc().amplitudeZEM1()}; + float aZEM2{foundBC.zdc().amplitudeZEM2()}; + float tZNA{foundBC.zdc().timeZNA()}; + float tZNC{foundBC.zdc().timeZNC()}; + float tZPA{foundBC.zdc().timeZPA()}; + float tZPC{foundBC.zdc().timeZPC()}; + float tZDCdif{tZNC + tZPC - tZNA - tZPA}; + float tZDCsum{tZNC + tZPC + tZNA + tZPA}; + znA /= 2.81; + znC /= 2.81; + float sumZNs{znA + znC}; + float sumZEMs{aZEM1 + aZEM2}; + + // TDC cut + if (isTDCcut) { + if (std::sqrt(std::pow(tZDCdif, 2.) + std::pow(tZDCsum, 2.)) > tdcCut) { + return; + } + registry.fill(HIST("hEventCounter"), EvCutLabel::Tdc); + } + + // ZEM cut + if (isZEMcut) { + if (sumZEMs < zemCut) { + return; + } + registry.fill(HIST("hEventCounter"), EvCutLabel::Zem); + } + + registry.fill(HIST("zPos"), collision.posZ()); + registry.fill(HIST("T0Ccent"), collision.centFT0C()); + std::vector pTs; std::vector wIs; - float itsTracks{0.}; - // Calculates the event weight, W_k for (const auto& track : tracks) { - if (track.hasITS() && track.itsNCls() >= minITSnCls) { - itsTracks++; - } // Track Selection if (!track.isGlobalTrack()) { continue; } + registry.fill(HIST("ZposVsEta"), collision.posZ(), track.eta()); registry.fill(HIST("EtaVsPhi"), track.eta(), track.phi()); registry.fill(HIST("sigma1Pt"), track.pt(), track.sigma1Pt()); registry.fill(HIST("dcaXYvspT"), track.dcaXY(), track.pt()); @@ -598,317 +633,265 @@ struct UccZdc { p1 = p2 = p3 = p4 = w1 = w2 = w3 = w4 = 0.0; getPTpowers(pTs, wIs, p1, w1, p2, w2, p3, w3, p4, w4); const double nch{static_cast(pTs.size())}; - if (!(nch != 0.)) + if (!(nch != 0.)) { return; + } - registry.fill(HIST("NchVsFV0A"), aV0A / 100., nch); - registry.fill(HIST("NchVsFT0A"), aT0A / 100., nch); - registry.fill(HIST("NchVsFT0C"), aT0C / 100., nch); - registry.fill(HIST("NchVsFT0M"), (aT0A + aT0C) / 100., nch); - registry.fill(HIST("ZNVsFT0A"), aT0A / 100., sumZNs); - registry.fill(HIST("ZNVsFT0C"), aT0C / 100., sumZNs); - registry.fill(HIST("ZNVsFT0M"), (aT0A + aT0C) / 100., sumZNs); - registry.fill(HIST("NchVsNPV"), collision.multNTracksPVeta1(), nch); - registry.fill(HIST("NchVsITStracks"), itsTracks, nch); - registry.fill(HIST("ZNAVsNch"), nch, znA); - registry.fill(HIST("ZNCVsNch"), nch, znC); - registry.fill(HIST("ZNVsNch"), nch, sumZNs); - registry.fill(HIST("ZNDifVsNch"), nch, znA - znC); - registry.fill(HIST("NchVsZpos"), nch, collision.posZ()); - - // QA check + // To calculate event-averaged for (const auto& track : tracks) { // Track Selection if (!track.isGlobalTrack()) { continue; } registry.fill(HIST("NchVsPt"), w1, track.pt()); - registry.fill(HIST("ZposVsEta"), collision.posZ(), track.eta()); } // EbE one-particle pT correlation - // P1 / W1 double oneParCorr{p1 / w1}; // EbE two-particle pT correlation - // (P1^{2} - P2)/(W1^{2} - W2) double denTwoParCorr{std::pow(w1, 2.) - w2}; double numTwoParCorr{std::pow(p1, 2.) - p2}; double twoParCorr{numTwoParCorr / denTwoParCorr}; // EbE three-particle pT correlation - // (P1^{3} − 3P2P1 + 2P3)/(W1^{3} − 3W2W1 + 2W3) double denThreeParCorr{std::pow(w1, 3.) - 3. * w2 * w1 + 2. * w3}; double numThreeParCorr{std::pow(p1, 3.) - 3. * p2 * p1 + 2. * p3}; double threeParCorr{numThreeParCorr / denThreeParCorr}; // EbE four-particle pT correlation - // (P1^{4} − 6P2P1^{2} + 3P2^{2} + 8P3P1 − 6P4)/(W1^{4} − 6W2W1^{2} + - // 3W2^{2} + 8W3W1 − 6W4) - double denFourParCorr{std::pow(w1, 4.) - 6. * w2 * std::pow(w1, 2.) + - 3. * std::pow(w2, 2.) + 8 * w3 * w1 - 6. * w4}; - double numFourParCorr{std::pow(p1, 4.) - 6. * p2 * std::pow(p1, 2.) + - 3. * std::pow(p2, 2.) + 8 * p3 * p1 - 6. * p4}; + double denFourParCorr{std::pow(w1, 4.) - 6. * w2 * std::pow(w1, 2.) + 3. * std::pow(w2, 2.) + 8 * w3 * w1 - 6. * w4}; + double numFourParCorr{std::pow(p1, 4.) - 6. * p2 * std::pow(p1, 2.) + 3. * std::pow(p2, 2.) + 8 * p3 * p1 - 6. * p4}; double fourParCorr{numFourParCorr / denFourParCorr}; - if (isZNbasedSel && (sumZNs > znBasedCut)) - return; - if (isZNAbasedSel && (znA > znBasedCut)) - return; - if (isZNCbasedSel && (znC > znBasedCut)) + if (sumZNs > znBasedCut) { return; + } registry.fill(HIST("Nch"), w1); registry.fill(HIST("NchRaw"), nch); registry.fill(HIST("NchVsOneParCorr"), w1, oneParCorr, w1); - registry.fill(HIST("NchVsTwoParCorr"), w1, twoParCorr, denTwoParCorr); - registry.fill(HIST("NchVsThreeParCorr"), w1, threeParCorr, denThreeParCorr); - registry.fill(HIST("NchVsFourParCorr"), w1, fourParCorr, denFourParCorr); + registry.fill(HIST("NchVsOneParCorrVsZN"), w1, sumZNs, oneParCorr, w1); + registry.fill(HIST("NchVsTwoParCorrVsZN"), w1, sumZNs, twoParCorr, denTwoParCorr); + registry.fill(HIST("NchVsThreeParCorrVsZN"), w1, sumZNs, threeParCorr, denThreeParCorr); + registry.fill(HIST("NchVsFourParCorrVsZN"), w1, sumZNs, fourParCorr, denFourParCorr); } PROCESS_SWITCH(UccZdc, processZdcCollAss, "Process ZDC W/Coll Ass.", true); - void processMCclosure( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups const& collisions, - aod::McParticles const& mcParticles, - TheFilteredSimTracks const& simTracks) + // Preslice perMCCollision = aod::mcparticle::mcCollisionId; + Preslice perCollision = aod::track::collisionId; + TRandom* randPointer = new TRandom(); + void processMCclosure(aod::McCollisions::iterator const& mccollision, soa::SmallGroups const& collisions, aod::McParticles const& mcParticles, TheFilteredSimTracks const& simTracks) { - //----- MC reconstructed -----// - for (const auto& collision : collisions) { - // Event selection - if (!isEventSelected(collision)) - continue; - // MC collision? - if (!collision.has_mcCollision()) - continue; - - const auto& cent{collision.centFT0C()}; - registry.fill(HIST("T0Ccent"), cent); - registry.fill(HIST("zPos"), collision.posZ()); - // registry.fill(HIST("nRecColvsCent"), collisions.size(), cent); - - const auto& groupedTracks = - simTracks.sliceBy(perCollision, collision.globalIndex()); - - std::vector pTs; - std::vector wIs; - - // Calculates the event weight, W_k - for (const auto& track : groupedTracks) { - // Track Selection - if (!track.isGlobalTrack()) - continue; - - // To match the primary particles - if (!track.has_mcParticle()) + float rndNum = randPointer->Uniform(0.0, 1.0); + registry.fill(HIST("RandomNumber"), rndNum); + + // Half of the statistics for MC closure + if (rndNum >= zEro && rndNum < oneHalf) { + registry.fill(HIST("EvtsDivided"), 0); + //----- MC reconstructed -----// + for (const auto& collision : collisions) { + // Event selection + if (!isEventSelected(collision)) { continue; - const auto& particle = track.mcParticle(); - if (!particle.isPhysicalPrimary()) + } + // MC collision? + if (!collision.has_mcCollision()) { continue; - - float pt{track.pt()}; - double trkEff{efficiency->GetBinContent(efficiency->FindBin(pt))}; - if (trkEff > 0.) { - pTs.emplace_back(pt); - wIs.emplace_back(1. / trkEff); } - } - - const double nch{static_cast(pTs.size())}; - if (!(nch != 0.)) - return; - double p1, p2, p3, p4, w1, w2, w3, w4; - p1 = p2 = p3 = p4 = w1 = w2 = w3 = w4 = 0.0; - getPTpowers(pTs, wIs, p1, w1, p2, w2, p3, w3, p4, w4); - - const double denTwoParCorr{std::pow(w1, 2.) - w2}; - const double numTwoParCorr{std::pow(p1, 2.) - p2}; - const double denThreeParCorr{std::pow(w1, 3.) - 3. * w2 * w1 + 2. * w3}; - const double numThreeParCorr{std::pow(p1, 3.) - 3. * p2 * p1 + 2. * p3}; - const double denFourParCorr{ - std::pow(w1, 4.) - 6. * w2 * std::pow(w1, 2.) + - 3. * std::pow(w2, 2.) + 8 * w3 * w1 - 6. * w4}; - const double numFourParCorr{ - std::pow(p1, 4.) - 6. * p2 * std::pow(p1, 2.) + - 3. * std::pow(p2, 2.) + 8 * p3 * p1 - 6. * p4}; - - const double oneParCorr{p1 / w1}; - const double twoParCorr{numTwoParCorr / denTwoParCorr}; - const double threeParCorr{numThreeParCorr / denThreeParCorr}; - const double fourParCorr{numFourParCorr / denFourParCorr}; - - registry.fill(HIST("Nch"), w1); - registry.fill(HIST("NchRaw"), nch); - registry.fill(HIST("NchVsOneParCorr"), w1, oneParCorr, w1); - registry.fill(HIST("NchVsTwoParCorr"), w1, twoParCorr, denTwoParCorr); - registry.fill(HIST("NchVsThreeParCorr"), w1, threeParCorr, - denThreeParCorr); - registry.fill(HIST("NchVsFourParCorr"), w1, fourParCorr, denFourParCorr); - - //--------------------------- Generated MC --------------------------- - if (std::fabs(mccollision.posZ()) > posZcut) - continue; + registry.fill(HIST("T0Ccent"), collision.centFT0C()); + registry.fill(HIST("zPos"), collision.posZ()); + + const auto& groupedTracks{simTracks.sliceBy(perCollision, collision.globalIndex())}; + + std::vector pTs; + std::vector wIs; + // Calculates the event weight, W_k + for (const auto& track : groupedTracks) { + // Track Selection + if (!track.isGlobalTrack()) { + continue; + } + + float pt{track.pt()}; + double weight{efficiency->GetBinContent(efficiency->FindBin(pt))}; + if (weight > 0.) { + pTs.emplace_back(pt); + wIs.emplace_back(weight); + } + } - std::vector pTsMC; - std::vector wIsMC; + const double nch{static_cast(pTs.size())}; + if (!(nch != 0.)) { + return; + } - // Calculates the event weight, W_k - for (const auto& particle : mcParticles) { - if (particle.eta() < minEta || particle.eta() > maxEta) - continue; - if (particle.pt() < minPt || particle.pt() > maxPt) - continue; - if (!particle.isPhysicalPrimary()) + double p1, p2, p3, p4, w1, w2, w3, w4; + p1 = p2 = p3 = p4 = w1 = w2 = w3 = w4 = 0.0; + getPTpowers(pTs, wIs, p1, w1, p2, w2, p3, w3, p4, w4); + + const double denTwoParCorr{std::pow(w1, 2.) - w2}; + const double numTwoParCorr{std::pow(p1, 2.) - p2}; + const double denThreeParCorr{std::pow(w1, 3.) - 3. * w2 * w1 + 2. * w3}; + const double numThreeParCorr{std::pow(p1, 3.) - 3. * p2 * p1 + 2. * p3}; + const double denFourParCorr{std::pow(w1, 4.) - 6. * w2 * std::pow(w1, 2.) + 3. * std::pow(w2, 2.) + 8 * w3 * w1 - 6. * w4}; + const double numFourParCorr{std::pow(p1, 4.) - 6. * p2 * std::pow(p1, 2.) + 3. * std::pow(p2, 2.) + 8 * p3 * p1 - 6. * p4}; + + const double oneParCorr{p1 / w1}; + const double twoParCorr{numTwoParCorr / denTwoParCorr}; + const double threeParCorr{numThreeParCorr / denThreeParCorr}; + const double fourParCorr{numFourParCorr / denFourParCorr}; + + registry.fill(HIST("Nch"), w1); + registry.fill(HIST("NchRaw"), nch); + registry.fill(HIST("NchVsOneParCorr"), w1, oneParCorr, w1); + registry.fill(HIST("NchVsTwoParCorr"), w1, twoParCorr, denTwoParCorr); + registry.fill(HIST("NchVsThreeParCorr"), w1, threeParCorr, denThreeParCorr); + registry.fill(HIST("NchVsFourParCorr"), w1, fourParCorr, denFourParCorr); + + //--------------------------- Generated MC --------------------------- + registry.fill(HIST("hEventCounterMC"), EvCutLabel::All); + if (std::fabs(mccollision.posZ()) > posZcut) { continue; + } + registry.fill(HIST("zPosMC"), mccollision.posZ()); + registry.fill(HIST("hEventCounterMC"), EvCutLabel::VtxZ); + + std::vector pTsMC; + std::vector wIsMC; + // Calculates the event weight, W_k + for (const auto& particle : mcParticles) { + if (particle.eta() < minEta || particle.eta() > maxEta) { + continue; + } + if (particle.pt() < minPt || particle.pt() > maxPt) { + continue; + } + if (!particle.isPhysicalPrimary()) { + continue; + } + + float pt{particle.pt()}; + pTsMC.emplace_back(pt); + wIsMC.emplace_back(1.); + } - float pt{particle.pt()}; - pTsMC.emplace_back(pt); - wIsMC.emplace_back(1.); + const double nchMC{static_cast(pTsMC.size())}; + double p1MC, p2MC, p3MC, p4MC, w1MC, w2MC, w3MC, w4MC; + p1MC = p2MC = p3MC = p4MC = w1MC = w2MC = w3MC = w4MC = 0.0; + getPTpowers(pTsMC, wIsMC, p1MC, w1MC, p2MC, w2MC, p3MC, w3MC, p4MC, w4MC); + + const double denTwoParCorrMC{std::pow(w1MC, 2.) - w2MC}; + const double numTwoParCorrMC{std::pow(p1MC, 2.) - p2MC}; + const double denThreeParCorrMC{std::pow(w1MC, 3.) - 3. * w2MC * w1MC + 2. * w3MC}; + const double numThreeParCorrMC{std::pow(p1MC, 3.) - 3. * p2MC * p1MC + 2. * p3MC}; + const double denFourParCorrMC{std::pow(w1MC, 4.) - 6. * w2MC * std::pow(w1MC, 2.) + 3. * std::pow(w2MC, 2.) + 8 * w3MC * w1MC - 6. * w4MC}; + const double numFourParCorrMC{std::pow(p1MC, 4.) - 6. * p2MC * std::pow(p1MC, 2.) + 3. * std::pow(p2MC, 2.) + 8 * p3MC * p1MC - 6. * p4MC}; + + const double oneParCorrMC{p1MC / w1MC}; + const double twoParCorrMC{numTwoParCorrMC / denTwoParCorrMC}; + const double threeParCorrMC{numThreeParCorrMC / denThreeParCorrMC}; + const double fourParCorrMC{numFourParCorrMC / denFourParCorrMC}; + + registry.fill(HIST("NchGen"), nchMC); + registry.fill(HIST("NchvsOneParCorrGen"), nchMC, oneParCorrMC, w1MC); + registry.fill(HIST("NchvsTwoParCorrGen"), nchMC, twoParCorrMC, denTwoParCorrMC); + registry.fill(HIST("NchvsThreeParCorrGen"), nchMC, threeParCorrMC, denThreeParCorrMC); + registry.fill(HIST("NchvsFourParCorrGen"), nchMC, fourParCorrMC, denFourParCorrMC); } - - const double nchMC{static_cast(pTsMC.size())}; - double p1MC, p2MC, p3MC, p4MC, w1MC, w2MC, w3MC, w4MC; - p1MC = p2MC = p3MC = p4MC = w1MC = w2MC = w3MC = w4MC = 0.0; - getPTpowers(pTsMC, wIsMC, p1MC, w1MC, p2MC, w2MC, p3MC, w3MC, p4MC, w4MC); - - const double denTwoParCorrMC{std::pow(w1MC, 2.) - w2MC}; - const double numTwoParCorrMC{std::pow(p1MC, 2.) - p2MC}; - const double denThreeParCorrMC{std::pow(w1MC, 3.) - 3. * w2MC * w1MC + - 2. * w3MC}; - const double numThreeParCorrMC{std::pow(p1MC, 3.) - 3. * p2MC * p1MC + - 2. * p3MC}; - const double denFourParCorrMC{ - std::pow(w1MC, 4.) - 6. * w2MC * std::pow(w1MC, 2.) + - 3. * std::pow(w2MC, 2.) + 8 * w3MC * w1MC - 6. * w4MC}; - const double numFourParCorrMC{ - std::pow(p1MC, 4.) - 6. * p2MC * std::pow(p1MC, 2.) + - 3. * std::pow(p2MC, 2.) + 8 * p3MC * p1MC - 6. * p4MC}; - - const double oneParCorrMC{p1MC / w1MC}; - const double twoParCorrMC{numTwoParCorrMC / denTwoParCorrMC}; - const double threeParCorrMC{numThreeParCorrMC / denThreeParCorrMC}; - const double fourParCorrMC{numFourParCorrMC / denFourParCorrMC}; - - registry.fill(HIST("NchGen"), nchMC); - registry.fill(HIST("NchvsOneParCorrGen"), nchMC, oneParCorrMC, w1MC); - registry.fill(HIST("NchvsTwoParCorrGen"), nchMC, twoParCorrMC, - denTwoParCorrMC); - registry.fill(HIST("NchvsThreeParCorrGen"), nchMC, threeParCorrMC, - denThreeParCorrMC); - registry.fill(HIST("NchvsFourParCorrGen"), nchMC, fourParCorrMC, - denFourParCorrMC); - } - } - PROCESS_SWITCH(UccZdc, processMCclosure, "Process MC closure", false); - - Preslice perMCCollision = aod::mcparticle::mcCollisionId; - Preslice perCollision = aod::track::collisionId; - void processpTEff(aod::McCollisions::iterator const& mccollision, - soa::SmallGroups const& collisions, - aod::McParticles const& mcParticles, - TheFilteredSimTracks const& simTracks) - { - //----- MC reconstructed -----// - for (const auto& collision : collisions) { - // Event selection - if (!isEventSelected(collision)) - continue; - - // MC collision? - if (!collision.has_mcCollision()) - continue; - - registry.fill(HIST("zPos"), collision.posZ()); - registry.fill(HIST("nRecColvsCent"), collisions.size(), - collision.centFT0C()); - - const auto& cent{collision.centFT0C()}; - registry.fill(HIST("T0Ccent"), cent); - - const auto& groupedTracks = - simTracks.sliceBy(perCollision, collision.globalIndex()); - for (const auto& track : groupedTracks) { - if (!track.has_mcParticle()) - continue; - - const auto& particle = track.mcParticle(); - registry.fill(HIST("Pt_all_ch"), cent, track.pt()); - registry.fill(HIST("EtaVsPhi"), track.eta(), track.phi()); - - if (!particle.isPhysicalPrimary()) + } else { + registry.fill(HIST("EvtsDivided"), 1); + //----- MC reconstructed -----// + for (const auto& collision : collisions) { + // Event selection + if (!isEventSelected(collision)) { continue; - - registry.fill(HIST("Pt_ch"), cent, track.pt()); - if (particle.pdgCode() == PDG_t::kPiPlus || - particle.pdgCode() == PDG_t::kPiMinus) { - registry.fill(HIST("Pt_pi"), cent, track.pt()); - } else if (particle.pdgCode() == PDG_t::kKPlus || - particle.pdgCode() == PDG_t::kKMinus) { - registry.fill(HIST("Pt_ka"), cent, track.pt()); - } else if (particle.pdgCode() == PDG_t::kProton || - particle.pdgCode() == PDG_t::kProtonBar) { - registry.fill(HIST("Pt_pr"), cent, track.pt()); - } else if (particle.pdgCode() == PDG_t::kSigmaPlus || - particle.pdgCode() == PDG_t::kSigmaBarMinus) { - registry.fill(HIST("Pt_sigpos"), cent, track.pt()); - } else if (particle.pdgCode() == PDG_t::kSigmaMinus || - particle.pdgCode() == PDG_t::kSigmaBarPlus) { - registry.fill(HIST("Pt_signeg"), cent, track.pt()); - } else { - registry.fill(HIST("Pt_re"), cent, track.pt()); } - } - - // Generated MC - registry.fill(HIST("hEventCounterMC"), EvCutLabel::All); - if (std::fabs(mccollision.posZ()) > posZcut) - continue; - registry.fill(HIST("zPosMC"), mccollision.posZ()); - registry.fill(HIST("hEventCounterMC"), EvCutLabel::VtxZ); - - for (const auto& particle : mcParticles) { - if (particle.eta() < minEta || particle.eta() > maxEta) { + // MC collision? + if (!collision.has_mcCollision()) { continue; } - if (particle.pt() < minPt || particle.pt() > maxPt) { - continue; + + registry.fill(HIST("zPos"), collision.posZ()); + registry.fill(HIST("nRecColvsCent"), collisions.size(), collision.centFT0C()); + + const auto& cent{collision.centFT0C()}; + registry.fill(HIST("T0Ccent"), cent); + + const auto& groupedTracks{simTracks.sliceBy(perCollision, collision.globalIndex())}; + for (const auto& track : groupedTracks) { + if (!track.has_mcParticle()) { + continue; + } + + const auto& particle{track.mcParticle()}; + registry.fill(HIST("Pt_all_ch"), cent, track.pt()); + registry.fill(HIST("EtaVsPhi"), track.eta(), track.phi()); + + if (!particle.isPhysicalPrimary()) { + continue; + } + + registry.fill(HIST("Pt_ch"), cent, track.pt()); + if (particle.pdgCode() == PDG_t::kPiPlus || particle.pdgCode() == PDG_t::kPiMinus) { + registry.fill(HIST("Pt_pi"), cent, track.pt()); + } else if (particle.pdgCode() == PDG_t::kKPlus || particle.pdgCode() == PDG_t::kKMinus) { + registry.fill(HIST("Pt_ka"), cent, track.pt()); + } else if (particle.pdgCode() == PDG_t::kProton || particle.pdgCode() == PDG_t::kProtonBar) { + registry.fill(HIST("Pt_pr"), cent, track.pt()); + } else if (particle.pdgCode() == PDG_t::kSigmaPlus || particle.pdgCode() == PDG_t::kSigmaBarMinus) { + registry.fill(HIST("Pt_sigpos"), cent, track.pt()); + } else if (particle.pdgCode() == PDG_t::kSigmaMinus || particle.pdgCode() == PDG_t::kSigmaBarPlus) { + registry.fill(HIST("Pt_signeg"), cent, track.pt()); + } else { + registry.fill(HIST("Pt_re"), cent, track.pt()); + } } - if (!particle.isPhysicalPrimary()) { + + // Generated MC + registry.fill(HIST("hEventCounterMC"), EvCutLabel::All); + if (std::fabs(mccollision.posZ()) > posZcut) { continue; } - registry.fill(HIST("PtMC_ch"), cent, particle.pt()); - if (particle.pdgCode() == PDG_t::kPiPlus || - particle.pdgCode() == PDG_t::kPiMinus) { // pion - registry.fill(HIST("PtMC_pi"), cent, particle.pt()); - } else if (particle.pdgCode() == PDG_t::kKPlus || - particle.pdgCode() == PDG_t::kKMinus) { // kaon - registry.fill(HIST("PtMC_ka"), cent, particle.pt()); - } else if (particle.pdgCode() == PDG_t::kProton || - particle.pdgCode() == PDG_t::kProtonBar) { // proton - registry.fill(HIST("PtMC_pr"), cent, particle.pt()); - } else if (particle.pdgCode() == PDG_t::kSigmaPlus || - particle.pdgCode() == - PDG_t::kSigmaBarMinus) { // positive sigma - registry.fill(HIST("PtMC_sigpos"), cent, particle.pt()); - } else if (particle.pdgCode() == PDG_t::kSigmaMinus || - particle.pdgCode() == - PDG_t::kSigmaBarPlus) { // negative sigma - registry.fill(HIST("PtMC_signeg"), cent, particle.pt()); - } else { // rest - registry.fill(HIST("PtMC_re"), cent, particle.pt()); + registry.fill(HIST("zPosMC"), mccollision.posZ()); + registry.fill(HIST("hEventCounterMC"), EvCutLabel::VtxZ); + + for (const auto& particle : mcParticles) { + if (particle.eta() < minEta || particle.eta() > maxEta) { + continue; + } + if (particle.pt() < minPt || particle.pt() > maxPt) { + continue; + } + if (!particle.isPhysicalPrimary()) { + continue; + } + + registry.fill(HIST("PtMC_ch"), cent, particle.pt()); + if (particle.pdgCode() == PDG_t::kPiPlus || particle.pdgCode() == PDG_t::kPiMinus) { // pion + registry.fill(HIST("PtMC_pi"), cent, particle.pt()); + } else if (particle.pdgCode() == PDG_t::kKPlus || particle.pdgCode() == PDG_t::kKMinus) { // kaon + registry.fill(HIST("PtMC_ka"), cent, particle.pt()); + } else if (particle.pdgCode() == PDG_t::kProton || particle.pdgCode() == PDG_t::kProtonBar) { // proton + registry.fill(HIST("PtMC_pr"), cent, particle.pt()); + } else if (particle.pdgCode() == PDG_t::kSigmaPlus || particle.pdgCode() == PDG_t::kSigmaBarMinus) { // positive sigma + registry.fill(HIST("PtMC_sigpos"), cent, particle.pt()); + } else if (particle.pdgCode() == PDG_t::kSigmaMinus || particle.pdgCode() == PDG_t::kSigmaBarPlus) { // negative sigma + registry.fill(HIST("PtMC_signeg"), cent, particle.pt()); + } else { // rest + registry.fill(HIST("PtMC_re"), cent, particle.pt()); + } } } - } + } // Half of statistics for corrections } - PROCESS_SWITCH(UccZdc, processpTEff, "Process pT Eff", false); + PROCESS_SWITCH(UccZdc, processMCclosure, "Process MC closure", false); template - void getPTpowers(const T& pTs, const T& wIs, U& pOne, U& wOne, U& pTwo, - U& wTwo, U& pThree, U& wThree, U& pFour, U& wFour) + void getPTpowers(const T& pTs, const T& wIs, U& pOne, U& wOne, U& pTwo, U& wTwo, U& pThree, U& wThree, U& pFour, U& wFour) { pOne = wOne = pTwo = wTwo = pThree = wThree = pFour = wFour = 0.; - for (std::size_t i = 0; i < pTs.size(); ++i) { const float pTi{pTs.at(i)}; const float wEighti{wIs.at(i)}; diff --git a/PWGLF/Tasks/Resonances/doublephimeson.cxx b/PWGLF/Tasks/Resonances/doublephimeson.cxx index 23eb7a8043d..9f10015c021 100644 --- a/PWGLF/Tasks/Resonances/doublephimeson.cxx +++ b/PWGLF/Tasks/Resonances/doublephimeson.cxx @@ -50,14 +50,17 @@ struct doublephimeson { Configurable cutMinNsigmaTPC{"cutMinNsigmaTPC", -2.5, "nsigma cut TPC"}; Configurable cutNsigmaTPC{"cutNsigmaTPC", 3.0, "nsigma cut TPC"}; Configurable cutNsigmaTOF{"cutNsigmaTOF", 3.0, "nsigma cut TOF"}; + Configurable momTOFCut{"momTOFCut", 1.8, "minimum pT cut for madnatory TOF"}; + Configurable maxKaonPt{"maxKaonPt", 4.0, "maximum kaon pt cut"}; // Event Mixing - Configurable nEvtMixing{"nEvtMixing", 10, "Number of events to mix"}; + Configurable nEvtMixing{"nEvtMixing", 1, "Number of events to mix"}; ConfigurableAxis CfgVtxBins{"CfgVtxBins", {10, -10, 10}, "Mixing bins - z-vertex"}; ConfigurableAxis CfgMultBins{"CfgMultBins", {VARIABLE_WIDTH, 0.0, 20.0, 40.0, 60.0, 80.0, 500.0}, "Mixing bins - number of contributor"}; // THnsparse bining ConfigurableAxis configThnAxisInvMass{"configThnAxisInvMass", {1500, 2.0, 3.5}, "#it{M} (GeV/#it{c}^{2})"}; ConfigurableAxis configThnAxisInvMassPhi{"configThnAxisInvMassPhi", {20, 1.01, 1.03}, "#it{M} (GeV/#it{c}^{2})"}; + ConfigurableAxis configThnAxisInvMassDeltaPhi{"configThnAxisInvMassDeltaPhi", {80, 0.0, 0.08}, "#it{M} (GeV/#it{c}^{2})"}; ConfigurableAxis configThnAxisDaugherPt{"configThnAxisDaugherPt", {25, 0.0, 50.}, "#it{p}_{T} (GeV/#it{c})"}; ConfigurableAxis configThnAxisPt{"configThnAxisPt", {40, 0.0, 20.}, "#it{p}_{T} (GeV/#it{c})"}; ConfigurableAxis configThnAxisKstar{"configThnAxisKstar", {200, 0.0, 2.0}, "#it{k}^{*} (GeV/#it{c})"}; @@ -71,17 +74,20 @@ struct doublephimeson { // register histograms histos.add("hnsigmaTPCKaonPlus", "hnsigmaTPCKaonPlus", kTH2F, {{1000, -3.0, 3.0f}, {100, 0.0f, 10.0f}}); histos.add("hnsigmaTPCKaonMinus", "hnsigmaTPCKaonMinus", kTH2F, {{1000, -3.0, 3.0f}, {100, 0.0f, 10.0f}}); + histos.add("hnsigmaTPCTOFKaon", "hnsigmaTPCTOFKaon", kTH3F, {{500, -3.0, 3.0f}, {500, -3.0, 3.0f}, {100, 0.0f, 10.0f}}); histos.add("hPhiMass", "hPhiMass", kTH2F, {{40, 1.0, 1.04f}, {100, 0.0f, 10.0f}}); + histos.add("hPhiMass2", "hPhiMass2", kTH2F, {{40, 1.0, 1.04f}, {40, 1.0f, 1.04f}}); const AxisSpec thnAxisInvMass{configThnAxisInvMass, "#it{M} (GeV/#it{c}^{2})"}; const AxisSpec thnAxisInvMassPhi{configThnAxisInvMassPhi, "#it{M} (GeV/#it{c}^{2})"}; + const AxisSpec thnAxisInvMassDeltaPhi{configThnAxisInvMassDeltaPhi, "#it{M} (GeV/#it{c}^{2})"}; const AxisSpec thnAxisPt{configThnAxisPt, "#it{p}_{T} (GeV/#it{c})"}; const AxisSpec thnAxisDeltaR{configThnAxisDeltaR, "#Delta R)"}; const AxisSpec thnAxisCosTheta{configThnAxisCosTheta, "cos #theta"}; const AxisSpec thnAxisNumPhi{configThnAxisNumPhi, "Number of phi meson"}; - histos.add("SEMassUnlike", "SEMassUnlike", HistType::kTHnSparseF, {thnAxisInvMass, thnAxisPt, thnAxisDeltaR, thnAxisCosTheta, thnAxisInvMassPhi, thnAxisInvMassPhi, thnAxisNumPhi}); - histos.add("MEMassUnlike", "MEMassUnlike", HistType::kTHnSparseF, {thnAxisInvMass, thnAxisPt, thnAxisDeltaR, thnAxisCosTheta, thnAxisInvMassPhi, thnAxisInvMassPhi, thnAxisNumPhi}); + histos.add("SEMassUnlike", "SEMassUnlike", HistType::kTHnSparseF, {thnAxisInvMass, thnAxisPt, thnAxisDeltaR, thnAxisCosTheta, thnAxisInvMassDeltaPhi, thnAxisNumPhi}); + histos.add("MEMassUnlike", "MEMassUnlike", HistType::kTHnSparseF, {thnAxisInvMass, thnAxisPt, thnAxisDeltaR, thnAxisCosTheta, thnAxisInvMassDeltaPhi}); } // get kstar @@ -149,18 +155,35 @@ struct doublephimeson { } if (ptcand >= 0.5) { if (TOFHit != 1) { - if (nsigmaTPC > cutMinNsigmaTPC && nsigmaTPC < cutNsigmaTPC) { + if (ptcand >= 0.5 && ptcand < 0.6 && nsigmaTPC > -1.5 && nsigmaTPC < cutNsigmaTPC) { + return true; + } + if (ptcand >= 0.6 && ptcand < 0.7 && nsigmaTPC > -1.0 && nsigmaTPC < cutNsigmaTPC) { + return true; + } + if (ptcand >= 0.7 && ptcand < 0.8 && nsigmaTPC > -0.4 && nsigmaTPC < cutNsigmaTPC) { + return true; + } + if (ptcand >= 0.8 && ptcand < 1.0 && nsigmaTPC > -0.0 && nsigmaTPC < cutNsigmaTPC) { + return true; + } + if (ptcand >= 1.0 && ptcand < 1.8 && nsigmaTPC > -2.0 && nsigmaTPC < 2.0) { + return true; + } + if (ptcand >= 1.8 && ptcand < 2.0 && nsigmaTPC > -2.0 && nsigmaTPC < 1.5) { + return true; + } + if (ptcand >= 2.0 && nsigmaTPC > -2.0 && nsigmaTPC < 1.0) { return true; } } if (TOFHit == 1) { - if (nsigmaTPC > cutMinNsigmaTPC && nsigmaTPC < cutNsigmaTPC && TMath::Abs(nsigmaTOF) < cutNsigmaTOF) { + if (TMath::Sqrt((nsigmaTPC * nsigmaTPC + nsigmaTOF * nsigmaTOF) / 2.0) < cutNsigmaTOF) { return true; } } } } - if (PIDStrategy == 1) { if (ptcand < 0.5) { if (nsigmaTPC > cutMinNsigmaTPC && nsigmaTPC < cutNsigmaTPC) { @@ -175,6 +198,62 @@ struct doublephimeson { } } } + if (PIDStrategy == 2) { + if (ptcand < 0.5) { + if (nsigmaTPC > cutMinNsigmaTPC && nsigmaTPC < cutNsigmaTPC) { + return true; + } + } + if (ptcand >= 0.5) { + if (TOFHit != 1 && ptcand < momTOFCut) { + if (ptcand >= 0.5 && ptcand < 0.6 && nsigmaTPC > -1.5 && nsigmaTPC < cutNsigmaTPC) { + return true; + } + if (ptcand >= 0.6 && ptcand < 0.7 && nsigmaTPC > -1.0 && nsigmaTPC < cutNsigmaTPC) { + return true; + } + if (ptcand >= 0.7 && ptcand < 0.8 && nsigmaTPC > -0.4 && nsigmaTPC < cutNsigmaTPC) { + return true; + } + if (ptcand >= 0.8 && ptcand < 1.0 && nsigmaTPC > -0.0 && nsigmaTPC < cutNsigmaTPC) { + return true; + } + if (ptcand >= 1.0 && ptcand < 1.8 && nsigmaTPC > -2.0 && nsigmaTPC < 2.0) { + return true; + } + if (ptcand >= 1.8 && ptcand < 2.0 && nsigmaTPC > -2.0 && nsigmaTPC < 1.5) { + return true; + } + if (ptcand >= 2.0 && nsigmaTPC > -2.0 && nsigmaTPC < 1.0) { + return true; + } + } + if (TOFHit == 1) { + if (TMath::Sqrt((nsigmaTPC * nsigmaTPC + nsigmaTOF * nsigmaTOF) / 2.0) < cutNsigmaTOF) { + return true; + } + } + } + } + if (PIDStrategy == 3) { + if (ptcand < 0.5) { + if (nsigmaTPC > cutMinNsigmaTPC && nsigmaTPC < cutNsigmaTPC) { + return true; + } + } + if (ptcand >= 0.5) { + if (TOFHit != 1) { + if (nsigmaTPC > cutMinNsigmaTPC && nsigmaTPC < cutNsigmaTPC) { + return true; + } + } + if (TOFHit == 1) { + if (TMath::Sqrt((nsigmaTPC * nsigmaTPC + nsigmaTOF * nsigmaTOF) / 2.0) < cutNsigmaTOF) { + return true; + } + } + } + } return false; } @@ -186,24 +265,51 @@ struct doublephimeson { if (additionalEvsel && (collision.numPos() < 2 || collision.numNeg() < 2)) { return; } - auto phimult = phitracks.size(); + int phimult = 0; for (auto phitrackd1 : phitracks) { if (phitrackd1.phiMass() < minPhiMass || phitrackd1.phiMass() > maxPhiMass) { continue; } auto kaonplusd1pt = TMath::Sqrt(phitrackd1.phid1Px() * phitrackd1.phid1Px() + phitrackd1.phid1Py() * phitrackd1.phid1Py()); auto kaonminusd1pt = TMath::Sqrt(phitrackd1.phid2Px() * phitrackd1.phid2Px() + phitrackd1.phid2Py() * phitrackd1.phid2Py()); + if (kaonplusd1pt > maxKaonPt) { + continue; + } + if (kaonminusd1pt > maxKaonPt) { + continue; + } if (!selectionPID(phitrackd1.phid1TPC(), phitrackd1.phid1TOF(), phitrackd1.phid1TOFHit(), strategyPID1, kaonplusd1pt)) { continue; } if (!selectionPID(phitrackd1.phid2TPC(), phitrackd1.phid2TOF(), phitrackd1.phid2TOFHit(), strategyPID1, kaonminusd1pt)) { continue; } - auto phid1id = phitrackd1.index(); - Phid1.SetXYZM(phitrackd1.phiPx(), phitrackd1.phiPy(), phitrackd1.phiPz(), phitrackd1.phiMass()); + phimult = phimult + 1; + } + for (auto phitrackd1 : phitracks) { + if (phitrackd1.phiMass() < minPhiMass || phitrackd1.phiMass() > maxPhiMass) { + continue; + } + auto kaonplusd1pt = TMath::Sqrt(phitrackd1.phid1Px() * phitrackd1.phid1Px() + phitrackd1.phid1Py() * phitrackd1.phid1Py()); + auto kaonminusd1pt = TMath::Sqrt(phitrackd1.phid2Px() * phitrackd1.phid2Px() + phitrackd1.phid2Py() * phitrackd1.phid2Py()); + if (kaonplusd1pt > maxKaonPt) { + continue; + } + if (kaonminusd1pt > maxKaonPt) { + continue; + } + if (!selectionPID(phitrackd1.phid1TPC(), phitrackd1.phid1TOF(), phitrackd1.phid1TOFHit(), strategyPID1, kaonplusd1pt)) { + continue; + } + histos.fill(HIST("hnsigmaTPCTOFKaon"), phitrackd1.phid1TPC(), phitrackd1.phid1TOF(), kaonplusd1pt); histos.fill(HIST("hnsigmaTPCKaonPlus"), phitrackd1.phid1TPC(), kaonplusd1pt); + if (!selectionPID(phitrackd1.phid2TPC(), phitrackd1.phid2TOF(), phitrackd1.phid2TOFHit(), strategyPID1, kaonminusd1pt)) { + continue; + } histos.fill(HIST("hnsigmaTPCKaonMinus"), phitrackd1.phid2TPC(), kaonminusd1pt); histos.fill(HIST("hPhiMass"), Phid1.M(), Phid1.Pt()); + auto phid1id = phitrackd1.index(); + Phid1.SetXYZM(phitrackd1.phiPx(), phitrackd1.phiPy(), phitrackd1.phiPz(), phitrackd1.phiMass()); for (auto phitrackd2 : phitracks) { auto phid2id = phitrackd2.index(); if (phid2id <= phid1id) { @@ -214,6 +320,12 @@ struct doublephimeson { } auto kaonplusd2pt = TMath::Sqrt(phitrackd2.phid1Px() * phitrackd2.phid1Px() + phitrackd2.phid1Py() * phitrackd2.phid1Py()); auto kaonminusd2pt = TMath::Sqrt(phitrackd2.phid2Px() * phitrackd2.phid2Px() + phitrackd2.phid2Py() * phitrackd2.phid2Py()); + if (kaonplusd2pt > maxKaonPt) { + continue; + } + if (kaonminusd2pt > maxKaonPt) { + continue; + } if (!selectionPID(phitrackd2.phid1TPC(), phitrackd2.phid1TOF(), phitrackd2.phid1TOFHit(), strategyPID2, kaonplusd2pt)) { continue; } @@ -232,11 +344,13 @@ struct doublephimeson { // auto kstar = getkstar(Phid1, Phid2); auto deltaR = TMath::Sqrt(TMath::Power(Phid1.Phi() - Phid2.Phi(), 2.0) + TMath::Power(Phid1.Eta() - Phid2.Eta(), 2.0)); auto costheta = (Phid1.Px() * Phid2.Px() + Phid1.Py() * Phid2.Py() + Phid1.Pz() * Phid2.Pz()) / (Phid1.P() * Phid2.P()); + auto deltam = TMath::Sqrt(TMath::Power(Phid1.M() - 1.0192, 2.0) + TMath::Power(Phid2.M() - 1.0192, 2.0)); + histos.fill(HIST("hPhiMass2"), Phid1.M(), Phid2.M()); if (!isDeep) { - histos.fill(HIST("SEMassUnlike"), exotic.M(), exotic.Pt(), deltaR, costheta, Phid1.M(), Phid2.M(), phimult); + histos.fill(HIST("SEMassUnlike"), exotic.M(), exotic.Pt(), deltaR, costheta, deltam, phimult); } if (isDeep) { - histos.fill(HIST("SEMassUnlike"), exotic.M(), exotic.Pt(), deltaR, deepangle(Phid1, Phid2), Phid1.M(), Phid2.M(), phimult); + histos.fill(HIST("SEMassUnlike"), exotic.M(), exotic.Pt(), deltaR, deepangle(Phid1, Phid2), deltam, phimult); } } } @@ -254,7 +368,6 @@ struct doublephimeson { if (collision1.index() == collision2.index()) { continue; } - auto phimult = tracks1.size(); for (auto& [phitrackd1, phitrackd2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(tracks1, tracks2))) { if (phitrackd1.phiMass() < minPhiMass || phitrackd1.phiMass() > maxPhiMass) { continue; @@ -266,6 +379,18 @@ struct doublephimeson { auto kaonminusd1pt = TMath::Sqrt(phitrackd1.phid2Px() * phitrackd1.phid2Px() + phitrackd1.phid2Py() * phitrackd1.phid2Py()); auto kaonplusd2pt = TMath::Sqrt(phitrackd2.phid1Px() * phitrackd2.phid1Px() + phitrackd2.phid1Py() * phitrackd2.phid1Py()); auto kaonminusd2pt = TMath::Sqrt(phitrackd2.phid2Px() * phitrackd2.phid2Px() + phitrackd2.phid2Py() * phitrackd2.phid2Py()); + if (kaonplusd1pt > maxKaonPt) { + continue; + } + if (kaonminusd1pt > maxKaonPt) { + continue; + } + if (kaonplusd2pt > maxKaonPt) { + continue; + } + if (kaonminusd2pt > maxKaonPt) { + continue; + } if (!selectionPID(phitrackd1.phid1TPC(), phitrackd1.phid1TOF(), phitrackd1.phid1TOFHit(), strategyPID1, kaonplusd1pt)) { continue; } @@ -283,11 +408,12 @@ struct doublephimeson { exotic = Phid1 + Phid2; auto deltaR = TMath::Sqrt(TMath::Power(Phid1.Phi() - Phid2.Phi(), 2.0) + TMath::Power(Phid1.Eta() - Phid2.Eta(), 2.0)); auto costheta = (Phid1.Px() * Phid2.Px() + Phid1.Py() * Phid2.Py() + Phid1.Pz() * Phid2.Pz()) / (Phid1.P() * Phid2.P()); + auto deltam = TMath::Sqrt(TMath::Power(Phid1.M() - 1.0192, 2.0) + TMath::Power(Phid2.M() - 1.0192, 2.0)); if (!isDeep) { - histos.fill(HIST("MEMassUnlike"), exotic.M(), exotic.Pt(), deltaR, costheta, Phid1.M(), Phid2.M(), phimult); + histos.fill(HIST("MEMassUnlike"), exotic.M(), exotic.Pt(), deltaR, costheta, deltam); } if (isDeep) { - histos.fill(HIST("MEMassUnlike"), exotic.M(), exotic.Pt(), deltaR, deepangle(Phid1, Phid2), Phid1.M(), Phid2.M(), phimult); + histos.fill(HIST("MEMassUnlike"), exotic.M(), exotic.Pt(), deltaR, deepangle(Phid1, Phid2), deltam); } } }