diff --git a/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx b/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx index e4cbd6bcd3f..40577807823 100644 --- a/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx +++ b/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx @@ -184,11 +184,11 @@ enum TrkSel { trkSelEta, trkSelPt, trkSelDCA, + trkSelCustomDCA, trkNRowsTPC, trkSelNClsFound, trkSelNClsPID, trkSelTPCBndr, - trkSelCustomDCA, nTrkSel }; @@ -240,51 +240,56 @@ struct FlattenictyPikp { int runNumber{-1}; o2::parameters::GRPMagField* grpmag = nullptr; - Configurable multEst{"multEst", 1, "0: without multiplicity; 1: MultFT0M; 2: MultTPC"}; - Configurable applyCalibGain{"applyCalibGain", false, "equalize detector amplitudes"}; - Configurable applyCalibVtx{"applyCalibVtx", false, "equalize Amp vs vtx"}; - Configurable applyCalibDeDx{"applyCalibDeDx", false, "calibration of dedx signal"}; - Configurable applyCalibDeDxFromCCDB{"applyCalibDeDxFromCCDB", true, "use CCDB-based calibration of dedx signal"}; - Configurable cfgFillTrackQaHist{"cfgFillTrackQaHist", false, "fill track QA histograms"}; - Configurable cfgFillNclVsPhiCutQaHist{"cfgFillNclVsPhiCutQaHist", false, "fill TPC cluster vs geometrical cut QA histograms"}; - Configurable cfgFilldEdxCalibHist{"cfgFilldEdxCalibHist", false, "fill dEdx calibration histograms"}; - Configurable cfgFilldEdxQaHist{"cfgFilldEdxQaHist", false, "fill dEdx QA histograms"}; - Configurable cfgFillDCAxyHist{"cfgFillDCAxyHist", false, "fill nsigma QA histograms"}; - Configurable cfgFillV0Hist{"cfgFillV0Hist", false, "fill V0 histograms"}; - Configurable cfgFillChrgType{"cfgFillChrgType", false, "fill histograms per charge types"}; - Configurable cfgFillChrgTypeV0s{"cfgFillChrgTypeV0s", false, "fill V0s histograms per charge types"}; - Configurable cfgCalibDeDxFunction{"cfgCalibDeDxFunction", "pol8", "Functional form for dEdx calibration"}; - Configurable> paramsFuncMIPposEtaP{"paramsFuncMIPposEtaP", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncMIPnegEtaP{"paramsFuncMIPnegEtaP", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncMIPallEtaP{"paramsFuncMIPallEtaP", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncMIPposEtaN{"paramsFuncMIPposEtaN", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncMIPnegEtaN{"paramsFuncMIPnegEtaN", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncMIPallEtaN{"paramsFuncMIPallEtaN", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncPlateaUposEtaP{"paramsFuncPlateaUposEtaP", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncPlateaUnegEtaP{"paramsFuncPlateaUnegEtaP", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncPlateaUallEtaP{"paramsFuncPlateaUallEtaP", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncPlateaUposEtaN{"paramsFuncPlateaUposEtaN", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncPlateaUnegEtaN{"paramsFuncPlateaUnegEtaN", std::vector{-1.f}, "function parameters"}; - Configurable> paramsFuncPlateaUallEtaN{"paramsFuncPlateaUallEtaN", std::vector{-1.f}, "function parameters"}; - Configurable cfgGainEqCcdbPath{"cfgGainEqCcdbPath", "Users/g/gbencedi/flattenicity/GainEq", "CCDB path for gain equalization constants"}; - Configurable cfgVtxEqCcdbPath{"cfgVtxEqCcdbPath", "Users/g/gbencedi/flattenicity/ZvtxEq", "CCDB path for z-vertex equalization constants"}; - Configurable cfgDeDxCalibCcdbPath{"cfgDeDxCalibCcdbPath", "Users/g/gbencedi/flattenicity/dEdxCalib", "CCDB path for dEdx calibration"}; - Configurable cfgStoreThnSparse{"cfgStoreThnSparse", true, "Store histograms as THnSparse"}; + struct : ConfigurableGroup { + Configurable multEst{"multEst", 1, "0: without multiplicity; 1: MultFT0M; 2: MultTPC"}; + Configurable applyCalibGainFromCCDB{"applyCalibGainFromCCDB", false, "equalize detector amplitudes"}; + Configurable applyCalibVtxFromCCDB{"applyCalibVtxFromCCDB", false, "equalize Amp vs vtx"}; + Configurable applyCalibDeDx{"applyCalibDeDx", false, "calibration of dedx signal"}; + Configurable applyCalibDeDxFromCCDB{"applyCalibDeDxFromCCDB", false, "use CCDB-based calibration of dedx signal"}; + Configurable applyDCAParam{"applyDCAParam", false, "use parametrization of DCAxy and DCAz"}; + Configurable applyDCAParamFromCCDB{"applyDCAParamFromCCDB", false, "use CCDB-based parametrization of DCAxy and DCAz"}; + Configurable fillTrackQaHist{"fillTrackQaHist", false, "fill track QA histograms"}; + Configurable fillNclVsPhiCutQaHist{"fillNclVsPhiCutQaHist", false, "fill TPC cluster vs geometrical cut QA histograms"}; + Configurable filldEdxCalibHist{"filldEdxCalibHist", false, "fill dEdx calibration histograms"}; + Configurable filldEdxQaHist{"filldEdxQaHist", false, "fill dEdx QA histograms"}; + Configurable fillDCAxyHist{"fillDCAxyHist", false, "fill nsigma QA histograms"}; + Configurable fillV0Hist{"fillV0Hist", false, "fill V0 histograms"}; + Configurable fillChrgType{"fillChrgType", false, "fill histograms per charge types"}; + Configurable fillChrgTypeV0s{"fillChrgTypeV0s", false, "fill V0s histograms per charge types"}; + Configurable calibDeDxFunction{"calibDeDxFunction", "pol8", "Functional form for dEdx calibration"}; + Configurable> paramsFuncMIPposEtaP{"paramsFuncMIPposEtaP", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncMIPnegEtaP{"paramsFuncMIPnegEtaP", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncMIPallEtaP{"paramsFuncMIPallEtaP", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncMIPposEtaN{"paramsFuncMIPposEtaN", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncMIPnegEtaN{"paramsFuncMIPnegEtaN", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncMIPallEtaN{"paramsFuncMIPallEtaN", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncPlateaUposEtaP{"paramsFuncPlateaUposEtaP", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncPlateaUnegEtaP{"paramsFuncPlateaUnegEtaP", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncPlateaUallEtaP{"paramsFuncPlateaUallEtaP", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncPlateaUposEtaN{"paramsFuncPlateaUposEtaN", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncPlateaUnegEtaN{"paramsFuncPlateaUnegEtaN", std::vector{-1.f}, "function parameters"}; + Configurable> paramsFuncPlateaUallEtaN{"paramsFuncPlateaUallEtaN", std::vector{-1.f}, "function parameters"}; + Configurable gainEqCcdbPath{"gainEqCcdbPath", "Users/g/gbencedi/flattenicity/GainEq", "CCDB path for gain equalization constants"}; + Configurable vtxEqCcdbPath{"vtxEqCcdbPath", "Users/g/gbencedi/flattenicity/ZvtxEq", "CCDB path for z-vertex equalization constants"}; + Configurable dEdxCalibCcdbPath{"dEdxCalibCcdbPath", "Users/g/gbencedi/flattenicity/dEdxCalib", "CCDB path for dEdx calibration"}; + Configurable dcaParamCcdbPath{"dcaParamCcdbPath", "Users/g/gbencedi/flattenicity/DCAParam", "CCDB path for DCAxy and DCAz parametrization"}; + Configurable storeThnSparse{"storeThnSparse", true, "Store histograms as THnSparse"}; + } defOpt; struct : ConfigurableGroup { - Configurable cfgCustomTVX{"cfgCustomTVX", false, "Ask for custom TVX instead of sel8"}; - Configurable cfgRemoveNoTimeFrameBorder{"cfgRemoveNoTimeFrameBorder", false, "Bunch crossing is far from Time Frame borders"}; - Configurable cfgRemoveITSROFrameBorder{"cfgRemoveITSROFrameBorder", false, "Bunch crossing is far from ITS RO Frame border"}; - Configurable cfgCutVtxZ{"cfgCutVtxZ", 10.0f, "Accepted z-vertex range"}; - Configurable useZVtxCutMC{"useZVtxCutMC", true, "use Zvtx cut in MC"}; + Configurable customTVX{"customTVX", false, "Ask for custom TVX instead of sel8"}; + Configurable removeNoTimeFrameBorder{"removeNoTimeFrameBorder", false, "Bunch crossing is far from Time Frame borders"}; + Configurable removeITSROFrameBorder{"removeITSROFrameBorder", false, "Bunch crossing is far from ITS RO Frame border"}; + Configurable cutVtxZ{"cutVtxZ", 10.0f, "Accepted z-vertex range"}; + Configurable zVtxCutMC{"zVtxCutMC", true, "use Zvtx cut in MC"}; Configurable useINELCutMC{"useINELCutMC", true, "use INEL>0 cut in MC"}; - Configurable cfgRemoveNoSameBunchPileup{"cfgRemoveNoSameBunchPileup", true, "Reject collisions in case of pileup with another collision in the same foundBC"}; - Configurable cfgRequireIsGoodZvtxFT0vsPV{"cfgRequireIsGoodZvtxFT0vsPV", true, "Small difference between z-vertex from PV and from FT0"}; - Configurable cfgRequireIsVertexITSTPC{"cfgRequireIsVertexITSTPC", false, "At least one ITS-TPC track (reject vertices built from ITS-only tracks)"}; - Configurable cfgRequirekIsVertexTOFmatched{"cfgRequirekIsVertexTOFmatched", false, "Require kIsVertexTOFmatched: at least one of vertex contributors is matched to TOF"}; + Configurable removeNoSameBunchPileup{"removeNoSameBunchPileup", true, "Reject collisions in case of pileup with another collision in the same foundBC"}; + Configurable requireIsGoodZvtxFT0vsPV{"requireIsGoodZvtxFT0vsPV", true, "Small difference between z-vertex from PV and from FT0"}; + Configurable requireIsVertexITSTPC{"requireIsVertexITSTPC", false, "At least one ITS-TPC track (reject vertices built from ITS-only tracks)"}; + Configurable requirekIsVertexTOFmatched{"requirekIsVertexTOFmatched", false, "Require kIsVertexTOFmatched: at least one of vertex contributors is matched to TOF"}; Configurable useMultMCmidrap{"useMultMCmidrap", true, "use generated Nch in ∣eta∣ < 0.8"}; - Configurable cfgUseInelgt0wTVX{"cfgUseInelgt0wTVX", true, "Use INEL > 0 condition with TVX trigger, i.e. FT0A and FT0C acceptance"}; - Configurable cfgRemoveSplitVertex{"cfgRemoveSplitVertex", true, "Remove split vertices"}; + Configurable useInelgt0wTVX{"useInelgt0wTVX", true, "Use INEL > 0 condition with TVX trigger, i.e. FT0A and FT0C acceptance"}; + Configurable removeSplitVertex{"removeSplitVertex", true, "Remove split vertices"}; } evtSelOpt; struct : ConfigurableGroup { @@ -310,89 +315,91 @@ struct FlattenictyPikp { } binOpt; struct : ConfigurableGroup { - Configurable cfgTrkEtaMax{"cfgTrkEtaMax", 0.8f, "Eta range for tracks"}; - Configurable cfgRapMax{"cfgRapMax", 0.5f, "Maximum range of rapidity for tracks"}; - Configurable cfgTrkPtMin{"cfgTrkPtMin", 0.1f, "Minimum pT of tracks"}; - Configurable cfgApplyNcl{"cfgApplyNcl", false, "Apply cut on TPC clusters"}; - Configurable cfgNclTPCMin{"cfgNclTPCMin", 135.0f, "Minimum of number of TPC found clusters"}; - Configurable cfgApplyNclPID{"cfgApplyNclPID", true, "Apply cut on TPC PID clusters"}; - Configurable cfgNclPidTPCMin{"cfgNclPidTPCMin", 135.0f, "Minimum of number of TPC PID clusters"}; - Configurable cfgPhiCutPtMin{"cfgPhiCutPtMin", 2.0f, "Minimum pT for phi cut"}; - Configurable cfgTOFBetaPion{"cfgTOFBetaPion", 1.0f, "Minimum beta for TOF pions"}; - Configurable cfgTofBetaPiMax{"cfgTofBetaPiMax", 5E-5, "Maximum beta for TOF pion selection"}; - Configurable cfgRejectTrkAtTPCSector{"cfgRejectTrkAtTPCSector", true, "Reject tracks close to the TPC sector boundaries"}; - Configurable cfgGeoTrkCutMin{"cfgGeoTrkCutMin", "0.06/x+pi/18.0-0.06", "ROOT TF1 formula for minimum phi cut in TPC"}; - Configurable cfgGeoTrkCutMax{"cfgGeoTrkCutMax", "0.1/x+pi/18.0+0.06", "ROOT TF1 formula for maximum phi cut in TPC"}; - Configurable cfgMomMIPMax{"cfgMomMIPMax", 0.6f, "Maximum momentum of MIP pions"}; - Configurable cfgMomMIPMin{"cfgMomMIPMin", 0.4f, "Minimum momentum of MIP pions"}; - Configurable cfgDeDxMIPMax{"cfgDeDxMIPMax", 60.0f, "Maximum range of MIP dedx"}; - Configurable cfgDeDxMIPMin{"cfgDeDxMIPMin", 40.0f, "Maximum range of MIP dedx"}; - Configurable cfgNsigmaMax{"cfgNsigmaMax", 100.0f, "Maximum range of nsgima for tracks"}; - Configurable cfgDcaNsigmaCombinedMax{"cfgDcaNsigmaCombinedMax", 3.0f, "Maximum range of combined nsgima of tracks for DCA"}; - Configurable cfgMomSelPiTOF{"cfgMomSelPiTOF", 0.4f, "Minimum momentum cut for TOF pions"}; - Configurable cfgNsigSelKaTOF{"cfgNsigSelKaTOF", 3.0f, "Nsigma cut for TOF kaons"}; - Configurable cfgBetaPlateuMax{"cfgBetaPlateuMax", 0.1f, "Beta max for Plateau electrons"}; - Configurable cfgApplyCustomDCASel{"cfgApplyCustomDCASel", false, "Apply custom DCA selection"}; - Configurable> cfgDcaXY{"cfgDcaXY", std::vector{0.1f, 0.0f, 0.0f}, "abs dcaXY selection: [0] + [1] * pT^[2]"}; - Configurable> cfgDcaZ{"cfgDcaZ", std::vector{0.1f, 0.0f, 0.0f}, "abs dcaZ selection: [0] + [1] * pT^[2]"}; + Configurable trkEtaMax{"trkEtaMax", 0.8f, "Eta range for tracks"}; + Configurable rapMax{"rapMax", 0.5f, "Maximum range of rapidity for tracks"}; + Configurable trkPtMin{"trkPtMin", 0.1f, "Minimum pT of tracks"}; + Configurable applyNcl{"applyNcl", false, "Apply cut on TPC clusters"}; + Configurable nclTPCMin{"nclTPCMin", 135.0f, "Minimum of number of TPC found clusters"}; + Configurable applyNclPID{"applyNclPID", true, "Apply cut on TPC PID clusters"}; + Configurable nclPidTPCMin{"nclPidTPCMin", 135.0f, "Minimum of number of TPC PID clusters"}; + Configurable phiCutPtMin{"phiCutPtMin", 2.0f, "Minimum pT for phi cut"}; + Configurable tofBetaPion{"tofBetaPion", 1.0f, "Minimum beta for TOF pions"}; + Configurable tofBetaPiMax{"tofBetaPiMax", 5E-5, "Maximum beta for TOF pion selection"}; + Configurable rejectTrkAtTPCSector{"rejectTrkAtTPCSector", true, "Reject tracks close to the TPC sector boundaries"}; + Configurable geoTrkCutMin{"geoTrkCutMin", "0.06/x+pi/18.0-0.06", "ROOT TF1 formula for minimum phi cut in TPC"}; + Configurable geoTrkCutMax{"geoTrkCutMax", "0.1/x+pi/18.0+0.06", "ROOT TF1 formula for maximum phi cut in TPC"}; + Configurable dEdxMIPnominal{"dEdxMIPnominal", 50.0f, "Nominal value of MIP pions"}; + Configurable momMIPMax{"momMIPMax", 0.6f, "Maximum momentum of MIP pions"}; + Configurable momMIPMin{"momMIPMin", 0.4f, "Minimum momentum of MIP pions"}; + Configurable dEdxMIPMax{"dEdxMIPMax", 60.0f, "Maximum range of MIP dedx"}; + Configurable dEdxMIPMin{"dEdxMIPMin", 40.0f, "Maximum range of MIP dedx"}; + Configurable nsigmaMax{"nsigmaMax", 100.0f, "Maximum range of nsgima for tracks"}; + Configurable dcaNsigmaCombinedMax{"dcaNsigmaCombinedMax", 3.0f, "Maximum range of combined nsgima of tracks for DCA"}; + Configurable momSelPiTOF{"momSelPiTOF", 0.4f, "Minimum momentum cut for TOF pions"}; + Configurable nsigmaSelKaTOF{"nsigmaSelKaTOF", 3.0f, "Nsigma cut for TOF kaons"}; + Configurable betaPlateuMax{"betaPlateuMax", 0.1f, "Beta max for Plateau electrons"}; + Configurable> dcaXY{"dcaXY", std::vector{0.1f, 0.0f, 0.0f}, "abs dcaXY selection: [0] + [1] * pT^[2]"}; + Configurable> dcaZ{"dcaZ", std::vector{0.1f, 0.0f, 0.0f}, "abs dcaZ selection: [0] + [1] * pT^[2]"}; + Configurable nsigmaDCAxy{"nsigmaDCAxy", 1.0f, "Nsigma cut on DCAxy"}; + Configurable nsigmaDCAz{"nsigmaDCAz", 1.0f, "Nsigma cut on DCAz"}; } trkSelOpt; struct : ConfigurableGroup { // common selection - Configurable cfgV0TypeSel{"cfgV0TypeSel", 1, "select on a certain V0 type (leave negative if no selection desired)"}; - Configurable cfgV0Ymax{"cfgV0Ymax", 0.5f, "Maximum rapidity of V0s"}; - Configurable cfgRejectV0sAtTPCSector{"cfgRejectV0sAtTPCSector", true, "Reject V0s close to the TPC sector boundaries"}; - Configurable cfgRequireITS{"cfgRequireITS", true, "Additional cut on the ITS requirement"}; - Configurable cfgNsigmaElTPC{"cfgNsigmaElTPC", 5.0, "max nsigma of TPC for electorn"}; - Configurable cfgNsigmaPiTPC{"cfgNsigmaPiTPC", 5.0, "max nsigma of TPC for pion"}; - Configurable cfgNsigmaPrTPC{"cfgNsigmaPrTPC", 5.0, "max nsigma of TPC for proton"}; - Configurable cfgNsigmaElTOF{"cfgNsigmaElTOF", 3.0, "max nsigma of TOF for electorn"}; - Configurable cfgNsigmaPiTOF{"cfgNsigmaPiTOF", 3.0, "max nsigma of TOF for pion"}; - Configurable cfgNsigmaPrTOF{"cfgNsigmaPrTOF", 3.0, "max nsigma of TOF for proton"}; + Configurable v0TypeSel{"v0TypeSel", 1, "select on a certain V0 type (leave negative if no selection desired)"}; + Configurable v0Ymax{"v0Ymax", 0.5f, "Maximum rapidity of V0s"}; + Configurable rejectV0sAtTPCSector{"rejectV0sAtTPCSector", true, "Reject V0s close to the TPC sector boundaries"}; + Configurable v0requireITS{"v0requireITS", true, "Additional cut on the ITS requirement"}; + Configurable nsigmaElTPC{"nsigmaElTPC", 5.0, "max nsigma of TPC for electorn"}; + Configurable nsigmaPiTPC{"nsigmaPiTPC", 5.0, "max nsigma of TPC for pion"}; + Configurable nsigmaPrTPC{"nsigmaPrTPC", 5.0, "max nsigma of TPC for proton"}; + Configurable nsigmaElTOF{"nsigmaElTOF", 3.0, "max nsigma of TOF for electorn"}; + Configurable nsigmaPiTOF{"nsigmaPiTOF", 3.0, "max nsigma of TOF for pion"}; + Configurable nsigmaPrTOF{"nsigmaPrTOF", 3.0, "max nsigma of TOF for proton"}; ConfigurableAxis axisArmPodAlpha{"axisArmPodAlpha", {200, -1.0, 1.0}, "Armenteros-Podolanski alpha"}; ConfigurableAxis axisArmPodqT{"axisArmPodqT", {600, 0.0f, 0.3f}, "Armenteros-Podolanski qT"}; // standad parameters for V0 selection - Configurable cfgV0etamin{"cfgV0etamin", -0.8f, "min eta of V0s"}; - Configurable cfgV0etamax{"cfgV0etamax", +0.8f, "max eta of V0s"}; - Configurable cfgminNCrossedRowsTPC{"cfgminNCrossedRowsTPC", 70, "Additional cut on the minimum number of crossed rows in the TPC"}; - Configurable cfgApplyV0sNclFound{"cfgApplyV0sNclFound", false, "Apply cut on TPC Found clusters"}; - Configurable cfgV0NclTPCMin{"cfgV0NclTPCMin", 135.0f, "Minimum of number of TPC found clusters"}; - Configurable cfgApplyV0sNclPID{"cfgApplyV0sNclPID", true, "Apply cut on TPC PID clusters"}; - Configurable cfgV0NclPidTPCMin{"cfgV0NclPidTPCMin", 135.0f, "Minimum of number of TPC PID clusters"}; - Configurable cfgmaxChi2PerClusterTPC{"cfgmaxChi2PerClusterTPC", 4.f, "Additional cut on the maximum value of the chi2 per cluster in the TPC"}; - Configurable cfgmaxChi2PerClusterITS{"cfgmaxChi2PerClusterITS", 36.f, "Additional cut on the maximum value of the chi2 per cluster in the ITS"}; - Configurable cfgminITSnClusters{"cfgminITSnClusters", 4, "minimum number of found ITS clusters"}; - Configurable cfgminNCrossedRowsOverFindableClustersTPC{"cfgminNCrossedRowsOverFindableClustersTPC", 0.8f, "Additional cut on the minimum value of the ratio between crossed rows and findable clusters in the TPC"}; - Configurable cfgDCAv0daughter{"cfgDCAv0daughter", 1.0, "max DCA of V0 daughter tracks (cm)"}; - Configurable cfgv0cospa{"cfgv0cospa", 0.995, "min V0 CosPA"}; - Configurable cfgDCAposToPV{"cfgDCAposToPV", 0.05f, "min DCA Pos To PV (cm)"}; - Configurable cfgDCAnegToPV{"cfgDCAnegToPV", 0.05f, "min DCA Neg To PV (cm)"}; - Configurable cfgv0Rmin{"cfgv0Rmin", 1.2, "min V0 radius (cm)"}; - Configurable cfgv0Rmax{"cfgv0Rmax", 1E5, "max V0 radius (cm)"}; + Configurable v0etamin{"v0etamin", -0.8f, "min eta of V0s"}; + Configurable v0etamax{"v0etamax", +0.8f, "max eta of V0s"}; + Configurable v0minNCrossedRowsTPC{"v0minNCrossedRowsTPC", 70, "Additional cut on the minimum number of crossed rows in the TPC"}; + Configurable applyV0sNclFound{"applyV0sNclFound", false, "Apply cut on TPC Found clusters"}; + Configurable v0NclTPCMin{"v0NclTPCMin", 135.0f, "Minimum of number of TPC found clusters"}; + Configurable applyV0sNclPID{"applyV0sNclPID", true, "Apply cut on TPC PID clusters"}; + Configurable v0NclPidTPCMin{"v0NclPidTPCMin", 135.0f, "Minimum of number of TPC PID clusters"}; + Configurable v0maxChi2PerClusterTPC{"v0maxChi2PerClusterTPC", 4.f, "Additional cut on the maximum value of the chi2 per cluster in the TPC"}; + Configurable v0maxChi2PerClusterITS{"v0maxChi2PerClusterITS", 36.f, "Additional cut on the maximum value of the chi2 per cluster in the ITS"}; + Configurable v0minITSnClusters{"v0minITSnClusters", 4, "minimum number of found ITS clusters"}; + Configurable v0minNCrossedRowsOverFindableClustersTPC{"v0minNCrossedRowsOverFindableClustersTPC", 0.8f, "Additional cut on the minimum value of the ratio between crossed rows and findable clusters in the TPC"}; + Configurable dcaV0daughter{"dcaV0daughter", 1.0, "max DCA of V0 daughter tracks (cm)"}; + Configurable v0cospa{"v0cospa", 0.995, "min V0 CosPA"}; + Configurable dcaPosToPV{"dcaPosToPV", 0.05f, "min DCA Pos To PV (cm)"}; + Configurable dcaNegToPV{"dcaNegToPV", 0.05f, "min DCA Neg To PV (cm)"}; + Configurable v0Rmin{"v0Rmin", 1.2, "min V0 radius (cm)"}; + Configurable v0Rmax{"v0Rmax", 1E5, "max V0 radius (cm)"}; // parameters for selection KOs - Configurable cfgcTauK0s{"cfgcTauK0s", 20, "v0ctau for K0s"}; - Configurable cfgCosPAK0s{"cfgCosPAK0s", 0.995, "V0 CosPA for K0s"}; - Configurable cfgV0radiusK0s{"cfgV0radiusK0s", 0.5, "v0radius for K0s"}; - Configurable cfgdmassK{"cfgdmassK", 0.01f, "Competing Mass Rejection cut for K0s"}; - Configurable cfgArmPodK0s{"cfgArmPodK0s", 5.0f, "pT * (cut) > |alpha|, Armenteros-Podolanski cut for K0s"}; + Configurable cTauK0s{"cTauK0s", 20, "v0ctau for K0s"}; + Configurable cosPAK0s{"cosPAK0s", 0.995, "V0 CosPA for K0s"}; + Configurable v0radiusK0s{"v0radiusK0s", 0.5, "v0radius for K0s"}; + Configurable dmassK{"dmassK", 0.01f, "Competing Mass Rejection cut for K0s"}; + Configurable armPodK0s{"armPodK0s", 5.0f, "pT * (cut) > |alpha|, Armenteros-Podolanski cut for K0s"}; ConfigurableAxis axisK0sMass{"axisK0sMass", {200, 0.4f, 0.6f}, "K0Short mass binning"}; // parameters for selection Lambda / antiLambda - Configurable cfgcTauLambda{"cfgcTauLambda", 30, "v0ctau for Lambda"}; - Configurable cfgCosPALambda{"cfgCosPALambda", 0.995, "V0 CosPA for Lambda"}; - Configurable cfgV0radiusLambda{"cfgV0radiusLambda", 0.5, "v0radius for Lambda"}; - Configurable cfgdmassL{"cfgdmassL", 0.01f, "Competing Mass Rejection cut for Lambda"}; + Configurable cTauLambda{"cTauLambda", 30, "v0ctau for Lambda"}; + Configurable cosPALambda{"cosPALambda", 0.995, "V0 CosPA for Lambda"}; + Configurable v0radiusLambda{"v0radiusLambda", 0.5, "v0radius for Lambda"}; + Configurable dmassL{"dmassL", 0.01f, "Competing Mass Rejection cut for Lambda"}; ConfigurableAxis axisLambdaMass{"axisLambdaMass", {200, 1.101f, 1.131f}, "Lambda mass binning"}; // parameters for selection Gamma - Configurable cfgdmassG{"cfgdmassG", 0.1f, "max mass for Gammas"}; - Configurable cfgArmPodGammasalpha{"cfgArmPodGammasalpha", 0.45f, "Armenteros-Podolanski alpha cut for Gammas"}; - Configurable cfgArmPodGammasqT{"cfgArmPodGammasqT", 0.01f, "Armenteros-Podolanski qT cut for Gammas"}; + Configurable dmassG{"dmassG", 0.1f, "max mass for Gammas"}; + Configurable armPodGammasalpha{"armPodGammasalpha", 0.45f, "Armenteros-Podolanski alpha cut for Gammas"}; + Configurable armPodGammasqT{"armPodGammasqT", 0.01f, "Armenteros-Podolanski qT cut for Gammas"}; ConfigurableAxis axisGammaMass{"axisGammaMass", {200, 0.0f, 0.5f}, "Gamma mass binning"}; - Configurable cfgdEdxPlateauSel{"cfgdEdxPlateauSel", 50, "dEdx selection sensitivity for electrons"}; + Configurable dEdxPlateauSel{"dEdxPlateauSel", 50, "dEdx selection sensitivity for electrons"}; } v0SelOpt; Service ccdb{}; struct : ConfigurableGroup { - Configurable cfgMagField{"cfgMagField", 99999, "Configurable magnetic field;default CCDB will be queried"}; + Configurable magField{"magField", 99999, "Configurable magnetic field;default CCDB will be queried"}; Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; Configurable grpmagPath{"grpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"}; Configurable grpPath{"grpPath", "GLO/GRP/GRP", "Path of the grp file"}; @@ -409,11 +416,18 @@ struct FlattenictyPikp { bool lCalibLoaded = false; } dedxcalib; + struct DCAParam { + TList* lCalibObjects = nullptr; + TH1F* hDCAxyParam = nullptr; + TH1F* hDCAzParam = nullptr; + bool lCalibLoaded = false; + } dcaparam; + struct : ConfigurableGroup { Configurable requireRCTFlagChecker{"requireRCTFlagChecker", false, "Check event quality in run condition table"}; - Configurable cfgEvtRCTFlagCheckerLabel{"cfgEvtRCTFlagCheckerLabel", "CBT_hadronPID", "Evt sel: RCT flag checker label"}; - Configurable cfgEvtRCTFlagCheckerZDCCheck{"cfgEvtRCTFlagCheckerZDCCheck", false, "Evt sel: RCT flag checker ZDC check"}; - Configurable cfgEvtRCTFlagCheckerLimitAcceptAsBad{"cfgEvtRCTFlagCheckerLimitAcceptAsBad", true, "Evt sel: RCT flag checker treat Limited Acceptance As Bad"}; + Configurable evtRCTFlagCheckerLabel{"evtRCTFlagCheckerLabel", "CBT_hadronPID", "Evt sel: RCT flag checker label"}; + Configurable evtRCTFlagCheckerZDCCheck{"evtRCTFlagCheckerZDCCheck", false, "Evt sel: RCT flag checker ZDC check"}; + Configurable evtRCTFlagCheckerLimitAcceptAsBad{"evtRCTFlagCheckerLimitAcceptAsBad", true, "Evt sel: RCT flag checker treat Limited Acceptance As Bad"}; } rctCuts; RCTFlagsChecker rctChecker; @@ -480,19 +494,19 @@ struct FlattenictyPikp { void init(InitContext&) { - auto vecParamsMIPposEtaP = (std::vector)paramsFuncMIPposEtaP; - auto vecParamsMIPposEtaN = (std::vector)paramsFuncMIPposEtaN; - auto vecParamsMIPnegEtaP = (std::vector)paramsFuncMIPnegEtaP; - auto vecParamsMIPnegEtaN = (std::vector)paramsFuncMIPnegEtaN; - auto vecParamsMIPallEtaP = (std::vector)paramsFuncMIPallEtaP; - auto vecParamsMIPallEtaN = (std::vector)paramsFuncMIPallEtaN; - - auto vecParamsPLAposEtaP = (std::vector)paramsFuncPlateaUposEtaP; - auto vecParamsPLAposEtaN = (std::vector)paramsFuncPlateaUposEtaN; - auto vecParamsPLAnegEtaP = (std::vector)paramsFuncPlateaUnegEtaP; - auto vecParamsPLAnegEtaN = (std::vector)paramsFuncPlateaUnegEtaN; - auto vecParamsPLAallEtaP = (std::vector)paramsFuncPlateaUallEtaP; - auto vecParamsPLAallEtaN = (std::vector)paramsFuncPlateaUallEtaN; + auto vecParamsMIPposEtaP = (std::vector)defOpt.paramsFuncMIPposEtaP; + auto vecParamsMIPposEtaN = (std::vector)defOpt.paramsFuncMIPposEtaN; + auto vecParamsMIPnegEtaP = (std::vector)defOpt.paramsFuncMIPnegEtaP; + auto vecParamsMIPnegEtaN = (std::vector)defOpt.paramsFuncMIPnegEtaN; + auto vecParamsMIPallEtaP = (std::vector)defOpt.paramsFuncMIPallEtaP; + auto vecParamsMIPallEtaN = (std::vector)defOpt.paramsFuncMIPallEtaN; + + auto vecParamsPLAposEtaP = (std::vector)defOpt.paramsFuncPlateaUposEtaP; + auto vecParamsPLAposEtaN = (std::vector)defOpt.paramsFuncPlateaUposEtaN; + auto vecParamsPLAnegEtaP = (std::vector)defOpt.paramsFuncPlateaUnegEtaP; + auto vecParamsPLAnegEtaN = (std::vector)defOpt.paramsFuncPlateaUnegEtaN; + auto vecParamsPLAallEtaP = (std::vector)defOpt.paramsFuncPlateaUallEtaP; + auto vecParamsPLAallEtaN = (std::vector)defOpt.paramsFuncPlateaUallEtaN; auto addVec = [&](std::vector>& targetVec, const std::string& name, bool isMIP) { if (isMIP) { @@ -529,7 +543,7 @@ struct FlattenictyPikp { ccdb->setCreatedNotAfter(std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count()); ccdb->setFatalWhenNull(false); - rctChecker.init(rctCuts.cfgEvtRCTFlagCheckerLabel, rctCuts.cfgEvtRCTFlagCheckerZDCCheck, rctCuts.cfgEvtRCTFlagCheckerLimitAcceptAsBad); + rctChecker.init(rctCuts.evtRCTFlagCheckerLabel, rctCuts.evtRCTFlagCheckerZDCCheck, rctCuts.evtRCTFlagCheckerLimitAcceptAsBad); if (isCustomTracks.value) { selTrkGlobal = getGlobalTrackSelectionRun3ITSMatch(setITSreq.value); @@ -577,7 +591,7 @@ struct FlattenictyPikp { AxisSpec multAxis{binOpt.axisMultPerc, "multiplicity estimator"}; - switch (multEst) { + switch (defOpt.multEst) { case MultE::CnoMult: break; case MultE::CmultFT0M: @@ -587,12 +601,12 @@ struct FlattenictyPikp { multAxis.name = "multTPC"; break; default: - LOG(fatal) << "No valid option for mult estimator " << multEst; + LOG(fatal) << "No valid option for mult estimator " << defOpt.multEst; } - if (trkSelOpt.cfgRejectTrkAtTPCSector || v0SelOpt.cfgRejectV0sAtTPCSector) { - fPhiCutLow = new TF1("fPhiCutLow", trkSelOpt.cfgGeoTrkCutMin.value.c_str(), 0, 100); - fPhiCutHigh = new TF1("fPhiCutHigh", trkSelOpt.cfgGeoTrkCutMax.value.c_str(), 0, 100); + if (trkSelOpt.rejectTrkAtTPCSector || v0SelOpt.rejectV0sAtTPCSector) { + fPhiCutLow = new TF1("fPhiCutLow", trkSelOpt.geoTrkCutMin.value.c_str(), 0, 100); + fPhiCutHigh = new TF1("fPhiCutHigh", trkSelOpt.geoTrkCutMax.value.c_str(), 0, 100); } registryQC.add("Events/hVtxZ", "Measured vertex z position", kTH1F, {vtxzAxis}); @@ -632,11 +646,11 @@ struct FlattenictyPikp { registryData.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(trkSelEta + 1, "Eta"); registryData.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(trkSelPt + 1, "Pt"); registryData.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(trkSelDCA + 1, "DCA"); + registryData.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(trkSelCustomDCA + 1, "Custom DCA sel."); registryData.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(trkNRowsTPC + 1, "trkNRowsTPC"); registryData.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(trkSelNClsFound + 1, "NClsTPCFound"); registryData.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(trkSelNClsPID + 1, "NClsTPCPid"); registryData.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(trkSelTPCBndr + 1, "TPC Boundary"); - registryData.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(trkSelCustomDCA + 1, "Custom DCA sel."); // V0 counter registryData.add("Tracks/V0qa/hV0Sel", "Number of V0s; Cut; #Tracks Passed Cut", {kTH1F, {{nV0Sel, 0, nV0Sel}}}); registryData.get(HIST("Tracks/V0qa/hV0Sel"))->GetXaxis()->SetBinLabel(v0SelAll + 1, "All"); @@ -650,8 +664,8 @@ struct FlattenictyPikp { registryData.add("Events/hFlatVsMultEst", "hFlatVsMultEst", kTH2F, {flatAxis, multAxis}); registryData.add("Tracks/postSel/hPVsPtEta", "; #it{p} (GeV/#it{c}); #it{p}_{T} (GeV/#it{c}); #eta;", {kTH3F, {pAxis, ptAxis, etaAxis}}); - if (cfgFillNclVsPhiCutQaHist || cfgFillTrackQaHist || cfgFilldEdxQaHist || cfgFillDCAxyHist) { - if (cfgFillNclVsPhiCutQaHist) { + if (defOpt.fillNclVsPhiCutQaHist || defOpt.fillTrackQaHist || defOpt.filldEdxQaHist || defOpt.fillDCAxyHist) { + if (defOpt.fillNclVsPhiCutQaHist) { registryData.add("Tracks/postSel/hPtPhi", "; #it{p}_{T} (GeV/#it{c}); fmod(#varphi,#pi/9)", {kTH2F, {ptAxis, phiAxisMod}}); registryData.add("Tracks/postSel/hPtPhiNclTPC", "; #{eta}; #it{p}_{T} (GeV/#it{c}); fmod(#varphi,#pi/9); N_{cluster}", {kTHnSparseF, {etaAxis, ptAxis, phiAxisMod, clTpcAxis}}); registryData.add("Tracks/postSel/hPtPhiNclPIDTPC", "; #{eta}; #it{p}_{T} (GeV/#it{c}); fmod(#varphi,#pi/9); N_{PID cluster}", {kTHnSparseF, {etaAxis, ptAxis, phiAxisMod, clTpcAxis}}); @@ -660,7 +674,7 @@ struct FlattenictyPikp { registryData.add("Tracks/postSel/hPtNclPIDTPC", "; #it{p}_{T} (GeV/#it{c}); N_{PID cluster}", {kTH2F, {ptAxis, clTpcAxis}}); registryData.add("Tracks/postSel/pPtNclPIDTPC", "; #it{p}_{T} (GeV/#it{c}); N_{PID cluster}", {kTProfile, {ptAxis}}); } - if (cfgFillTrackQaHist) { + if (defOpt.fillTrackQaHist) { registryData.add("Tracks/postSel/hShTpcClvsPt", "", {kTH2F, {ptAxis, shCluserAxis}}); registryData.add("Tracks/postSel/hNclTPCFoundvsPt", "", {kTH2F, {ptAxis, clTpcAxis}}); registryData.add("Tracks/postSel/hNClTPCPidvsPt", "", {kTH2F, {ptAxis, clTpcAxis}}); @@ -685,8 +699,8 @@ struct FlattenictyPikp { registryData.add("Tracks/postSel/hTOFPvsBeta", "Beta from TOF; #it{p} (GeV/#it{c}); #beta", {kTH2F, {pAxis, {120, 0.0, 1.2}}}); registryData.add("Tracks/postSel/hTOFpi", "Primary Pions from TOF; #eta; #it{p} (GeV/#it{c}); dEdx", {kTHnSparseF, {etaAxis, pAxis, dEdxAxis}}); } - if (cfgFilldEdxQaHist) { - if (cfgStoreThnSparse) { + if (defOpt.filldEdxQaHist) { + if (defOpt.storeThnSparse) { registryData.add("Tracks/postCalib/all/hMIP", "; mult; flat; #eta; #LT dE/dx #GT_{MIP, primary tracks};", {kTHnSparseF, {multAxis, flatAxis, etaAxis, dEdxAxis}}); registryData.add("Tracks/postCalib/all/hPlateau", "; mult; flat; #eta; #LT dE/dx #GT_{Plateau, primary tracks};", {kTHnSparseF, {multAxis, flatAxis, etaAxis, dEdxAxis}}); } else { @@ -702,14 +716,14 @@ struct FlattenictyPikp { registryData.add("Tracks/postCalib/all/hPlateauVsPhiVsEta", "; #varphi; #LT dE/dx #GT_{Plateau, primary tracks}; #eta;", {kTH3F, {phiAxis, dEdxAxis, etaAxis}}); registryData.add("Tracks/postCalib/all/hPlateauNClTPCPidvsEta", ";#eta; Ncl pid", {kTH2F, {etaAxis, clTpcAxis}}); registryData.addClone("Tracks/postCalib/all/", "Tracks/preCalib/all/"); - if (cfgFillChrgType) { + if (defOpt.fillChrgType) { registryData.addClone("Tracks/postCalib/all/", "Tracks/postCalib/pos/"); registryData.addClone("Tracks/postCalib/all/", "Tracks/postCalib/neg/"); registryData.addClone("Tracks/preCalib/all/", "Tracks/preCalib/pos/"); registryData.addClone("Tracks/preCalib/all/", "Tracks/preCalib/neg/"); } } - if (cfgFillDCAxyHist) { + if (defOpt.fillDCAxyHist) { for (int i = 0; i < Npart; i++) { registryData.add({fmt::format(CpTvsDCAxyF.data(), CspeciesAll[i].data()).c_str(), "; mult; flat; #it{p} (GeV/#it{c}); DCA_{xy} (cm)", {kTHnSparseF, {multAxis, flatAxis, ptAxis, dcaXYAxis}}}); } @@ -738,8 +752,8 @@ struct FlattenictyPikp { // dEdx PID registryData.add({"Tracks/all/hdEdx", "; #eta; mult; flat; #it{p} (GeV/#it{c}); dEdx", {kTHnSparseF, {etaAxis, multAxis, flatAxis, pAxis, dEdxAxis}}}); // Clean samples - if (cfgFillV0Hist) { - if (cfgStoreThnSparse) { + if (defOpt.fillV0Hist) { + if (defOpt.storeThnSparse) { registryData.add({"Tracks/CleanTof/all/hPiTof", "; #eta; mult; flat; #it{p} (GeV/#it{c}); dEdx", {kTHnSparseF, {etaAxis, multAxis, flatAxis, pAxis, dEdxAxis}}}); registryData.add({"Tracks/CleanV0/all/hEV0", "; #eta; mult; flat; #it{p} (GeV/#it{c}); dEdx", {kTHnSparseF, {etaAxis, multAxis, flatAxis, pAxis, dEdxAxis}}}); registryData.add({"Tracks/CleanV0/all/hPiV0", "; #eta; mult; flat; #it{p} (GeV/#it{c}); dEdx", {kTHnSparseF, {etaAxis, multAxis, flatAxis, pAxis, dEdxAxis}}}); @@ -752,14 +766,14 @@ struct FlattenictyPikp { } registryData.add("Tracks/CleanTof/all/hBetaVsP", ";Momentum (GeV/#it{c}); #beta", kTH2F, {{{ptAxisV0s}, {120, 0., 1.2}}}); registryData.add("Tracks/CleanTof/all/hTofExpPi", ";Momentum (GeV/#it{c});#it{t}^{#pi}_{Exp}/#it{t}_{TOF}", kTH2F, {{{ptAxisV0s}, {100, 0.2, 1.2}}}); - if (cfgFillChrgType) { + if (defOpt.fillChrgType) { registryData.addClone("Tracks/CleanTof/all/", "Tracks/CleanTof/pos/"); registryData.addClone("Tracks/CleanTof/all/", "Tracks/CleanTof/neg/"); registryData.addClone("Tracks/CleanV0/all/", "Tracks/CleanV0/pos/"); registryData.addClone("Tracks/CleanV0/all/", "Tracks/CleanV0/neg/"); } } - if (cfgFillChrgType) { + if (defOpt.fillChrgType) { registryData.addClone("Tracks/all/", "Tracks/pos/"); registryData.addClone("Tracks/all/", "Tracks/neg/"); } @@ -799,7 +813,7 @@ struct FlattenictyPikp { registryMC.add({fmt::format(CpTmcClosureGenPrimF.data(), CspeciesAll[i].data()).c_str(), "Gen evt w/o Evt sel; Gen Nch (|#eta|<0.8); flat; #it{p}_{T} (GeV/#it{c})", {kTHnSparseF, {nChAxis, flatAxis, ptAxis}}}); registryMC.add({fmt::format(CpTmcClosureRecF.data(), CspeciesAll[i].data()).c_str(), "Gen Nch w/ Nrec > 0 + Evt. sel; Gen Nch (|#eta|<0.8); flat; #it{p}_{T} (GeV/#it{c})", {kTHnSparseF, {nChAxis, flatAxis, ptAxis}}}); } - if (cfgFillNclVsPhiCutQaHist) { + if (defOpt.fillNclVsPhiCutQaHist) { registryMC.add("Tracks/postSel/hPtPhi", "; #it{p}_{T} (GeV/#it{c}); fmod(#varphi,#pi/9)", {kTH2F, {ptAxis, phiAxisMod}}); registryMC.add("Tracks/postSel/hPtPhiNclTPC", "; #eta; #it{p}_{T} (GeV/#it{c}); fmod(#varphi,#pi/9); N_{cluster}", {kTHnSparseF, {etaAxis, ptAxis, phiAxisMod, clTpcAxis}}); registryMC.add("Tracks/postSel/hPtPhiNclPIDTPC", "; #eta; #it{p}_{T} (GeV/#it{c}); fmod(#varphi,#pi/9); N_{PID cluster}", {kTHnSparseF, {etaAxis, ptAxis, phiAxisMod, clTpcAxis}}); @@ -867,7 +881,7 @@ struct FlattenictyPikp { fv0AmplCorr = {}; auto runnumber = bc.runNumber(); - if (trkSelOpt.cfgRejectTrkAtTPCSector || v0SelOpt.cfgRejectV0sAtTPCSector) { + if (trkSelOpt.rejectTrkAtTPCSector || v0SelOpt.rejectV0sAtTPCSector) { grpmag = ccdb->getForRun(ccdbConf.grpmagPath, runnumber); if (!grpmag) { LOG(fatal) << "Got nullptr from CCDB for path " << ccdbConf.grpmagPath << " of object GRPMagField and " << ccdbConf.grpPath << " of object GRPObject for run " << runnumber; @@ -875,8 +889,8 @@ struct FlattenictyPikp { magField = std::lround(5.f * grpmag->getL3Current() / 30000.f); LOG(info) << "Retrieved GRP for run " << runnumber << " with magnetic field of " << magField << " kZG"; } - if (applyCalibGain) { - std::string fullPathCalibGain = cfgGainEqCcdbPath; + if (defOpt.applyCalibGainFromCCDB) { + std::string fullPathCalibGain = defOpt.gainEqCcdbPath; fullPathCalibGain += "/FV0"; const auto* objfv0Gain = ccdb->getForRun>(fullPathCalibGain, runnumber); if (!objfv0Gain) { @@ -888,18 +902,17 @@ struct FlattenictyPikp { fv0AmplCorr = *(objfv0Gain); } } - if (applyCalibVtx) { - std::string fullPathCalibVtx = cfgVtxEqCcdbPath; + if (defOpt.applyCalibVtxFromCCDB) { + std::string fullPathCalibVtx = defOpt.vtxEqCcdbPath; fullPathCalibVtx += "/FV0"; zVtxMap = ccdb->getForRun(fullPathCalibVtx, runnumber); } - - if (applyCalibDeDxFromCCDB) { - std::string fullPathCalibDeDxMip = cfgDeDxCalibCcdbPath; + if (defOpt.applyCalibDeDxFromCCDB) { + std::string fullPathCalibDeDxMip = defOpt.dEdxCalibCcdbPath; if (!fullPathCalibDeDxMip.empty()) { fullPathCalibDeDxMip += "/MIP"; } - std::string fullPathCalibDeDxPlateau = cfgDeDxCalibCcdbPath; + std::string fullPathCalibDeDxPlateau = defOpt.dEdxCalibCcdbPath; if (!fullPathCalibDeDxPlateau.empty()) { fullPathCalibDeDxPlateau += "/Plateau"; } @@ -933,13 +946,29 @@ struct FlattenictyPikp { LOGF(fatal, "Could not load hPlateauCalib from %s", fullPathCalibDeDxPlateau.c_str()); } } + if (defOpt.applyDCAParamFromCCDB) { + dcaparam.lCalibObjects = ccdb->getForRun(defOpt.dcaParamCcdbPath, runnumber); + if (dcaparam.lCalibObjects) { + LOG(info) << "CCDB objects loaded successfully"; + dcaparam.hDCAxyParam = dynamic_cast(dcaparam.lCalibObjects->FindObject("hfitDCAxyParams")); + dcaparam.hDCAzParam = dynamic_cast(dcaparam.lCalibObjects->FindObject("hfitDCAzParams")); + dcaparam.lCalibLoaded = true; + if (!dcaparam.hDCAxyParam || !dcaparam.hDCAzParam) { + LOGF(error, "Problem loading CCDB objects! Please check"); + dcaparam.lCalibLoaded = false; + } + } else { + LOGF(fatal, "Could not load DCAParam from %s", defOpt.dcaParamCcdbPath.value.c_str()); + dcaparam.lCalibLoaded = false; + } + } } template std::unique_ptr setFuncPars(T const& vecPars) { static_assert(!std::is_pointer::value, "Pointers to pointers not allowed here"); - std::unique_ptr fCalibDeDxFunc(new TF1("fCalibDeDxFunc", cfgCalibDeDxFunction.value.c_str(), -1., 1.)); + std::unique_ptr fCalibDeDxFunc(new TF1("fCalibDeDxFunc", defOpt.calibDeDxFunction.value.c_str(), -1., 1.)); if (vecPars.size() >= 1) { for (typename T::size_type i = 0; i < vecPars.size(); i++) { fCalibDeDxFunc->SetParameter(i, vecPars[i]); @@ -964,11 +993,11 @@ struct FlattenictyPikp { const float tTOF = track.tofSignal(); const float trkLength = track.length(); const float tExpPiTOF = track.tofExpSignalPi(tTOF); - if (track.p() >= trkSelOpt.cfgMomSelPiTOF && trkLength > Cnull && tTOF > Cnull) { + if (track.p() >= trkSelOpt.momSelPiTOF && trkLength > Cnull && tTOF > Cnull) { registryData.fill(HIST(CprefixCleanTof) + HIST(Ccharge[chrg]) + HIST("hTofExpPi"), track.p(), tExpPiTOF / tTOF); - if (std::abs((tExpPiTOF / tTOF) - Cone) < trkSelOpt.cfgTofBetaPiMax) { + if (std::abs((tExpPiTOF / tTOF) - Cone) < trkSelOpt.tofBetaPiMax) { registryData.fill(HIST(CprefixCleanTof) + HIST(Ccharge[chrg]) + HIST("hBetaVsP"), track.p(), track.beta()); - // if (std::abs(track.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC && std::abs(track.tofNSigmaPi()) < v0SelOpt.cfgNsigmaPiTOF) { + // if (std::abs(track.tpcNSigmaPi()) < v0SelOpt.nsigmaPiTPC && std::abs(track.tofNSigmaPi()) < v0SelOpt.nsigmaPiTOF) { return true; // } } @@ -980,7 +1009,7 @@ struct FlattenictyPikp { template void fillDCA(T const& tracks, C const& collision, aod::BCsWithTimestamps const& /*bcs*/) { - if (trkSelOpt.cfgRejectTrkAtTPCSector) { + if (trkSelOpt.rejectTrkAtTPCSector) { auto bc = collision.template bc_as(); int currentRun = bc.runNumber(); if (runNumber != currentRun) { @@ -991,27 +1020,10 @@ struct FlattenictyPikp { const float mult = getMult(collision); const float flat = fillFlat(collision); for (const auto& track : tracks) { - if (std::abs(track.eta()) > trkSelOpt.cfgTrkEtaMax) { - continue; - } - if (track.pt() < trkSelOpt.cfgTrkPtMin) { - continue; - } - if (trkSelOpt.cfgApplyNcl && track.tpcNClsFound() < trkSelOpt.cfgNclTPCMin) { - continue; - } - if (trkSelOpt.cfgApplyNclPID && track.tpcNClsPID() < trkSelOpt.cfgNclPidTPCMin) { + if (!isGoodTrack(track, magField)) { continue; } - float phiModn = track.phi(); - phiMod(phiModn, magField, track.sign()); - if (trkSelOpt.cfgRejectTrkAtTPCSector && (track.pt() >= trkSelOpt.cfgPhiCutPtMin && phiModn < fPhiCutHigh->Eval(track.pt()) && phiModn > fPhiCutLow->Eval(track.pt()))) { - continue; - } - if (!isDCAxyWoCut(track)) { - continue; - } - if (track.hasTOF() && (std::sqrt(std::pow(std::fabs(o2::aod::pidutils::tpcNSigma(track)), 2) + std::pow(std::fabs(o2::aod::pidutils::tofNSigma(track)), 2) < trkSelOpt.cfgDcaNsigmaCombinedMax))) { + if (track.hasTOF() && (std::sqrt(std::pow(std::fabs(o2::aod::pidutils::tpcNSigma(track)), 2) + std::pow(std::fabs(o2::aod::pidutils::tofNSigma(track)), 2) < trkSelOpt.dcaNsigmaCombinedMax))) { registryData.fill(HIST(Cprefix) + HIST(CspeciesAll[id]) + HIST(CpTvsDCAxy), mult, flat, track.pt(), track.dcaXY()); } } @@ -1020,7 +1032,7 @@ struct FlattenictyPikp { template void filldEdx(T const& tracks, V const& v0s, C const& collision, aod::BCsWithTimestamps const& bcs) { - if (trkSelOpt.cfgRejectTrkAtTPCSector || v0SelOpt.cfgRejectV0sAtTPCSector || applyCalibGain || applyCalibVtx) { + if (trkSelOpt.rejectTrkAtTPCSector || v0SelOpt.rejectV0sAtTPCSector || defOpt.applyCalibGainFromCCDB || defOpt.applyCalibVtxFromCCDB) { auto bc = collision.template bc_as(); int currentRun = bc.runNumber(); if (runNumber != currentRun) { @@ -1037,17 +1049,17 @@ struct FlattenictyPikp { for (const auto& track : tracks) { float dEdx = track.tpcSignal(); - if (cfgFillTrackQaHist) { + if (defOpt.fillTrackQaHist) { fillTrackQA(track); } - if (!isGoodTrack(track, magField)) { + if (!isGoodTrack(track, magField)) { continue; } - if (cfgFillTrackQaHist) { + if (defOpt.fillTrackQaHist) { fillTrackQA(track); } - if (cfgFilldEdxCalibHist && cfgFilldEdxQaHist) { - if (cfgFillChrgType) { + if (defOpt.filldEdxCalibHist && defOpt.filldEdxQaHist) { + if (defOpt.fillChrgType) { if (track.sign() * track.p() > Cnull) { filldEdxQA(track, collision, dEdx); } else { @@ -1057,41 +1069,41 @@ struct FlattenictyPikp { filldEdxQA(track, collision, dEdx); } } - if (applyCalibDeDx) { - if (cfgFillChrgType) { + if (defOpt.applyCalibDeDx) { + if (defOpt.fillChrgType) { if (track.sign() * track.p() > Cnull) { - if (applyCalibDeDxFromCCDB) { - dEdx *= (50.0 / dedxcalib.hMIPcalibPos->GetBinContent(dedxcalib.hMIPcalibPos->FindBin(track.eta()))); + if (defOpt.applyCalibDeDxFromCCDB && dedxcalib.lCalibLoaded) { + dEdx *= (trkSelOpt.dEdxMIPnominal / dedxcalib.hMIPcalibPos->GetBinContent(dedxcalib.hMIPcalibPos->FindBin(track.eta()))); } else { - dEdx *= (50.0 / getCalibration(fDeDxVsEta, track)); + dEdx *= (trkSelOpt.dEdxMIPnominal / getCalibration(fDeDxVsEta, track)); } - if (cfgFilldEdxQaHist) { + if (defOpt.filldEdxQaHist) { filldEdxQA(track, collision, dEdx); } } else { - if (applyCalibDeDxFromCCDB) { - dEdx *= (50.0 / dedxcalib.hMIPcalibNeg->GetBinContent(dedxcalib.hMIPcalibNeg->FindBin(track.eta()))); + if (defOpt.applyCalibDeDxFromCCDB && dedxcalib.lCalibLoaded) { + dEdx *= (trkSelOpt.dEdxMIPnominal / dedxcalib.hMIPcalibNeg->GetBinContent(dedxcalib.hMIPcalibNeg->FindBin(track.eta()))); } else { - dEdx *= (50.0 / getCalibration(fDeDxVsEta, track)); + dEdx *= (trkSelOpt.dEdxMIPnominal / getCalibration(fDeDxVsEta, track)); } - if (cfgFilldEdxQaHist) { + if (defOpt.filldEdxQaHist) { filldEdxQA(track, collision, dEdx); } } } else { - if (applyCalibDeDxFromCCDB) { - dEdx *= (50.0 / dedxcalib.hMIPcalibAll->GetBinContent(dedxcalib.hMIPcalibAll->FindBin(track.eta()))); + if (defOpt.applyCalibDeDxFromCCDB && dedxcalib.lCalibLoaded) { + dEdx *= (trkSelOpt.dEdxMIPnominal / dedxcalib.hMIPcalibAll->GetBinContent(dedxcalib.hMIPcalibAll->FindBin(track.eta()))); } else { - dEdx *= (50.0 / getCalibration(fDeDxVsEta, track)); + dEdx *= (trkSelOpt.dEdxMIPnominal / getCalibration(fDeDxVsEta, track)); } - if (cfgFilldEdxQaHist) { + if (defOpt.filldEdxQaHist) { filldEdxQA(track, collision, dEdx); } } } // PID TPC dEdx - if (cfgFillChrgType) { + if (defOpt.fillChrgType) { if (track.sign() * track.p() > Cnull) { registryData.fill(HIST(Cprefix) + HIST(Ccharge[kPos]) + HIST("hFlatVsPt"), track.eta(), mult, flat, track.p(), track.pt()); registryData.fill(HIST(Cprefix) + HIST(Ccharge[kPos]) + HIST("hdEdx"), track.eta(), mult, flat, track.p(), dEdx); @@ -1105,24 +1117,24 @@ struct FlattenictyPikp { } // TOF pions - if (cfgFillV0Hist) { + if (defOpt.fillV0Hist) { if (selTOFPi(track)) { - if (cfgFillChrgType) { + if (defOpt.fillChrgType) { if (track.sign() * track.p() > Cnull) { - if (cfgStoreThnSparse) { + if (defOpt.storeThnSparse) { registryData.fill(HIST(CprefixCleanTof) + HIST(Ccharge[kPos]) + HIST("hPiTof"), track.eta(), mult, flat, track.p(), dEdx); } else { registryData.fill(HIST(CprefixCleanTof) + HIST(Ccharge[kPos]) + HIST("hPiTof"), track.eta(), track.p(), dEdx); } } else { - if (cfgStoreThnSparse) { + if (defOpt.storeThnSparse) { registryData.fill(HIST(CprefixCleanTof) + HIST(Ccharge[kNeg]) + HIST("hPiTof"), track.eta(), mult, flat, track.p(), dEdx); } else { registryData.fill(HIST(CprefixCleanTof) + HIST(Ccharge[kNeg]) + HIST("hPiTof"), track.eta(), track.p(), dEdx); } } } else { - if (cfgStoreThnSparse) { + if (defOpt.storeThnSparse) { registryData.fill(HIST(CprefixCleanTof) + HIST(Ccharge[kAll]) + HIST("hPiTof"), track.eta(), mult, flat, track.p(), dEdx); } else { registryData.fill(HIST(CprefixCleanTof) + HIST(Ccharge[kAll]) + HIST("hPiTof"), track.eta(), track.p(), dEdx); @@ -1133,9 +1145,9 @@ struct FlattenictyPikp { } // V0s - if (cfgFillV0Hist) { + if (defOpt.fillV0Hist) { for (const auto& v0 : v0s) { - if (v0.v0Type() != v0SelOpt.cfgV0TypeSel && v0SelOpt.cfgV0TypeSel > -1) { + if (v0.v0Type() != v0SelOpt.v0TypeSel && v0SelOpt.v0TypeSel > -1) { continue; } if (!isGoodV0Track(v0, tracks, magField)) { @@ -1147,22 +1159,22 @@ struct FlattenictyPikp { float dEdxPos = posTrack.tpcSignal(); float dEdxNeg = negTrack.tpcSignal(); - if (applyCalibDeDx) { - if (cfgFillChrgTypeV0s) { - if (applyCalibDeDxFromCCDB) { - dEdxPos *= (50.0 / dedxcalib.hMIPcalibPos->GetBinContent(dedxcalib.hMIPcalibPos->FindBin(posTrack.eta()))); - dEdxNeg *= (50.0 / dedxcalib.hMIPcalibNeg->GetBinContent(dedxcalib.hMIPcalibNeg->FindBin(negTrack.eta()))); + if (defOpt.applyCalibDeDx) { + if (defOpt.fillChrgTypeV0s) { + if (defOpt.applyCalibDeDxFromCCDB && dedxcalib.lCalibLoaded) { + dEdxPos *= (trkSelOpt.dEdxMIPnominal / dedxcalib.hMIPcalibPos->GetBinContent(dedxcalib.hMIPcalibPos->FindBin(posTrack.eta()))); + dEdxNeg *= (trkSelOpt.dEdxMIPnominal / dedxcalib.hMIPcalibNeg->GetBinContent(dedxcalib.hMIPcalibNeg->FindBin(negTrack.eta()))); } else { - dEdxPos *= (50.0 / getCalibration(fDeDxVsEta, posTrack)); - dEdxNeg *= (50.0 / getCalibration(fDeDxVsEta, negTrack)); + dEdxPos *= (trkSelOpt.dEdxMIPnominal / getCalibration(fDeDxVsEta, posTrack)); + dEdxNeg *= (trkSelOpt.dEdxMIPnominal / getCalibration(fDeDxVsEta, negTrack)); } } else { - if (applyCalibDeDxFromCCDB) { - dEdxPos *= (50.0 / dedxcalib.hMIPcalibAll->GetBinContent(dedxcalib.hMIPcalibAll->FindBin(posTrack.eta()))); - dEdxNeg *= (50.0 / dedxcalib.hMIPcalibAll->GetBinContent(dedxcalib.hMIPcalibAll->FindBin(negTrack.eta()))); + if (defOpt.applyCalibDeDxFromCCDB && dedxcalib.lCalibLoaded) { + dEdxPos *= (trkSelOpt.dEdxMIPnominal / dedxcalib.hMIPcalibAll->GetBinContent(dedxcalib.hMIPcalibAll->FindBin(posTrack.eta()))); + dEdxNeg *= (trkSelOpt.dEdxMIPnominal / dedxcalib.hMIPcalibAll->GetBinContent(dedxcalib.hMIPcalibAll->FindBin(negTrack.eta()))); } else { - dEdxPos *= (50.0 / getCalibration(fDeDxVsEta, posTrack)); - dEdxNeg *= (50.0 / getCalibration(fDeDxVsEta, negTrack)); + dEdxPos *= (trkSelOpt.dEdxMIPnominal / getCalibration(fDeDxVsEta, posTrack)); + dEdxNeg *= (trkSelOpt.dEdxMIPnominal / getCalibration(fDeDxVsEta, negTrack)); } } } @@ -1171,39 +1183,39 @@ struct FlattenictyPikp { fillV0QA(v0, posTrack); fillV0QA(v0, negTrack); // float dEdxPosGa{-1.}, dEdxNegGa{-1.}; - if (applyCalibDeDx) { - if (cfgFillChrgTypeV0s) { - if (applyCalibDeDxFromCCDB) { + if (defOpt.applyCalibDeDx) { + if (defOpt.fillChrgTypeV0s) { + if (defOpt.applyCalibDeDxFromCCDB && dedxcalib.lCalibLoaded) { float dEdxPosGa = dedxcalib.hMIPcalibPos->GetBinContent(dedxcalib.hMIPcalibPos->FindBin(posTrack.eta())); float dEdxNegGa = dedxcalib.hMIPcalibNeg->GetBinContent(dedxcalib.hMIPcalibNeg->FindBin(negTrack.eta())); - if (std::abs(dEdxPos - dEdxPosGa) >= v0SelOpt.cfgdEdxPlateauSel || std::abs(dEdxNeg - dEdxNegGa) >= v0SelOpt.cfgdEdxPlateauSel) { + if (std::abs(dEdxPos - dEdxPosGa) >= v0SelOpt.dEdxPlateauSel || std::abs(dEdxNeg - dEdxNegGa) >= v0SelOpt.dEdxPlateauSel) { continue; } } else { float dEdxPosGa = getCalibration(fEDeDxVsEta, posTrack); float dEdxNegGa = getCalibration(fEDeDxVsEta, negTrack); - if (std::abs(dEdxPos - dEdxPosGa) >= v0SelOpt.cfgdEdxPlateauSel || std::abs(dEdxNeg - dEdxNegGa) >= v0SelOpt.cfgdEdxPlateauSel) { + if (std::abs(dEdxPos - dEdxPosGa) >= v0SelOpt.dEdxPlateauSel || std::abs(dEdxNeg - dEdxNegGa) >= v0SelOpt.dEdxPlateauSel) { continue; } } } else { - if (applyCalibDeDxFromCCDB) { + if (defOpt.applyCalibDeDxFromCCDB && dedxcalib.lCalibLoaded) { float dEdxPosGa = dedxcalib.hPlateauCalibAll->GetBinContent(dedxcalib.hPlateauCalibAll->FindBin(posTrack.eta())); float dEdxNegGa = dedxcalib.hPlateauCalibAll->GetBinContent(dedxcalib.hPlateauCalibAll->FindBin(negTrack.eta())); - if (std::abs(dEdxPos - dEdxPosGa) >= v0SelOpt.cfgdEdxPlateauSel || std::abs(dEdxNeg - dEdxNegGa) >= v0SelOpt.cfgdEdxPlateauSel) { + if (std::abs(dEdxPos - dEdxPosGa) >= v0SelOpt.dEdxPlateauSel || std::abs(dEdxNeg - dEdxNegGa) >= v0SelOpt.dEdxPlateauSel) { continue; } } else { float dEdxPosGa = getCalibration(fEDeDxVsEta, posTrack); float dEdxNegGa = getCalibration(fEDeDxVsEta, negTrack); - if (std::abs(dEdxPos - dEdxPosGa) >= v0SelOpt.cfgdEdxPlateauSel || std::abs(dEdxNeg - dEdxNegGa) >= v0SelOpt.cfgdEdxPlateauSel) { + if (std::abs(dEdxPos - dEdxPosGa) >= v0SelOpt.dEdxPlateauSel || std::abs(dEdxNeg - dEdxNegGa) >= v0SelOpt.dEdxPlateauSel) { continue; } } } } - if (cfgStoreThnSparse) { - if (cfgFillChrgType) { + if (defOpt.storeThnSparse) { + if (defOpt.fillChrgType) { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kPos]) + HIST("hEV0"), posTrack.eta(), mult, flat, posTrack.sign() * posTrack.p(), dEdxPos); registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kNeg]) + HIST("hEV0"), negTrack.eta(), mult, flat, negTrack.sign() * negTrack.p(), dEdxNeg); } else { @@ -1211,7 +1223,7 @@ struct FlattenictyPikp { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kAll]) + HIST("hEV0"), negTrack.eta(), mult, flat, negTrack.sign() * negTrack.p(), dEdxNeg); } } else { - if (cfgFillChrgType) { + if (defOpt.fillChrgType) { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kPos]) + HIST("hEV0"), posTrack.eta(), posTrack.sign() * posTrack.p(), dEdxPos); registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kNeg]) + HIST("hEV0"), negTrack.eta(), negTrack.sign() * negTrack.p(), dEdxNeg); } else { @@ -1223,8 +1235,8 @@ struct FlattenictyPikp { if (selectTypeV0s(collision, v0, posTrack, negTrack) == kKz) { // K0S -> pi + pi fillV0QA(v0, posTrack); fillV0QA(v0, negTrack); - if (cfgStoreThnSparse) { - if (cfgFillChrgType) { + if (defOpt.storeThnSparse) { + if (defOpt.fillChrgType) { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kPos]) + HIST("hPiV0"), posTrack.eta(), mult, flat, posTrack.sign() * posTrack.p(), dEdxPos); registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kNeg]) + HIST("hPiV0"), negTrack.eta(), mult, flat, negTrack.sign() * negTrack.p(), dEdxNeg); } else { @@ -1232,7 +1244,7 @@ struct FlattenictyPikp { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kAll]) + HIST("hPiV0"), negTrack.eta(), mult, flat, negTrack.sign() * negTrack.p(), dEdxNeg); } } else { - if (cfgFillChrgType) { + if (defOpt.fillChrgType) { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kPos]) + HIST("hPiV0"), posTrack.eta(), posTrack.sign() * posTrack.p(), dEdxPos); registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kNeg]) + HIST("hPiV0"), negTrack.eta(), negTrack.sign() * negTrack.p(), dEdxNeg); } else { @@ -1244,8 +1256,8 @@ struct FlattenictyPikp { if (selectTypeV0s(collision, v0, posTrack, negTrack) == kLam) { // L -> p + pi- fillV0QA(v0, negTrack); fillV0QA(v0, posTrack); - if (cfgStoreThnSparse) { - if (cfgFillChrgType) { + if (defOpt.storeThnSparse) { + if (defOpt.fillChrgType) { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kPos]) + HIST("hPV0"), posTrack.eta(), mult, flat, posTrack.sign() * posTrack.p(), dEdxPos); registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kNeg]) + HIST("hPiV0"), negTrack.eta(), mult, flat, negTrack.sign() * negTrack.p(), dEdxNeg); } else { @@ -1253,7 +1265,7 @@ struct FlattenictyPikp { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kAll]) + HIST("hPiV0"), negTrack.eta(), mult, flat, negTrack.sign() * negTrack.p(), dEdxNeg); } } else { - if (cfgFillChrgType) { + if (defOpt.fillChrgType) { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kPos]) + HIST("hPV0"), posTrack.eta(), posTrack.sign() * posTrack.p(), dEdxPos); registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kNeg]) + HIST("hPiV0"), negTrack.eta(), negTrack.sign() * negTrack.p(), dEdxNeg); } else { @@ -1265,8 +1277,8 @@ struct FlattenictyPikp { if (selectTypeV0s(collision, v0, posTrack, negTrack) == kaLam) { // antiLambda -> pbar + pi+ fillV0QA(v0, posTrack); fillV0QA(v0, negTrack); - if (cfgStoreThnSparse) { - if (cfgFillChrgType) { + if (defOpt.storeThnSparse) { + if (defOpt.fillChrgType) { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kPos]) + HIST("hPiV0"), posTrack.eta(), mult, flat, posTrack.sign() * posTrack.p(), dEdxPos); registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kNeg]) + HIST("hPV0"), negTrack.eta(), mult, flat, negTrack.sign() * negTrack.p(), dEdxNeg); } else { @@ -1274,7 +1286,7 @@ struct FlattenictyPikp { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kAll]) + HIST("hPV0"), negTrack.eta(), mult, flat, negTrack.sign() * negTrack.p(), dEdxNeg); } } else { - if (cfgFillChrgType) { + if (defOpt.fillChrgType) { registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kPos]) + HIST("hPiV0"), posTrack.eta(), posTrack.sign() * posTrack.p(), dEdxPos); registryData.fill(HIST(CprefixCleanV0) + HIST(Ccharge[kNeg]) + HIST("hPV0"), negTrack.eta(), negTrack.sign() * negTrack.p(), dEdxNeg); } else { @@ -1336,7 +1348,7 @@ struct FlattenictyPikp { if (!particle.isPhysicalPrimary()) { continue; } - if (std::abs(particle.eta()) > trkSelOpt.cfgTrkEtaMax) { + if (std::abs(particle.eta()) > trkSelOpt.trkEtaMax) { continue; } nCharged++; @@ -1377,7 +1389,7 @@ struct FlattenictyPikp { template int countTracks(T const& tracks, C const& collision, aod::BCsWithTimestamps const& /*bcs*/, float mult) { - if (trkSelOpt.cfgRejectTrkAtTPCSector || v0SelOpt.cfgRejectV0sAtTPCSector || applyCalibGain || applyCalibVtx) { + if (trkSelOpt.rejectTrkAtTPCSector || v0SelOpt.rejectV0sAtTPCSector || defOpt.applyCalibGainFromCCDB || defOpt.applyCalibVtxFromCCDB) { auto bc = collision.template bc_as(); int currentRun = bc.runNumber(); if (runNumber != currentRun) { @@ -1388,7 +1400,7 @@ struct FlattenictyPikp { auto nTrk = 0; for (auto const& track : tracks) { - if (!isGoodTrack(track, magField)) { + if (!isGoodTrack(track, magField)) { continue; } nTrk++; @@ -1417,7 +1429,7 @@ struct FlattenictyPikp { template inline void fillNclVsPhiCutQaHist(T const& track, const float phimodn) { - if (cfgFillNclVsPhiCutQaHist) { + if (defOpt.fillNclVsPhiCutQaHist) { registryData.fill(HIST(Cprefix) + HIST(Cstatus[ft]) + HIST("hPtPhi"), track.pt(), phimodn); registryData.fill(HIST(Cprefix) + HIST(Cstatus[ft]) + HIST("hPtPhiNclTPC"), track.eta(), track.pt(), phimodn, track.tpcNClsFound()); registryData.fill(HIST(Cprefix) + HIST(Cstatus[ft]) + HIST("hPtPhiNclPIDTPC"), track.eta(), track.pt(), phimodn, track.tpcNClsPID()); @@ -1428,54 +1440,62 @@ struct FlattenictyPikp { } } - template - bool isGoodTrack(T const& track, const int magfield) + template + bool isGoodTrack(T const& track, const float magfield) { registryData.fill(HIST("Tracks/hTrkSel"), trkSelAll); - if (std::abs(track.eta()) > trkSelOpt.cfgTrkEtaMax) { + if (std::abs(track.eta()) > trkSelOpt.trkEtaMax) { return false; } registryData.fill(HIST("Tracks/hTrkSel"), trkSelEta); - if (track.pt() < trkSelOpt.cfgTrkPtMin) { + if (track.pt() < trkSelOpt.trkPtMin) { return false; } registryData.fill(HIST("Tracks/hTrkSel"), trkSelPt); - if (!isDCAxyCut(track)) { - return false; + if constexpr (selDCA) { + if (!isDCAxyCut(track)) { + return false; + } + registryData.fill(HIST("Tracks/hTrkSel"), trkSelDCA); + if (defOpt.applyDCAParam) { + if (defOpt.applyDCAParamFromCCDB) { + if (!isDCAParamCut(track)) { + return false; + } + } else { + if (std::fabs(track.dcaXY()) > trkSelOpt.dcaXY.value[0] + trkSelOpt.dcaXY.value[1] * std::pow(track.pt(), trkSelOpt.dcaXY.value[2]) || std::fabs(track.dcaZ()) > trkSelOpt.dcaZ.value[0] + trkSelOpt.dcaZ.value[1] * std::pow(track.pt(), trkSelOpt.dcaZ.value[2])) { + return false; + } + } + registryData.fill(HIST("Tracks/hTrkSel"), trkSelCustomDCA); + } } - registryData.fill(HIST("Tracks/hTrkSel"), trkSelDCA); if (track.tpcNClsCrossedRows() < minNCrossedRowsTPC) { return false; } registryData.fill(HIST("Tracks/hTrkSel"), trkNRowsTPC); - if (trkSelOpt.cfgApplyNcl && track.tpcNClsFound() < trkSelOpt.cfgNclTPCMin) { + if (trkSelOpt.applyNcl && track.tpcNClsFound() < trkSelOpt.nclTPCMin) { return false; } registryData.fill(HIST("Tracks/hTrkSel"), trkSelNClsFound); - if (trkSelOpt.cfgApplyNclPID && track.tpcNClsPID() < trkSelOpt.cfgNclPidTPCMin) { + if (trkSelOpt.applyNclPID && track.tpcNClsPID() < trkSelOpt.nclPidTPCMin) { return false; } registryData.fill(HIST("Tracks/hTrkSel"), trkSelNClsPID); float phimodn = track.phi(); phiMod(phimodn, magfield, track.sign()); - if (cfgFillNclVsPhiCutQaHist) { + if (defOpt.fillNclVsPhiCutQaHist) { fillNclVsPhiCutQaHist(track, phimodn); } - if (trkSelOpt.cfgRejectTrkAtTPCSector && (track.pt() >= trkSelOpt.cfgPhiCutPtMin && phimodn < fPhiCutHigh->Eval(track.pt()) && phimodn > fPhiCutLow->Eval(track.pt()))) { + if (trkSelOpt.rejectTrkAtTPCSector && (track.pt() >= trkSelOpt.phiCutPtMin && phimodn < fPhiCutHigh->Eval(track.pt()) && phimodn > fPhiCutLow->Eval(track.pt()))) { return false; } - if (cfgFillNclVsPhiCutQaHist) { + if (defOpt.fillNclVsPhiCutQaHist) { fillNclVsPhiCutQaHist(track, phimodn); } registryData.fill(HIST("Tracks/hTrkSel"), trkSelTPCBndr); - if (trkSelOpt.cfgApplyCustomDCASel) { - if (std::fabs(track.dcaXY()) > trkSelOpt.cfgDcaXY.value[0] + trkSelOpt.cfgDcaXY.value[1] * std::pow(track.pt(), trkSelOpt.cfgDcaXY.value[2]) || std::fabs(track.dcaZ()) > trkSelOpt.cfgDcaZ.value[0] + trkSelOpt.cfgDcaZ.value[1] * std::pow(track.pt(), trkSelOpt.cfgDcaZ.value[2])) { - return false; - } - registryData.fill(HIST("Tracks/hTrkSel"), trkSelCustomDCA); - } return true; } @@ -1496,30 +1516,30 @@ struct FlattenictyPikp { bool isMassL = false; bool isMassAL = false; - if (std::abs(v0.mK0Short() - o2::constants::physics::MassK0Short) > v0SelOpt.cfgdmassK && std::abs(v0.mLambda() - o2::constants::physics::MassLambda0) > v0SelOpt.cfgdmassL && std::abs(v0.mAntiLambda() - o2::constants::physics::MassLambda0) > v0SelOpt.cfgdmassL && std::abs(v0.mGamma() - o2::constants::physics::MassGamma) < v0SelOpt.cfgdmassG) { + if (std::abs(v0.mK0Short() - o2::constants::physics::MassK0Short) > v0SelOpt.dmassK && std::abs(v0.mLambda() - o2::constants::physics::MassLambda0) > v0SelOpt.dmassL && std::abs(v0.mAntiLambda() - o2::constants::physics::MassLambda0) > v0SelOpt.dmassL && std::abs(v0.mGamma() - o2::constants::physics::MassGamma) < v0SelOpt.dmassG) { isMassG = true; } - if (std::abs(v0.mK0Short() - o2::constants::physics::MassK0Short) < v0SelOpt.cfgdmassK && std::abs(v0.mLambda() - o2::constants::physics::MassLambda0) > v0SelOpt.cfgdmassL && std::abs(v0.mAntiLambda() - o2::constants::physics::MassLambda0) > v0SelOpt.cfgdmassL && std::abs(v0.mGamma() - o2::constants::physics::MassGamma) > v0SelOpt.cfgdmassG) { + if (std::abs(v0.mK0Short() - o2::constants::physics::MassK0Short) < v0SelOpt.dmassK && std::abs(v0.mLambda() - o2::constants::physics::MassLambda0) > v0SelOpt.dmassL && std::abs(v0.mAntiLambda() - o2::constants::physics::MassLambda0) > v0SelOpt.dmassL && std::abs(v0.mGamma() - o2::constants::physics::MassGamma) > v0SelOpt.dmassG) { isMassK0s = true; } - if (std::abs(v0.mK0Short() - o2::constants::physics::MassK0Short) > v0SelOpt.cfgdmassK && std::abs(v0.mLambda() - o2::constants::physics::MassLambda0) < v0SelOpt.cfgdmassL && std::abs(v0.mGamma() - o2::constants::physics::MassGamma) > v0SelOpt.cfgdmassG) { + if (std::abs(v0.mK0Short() - o2::constants::physics::MassK0Short) > v0SelOpt.dmassK && std::abs(v0.mLambda() - o2::constants::physics::MassLambda0) < v0SelOpt.dmassL && std::abs(v0.mGamma() - o2::constants::physics::MassGamma) > v0SelOpt.dmassG) { isMassL = true; } - if (std::abs(v0.mK0Short() - o2::constants::physics::MassK0Short) > v0SelOpt.cfgdmassK && std::abs(v0.mAntiLambda() - o2::constants::physics::MassLambda0) < v0SelOpt.cfgdmassL && std::abs(v0.mGamma() - o2::constants::physics::MassGamma) > v0SelOpt.cfgdmassG) { + if (std::abs(v0.mK0Short() - o2::constants::physics::MassK0Short) > v0SelOpt.dmassK && std::abs(v0.mAntiLambda() - o2::constants::physics::MassLambda0) < v0SelOpt.dmassL && std::abs(v0.mGamma() - o2::constants::physics::MassGamma) > v0SelOpt.dmassG) { isMassAL = true; } // Gamma selection if (isMassG) { - if (std::abs(RecoDecay::y(std::array{v0.px(), v0.py(), v0.pz()}, o2::constants::physics::MassGamma)) < v0SelOpt.cfgV0Ymax) { // rapidity cut - if (std::abs(v0.alpha()) < v0SelOpt.cfgArmPodGammasalpha && v0.qtarm() < v0SelOpt.cfgArmPodGammasqT) { // - if (postrk.hasTPC() && std::abs(postrk.tpcNSigmaEl()) < v0SelOpt.cfgNsigmaElTPC) { - if (postrk.hasTOF() && std::abs(postrk.tofNSigmaEl()) < v0SelOpt.cfgNsigmaElTOF) { + if (std::abs(RecoDecay::y(std::array{v0.px(), v0.py(), v0.pz()}, o2::constants::physics::MassGamma)) < v0SelOpt.v0Ymax) { // rapidity cut + if (std::abs(v0.alpha()) < v0SelOpt.armPodGammasalpha && v0.qtarm() < v0SelOpt.armPodGammasqT) { // + if (postrk.hasTPC() && std::abs(postrk.tpcNSigmaEl()) < v0SelOpt.nsigmaElTPC) { + if (postrk.hasTOF() && std::abs(postrk.tofNSigmaEl()) < v0SelOpt.nsigmaElTOF) { return kGa; } } - if (negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaEl()) < v0SelOpt.cfgNsigmaElTPC) { - if (negtrk.hasTOF() && std::abs(negtrk.tofNSigmaEl()) < v0SelOpt.cfgNsigmaElTOF) { + if (negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaEl()) < v0SelOpt.nsigmaElTPC) { + if (negtrk.hasTOF() && std::abs(negtrk.tofNSigmaEl()) < v0SelOpt.nsigmaElTOF) { return kGa; } } @@ -1528,16 +1548,16 @@ struct FlattenictyPikp { } // K0S selection, K0S -> pi + pi if (isMassK0s) { - if (std::abs(v0.yK0Short()) < v0SelOpt.cfgV0Ymax) { // rapidity cut - if (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short < v0SelOpt.cfgcTauK0s) { // ctau cut - if (v0.v0cosPA() >= v0SelOpt.cfgCosPAK0s && v0.v0radius() >= v0SelOpt.cfgV0radiusK0s && v0.qtarm() * v0SelOpt.cfgArmPodK0s > std::abs(v0.alpha())) { // - if (postrk.hasTPC() && std::abs(postrk.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC) { - if (postrk.hasTOF() && std::abs(postrk.tofNSigmaPi()) < v0SelOpt.cfgNsigmaPiTOF) { + if (std::abs(v0.yK0Short()) < v0SelOpt.v0Ymax) { // rapidity cut + if (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short < v0SelOpt.cTauK0s) { // ctau cut + if (v0.v0cosPA() >= v0SelOpt.cosPAK0s && v0.v0radius() >= v0SelOpt.v0radiusK0s && v0.qtarm() * v0SelOpt.armPodK0s > std::abs(v0.alpha())) { // + if (postrk.hasTPC() && std::abs(postrk.tpcNSigmaPi()) < v0SelOpt.nsigmaPiTPC) { + if (postrk.hasTOF() && std::abs(postrk.tofNSigmaPi()) < v0SelOpt.nsigmaPiTOF) { return kKz; } } - if (negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC) { - if (negtrk.hasTOF() && std::abs(negtrk.tofNSigmaPi()) < v0SelOpt.cfgNsigmaPiTOF) { + if (negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaPi()) < v0SelOpt.nsigmaPiTPC) { + if (negtrk.hasTOF() && std::abs(negtrk.tofNSigmaPi()) < v0SelOpt.nsigmaPiTOF) { return kKz; } } @@ -1547,11 +1567,11 @@ struct FlattenictyPikp { } // Lambda selection, L -> p + pi- if (isMassL) { - if (std::abs(v0.yLambda()) < v0SelOpt.cfgV0Ymax) { // rapidity cut - if (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassLambda0 < v0SelOpt.cfgcTauLambda) { // ctau cut - if (v0.v0cosPA() >= v0SelOpt.cfgCosPALambda && v0.v0radius() >= v0SelOpt.cfgV0radiusLambda) { // - if (postrk.hasTPC() && std::abs(postrk.tpcNSigmaPr()) < v0SelOpt.cfgNsigmaPrTPC && negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC) { - if (postrk.hasTOF() && std::abs(postrk.tofNSigmaPr()) < v0SelOpt.cfgNsigmaPrTOF && negtrk.hasTOF() && std::abs(negtrk.tofNSigmaPi()) < v0SelOpt.cfgNsigmaPiTOF) { + if (std::abs(v0.yLambda()) < v0SelOpt.v0Ymax) { // rapidity cut + if (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassLambda0 < v0SelOpt.cTauLambda) { // ctau cut + if (v0.v0cosPA() >= v0SelOpt.cosPALambda && v0.v0radius() >= v0SelOpt.v0radiusLambda) { // + if (postrk.hasTPC() && std::abs(postrk.tpcNSigmaPr()) < v0SelOpt.nsigmaPrTPC && negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaPi()) < v0SelOpt.nsigmaPiTPC) { + if (postrk.hasTOF() && std::abs(postrk.tofNSigmaPr()) < v0SelOpt.nsigmaPrTOF && negtrk.hasTOF() && std::abs(negtrk.tofNSigmaPi()) < v0SelOpt.nsigmaPiTOF) { return kLam; } } @@ -1561,11 +1581,11 @@ struct FlattenictyPikp { } // antiLambda -> pbar + pi+ if (isMassAL) { - if (std::abs(v0.yLambda()) < v0SelOpt.cfgV0Ymax) { // rapidity cut - if (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassLambda0 < v0SelOpt.cfgcTauLambda) { // ctau cut - if (v0.v0cosPA() >= v0SelOpt.cfgCosPALambda && v0.v0radius() >= v0SelOpt.cfgV0radiusLambda) { // - if (postrk.hasTPC() && std::abs(postrk.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC && negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaPr()) < v0SelOpt.cfgNsigmaPrTPC) { - if (postrk.hasTOF() && std::abs(postrk.tofNSigmaPi()) < v0SelOpt.cfgNsigmaPiTOF && negtrk.hasTOF() && std::abs(negtrk.tofNSigmaPr()) < v0SelOpt.cfgNsigmaPrTOF) { + if (std::abs(v0.yLambda()) < v0SelOpt.v0Ymax) { // rapidity cut + if (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassLambda0 < v0SelOpt.cTauLambda) { // ctau cut + if (v0.v0cosPA() >= v0SelOpt.cosPALambda && v0.v0radius() >= v0SelOpt.v0radiusLambda) { // + if (postrk.hasTPC() && std::abs(postrk.tpcNSigmaPi()) < v0SelOpt.nsigmaPiTPC && negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaPr()) < v0SelOpt.nsigmaPrTPC) { + if (postrk.hasTOF() && std::abs(postrk.tofNSigmaPi()) < v0SelOpt.nsigmaPiTOF && negtrk.hasTOF() && std::abs(negtrk.tofNSigmaPr()) < v0SelOpt.nsigmaPrTOF) { return kaLam; } } @@ -1577,7 +1597,7 @@ struct FlattenictyPikp { } template - bool isGoodV0Track(T1 const& v0, T2 const& /*track*/, const int magfield) + bool isGoodV0Track(T1 const& v0, T2 const& /*track*/, const float magfield) { const auto& posTrack = v0.template posTrack_as(); const auto& negTrack = v0.template negTrack_as(); @@ -1592,22 +1612,22 @@ struct FlattenictyPikp { float negTrackPhiModn = negTrack.phi(); phiMod(posTrackPhiModn, magfield, posTrack.sign()); phiMod(negTrackPhiModn, magfield, negTrack.sign()); - if (v0SelOpt.cfgRejectV0sAtTPCSector) { - if ((posTrack.pt() >= trkSelOpt.cfgPhiCutPtMin && posTrackPhiModn < fPhiCutHigh->Eval(posTrack.pt()) && posTrackPhiModn > fPhiCutLow->Eval(posTrack.pt())) && (negTrack.pt() >= trkSelOpt.cfgPhiCutPtMin && negTrackPhiModn < fPhiCutHigh->Eval(negTrack.pt()) && negTrackPhiModn > fPhiCutLow->Eval(negTrack.pt()))) { + if (v0SelOpt.rejectV0sAtTPCSector) { + if ((posTrack.pt() >= trkSelOpt.phiCutPtMin && posTrackPhiModn < fPhiCutHigh->Eval(posTrack.pt()) && posTrackPhiModn > fPhiCutLow->Eval(posTrack.pt())) && (negTrack.pt() >= trkSelOpt.phiCutPtMin && negTrackPhiModn < fPhiCutHigh->Eval(negTrack.pt()) && negTrackPhiModn > fPhiCutLow->Eval(negTrack.pt()))) { return false; } } registryData.fill(HIST("Tracks/V0qa/hV0Sel"), v0SelRejectV0sAtTPCSector); // V0 topological selections - if (v0.v0cosPA() < v0SelOpt.cfgv0cospa) { + if (v0.v0cosPA() < v0SelOpt.v0cospa) { return false; } registryData.fill(HIST("Tracks/V0qa/hV0Sel"), v0SelCosPA); - if (v0.v0radius() < v0SelOpt.cfgv0Rmin || v0.v0radius() > v0SelOpt.cfgv0Rmax) { + if (v0.v0radius() < v0SelOpt.v0Rmin || v0.v0radius() > v0SelOpt.v0Rmax) { return false; } registryData.fill(HIST("Tracks/V0qa/hV0Sel"), v0SelV0radius); - if (std::abs(v0.dcapostopv()) < v0SelOpt.cfgDCAposToPV || std::abs(v0.dcanegtopv()) < v0SelOpt.cfgDCAnegToPV) { + if (std::abs(v0.dcapostopv()) < v0SelOpt.dcaPosToPV || std::abs(v0.dcanegtopv()) < v0SelOpt.dcaNegToPV) { return false; } registryData.fill(HIST("Tracks/V0qa/hV0Sel"), v0SelDCAposToPV); @@ -1616,7 +1636,7 @@ struct FlattenictyPikp { return false; } registryData.fill(HIST("Tracks/V0qa/hV0Sel"), v0SelDaughters); - if (v0.dcaV0daughters() > v0SelOpt.cfgDCAv0daughter) { + if (v0.dcaV0daughters() > v0SelOpt.dcaV0daughter) { return false; } registryData.fill(HIST("Tracks/V0qa/hV0Sel"), v0SelDCAv0daughter); @@ -1630,38 +1650,38 @@ struct FlattenictyPikp { template bool isGoodV0DaughterTrack(const T& track) { - if (track.eta() < v0SelOpt.cfgV0etamin || track.eta() > v0SelOpt.cfgV0etamax) { + if (track.eta() < v0SelOpt.v0etamin || track.eta() > v0SelOpt.v0etamax) { return false; } if (!track.hasTPC()) { return false; } - if (track.tpcNClsCrossedRows() < v0SelOpt.cfgminNCrossedRowsTPC) { + if (track.tpcNClsCrossedRows() < v0SelOpt.v0minNCrossedRowsTPC) { return false; } - if (track.tpcCrossedRowsOverFindableCls() < v0SelOpt.cfgminNCrossedRowsOverFindableClustersTPC) { + if (track.tpcCrossedRowsOverFindableCls() < v0SelOpt.v0minNCrossedRowsOverFindableClustersTPC) { return false; } - if (v0SelOpt.cfgApplyV0sNclFound) { - if (track.tpcNClsFound() < v0SelOpt.cfgV0NclTPCMin) { + if (v0SelOpt.applyV0sNclFound) { + if (track.tpcNClsFound() < v0SelOpt.v0NclTPCMin) { return false; } } - if (v0SelOpt.cfgApplyV0sNclPID) { - if (track.tpcNClsPID() < v0SelOpt.cfgV0NclPidTPCMin) { + if (v0SelOpt.applyV0sNclPID) { + if (track.tpcNClsPID() < v0SelOpt.v0NclPidTPCMin) { return false; } } - if (track.tpcChi2NCl() > v0SelOpt.cfgmaxChi2PerClusterTPC) { + if (track.tpcChi2NCl() > v0SelOpt.v0maxChi2PerClusterTPC) { return false; } - if (v0SelOpt.cfgRequireITS && (!track.hasITS())) { + if (v0SelOpt.v0requireITS && (!track.hasITS())) { return false; } - if (v0SelOpt.cfgRequireITS && track.itsNCls() < v0SelOpt.cfgminITSnClusters) { + if (v0SelOpt.v0requireITS && track.itsNCls() < v0SelOpt.v0minITSnClusters) { return false; } - if (track.itsChi2NCl() > v0SelOpt.cfgmaxChi2PerClusterITS) { + if (track.itsChi2NCl() > v0SelOpt.v0maxChi2PerClusterITS) { return false; } return true; @@ -1693,11 +1713,11 @@ struct FlattenictyPikp { } registryData.fill(HIST(Cprefix) + HIST(Cstatus[ft]) + HIST("hTOFPvsBeta"), track.p(), track.beta()); - if (track.beta() > trkSelOpt.cfgTOFBetaPion && track.beta() < trkSelOpt.cfgTOFBetaPion + 0.05) { // TOF pions + if (track.beta() > trkSelOpt.tofBetaPion && track.beta() < trkSelOpt.tofBetaPion + 0.05) { // TOF pions registryData.fill(HIST(Cprefix) + HIST(Cstatus[ft]) + HIST("hTOFpi"), track.eta(), track.p(), track.tpcSignal()); } - if (std::abs(track.eta()) < trkSelOpt.cfgTrkEtaMax) { + if (std::abs(track.eta()) < trkSelOpt.trkEtaMax) { if (isDCAxyWoCut(track)) { registryData.fill(HIST(Cprefix) + HIST(Cstatus[ft]) + HIST("hPtVsWOcutDCA"), track.pt(), track.dcaXY()); } @@ -1712,9 +1732,9 @@ struct FlattenictyPikp { const float mult = getMult(collision); const float flat = fillFlat(collision); if constexpr (fillHist) { - if (track.p() >= trkSelOpt.cfgMomMIPMin && track.p() <= trkSelOpt.cfgMomMIPMax) { - if (dEdx > trkSelOpt.cfgDeDxMIPMin && dEdx < trkSelOpt.cfgDeDxMIPMax) { // MIP pions - if (cfgStoreThnSparse) { + if (track.p() >= trkSelOpt.momMIPMin && track.p() <= trkSelOpt.momMIPMax) { + if (dEdx > trkSelOpt.dEdxMIPMin && dEdx < trkSelOpt.dEdxMIPMax) { // MIP pions + if (defOpt.storeThnSparse) { registryData.fill(HIST(Cprefix) + HIST(CstatCalib[ft]) + HIST(Ccharge[chrg]) + HIST("hMIP"), mult, flat, track.eta(), dEdx); } else { registryData.fill(HIST(Cprefix) + HIST(CstatCalib[ft]) + HIST(Ccharge[chrg]) + HIST("hMIP"), track.eta(), dEdx); @@ -1724,9 +1744,9 @@ struct FlattenictyPikp { registryData.fill(HIST(Cprefix) + HIST(CstatCalib[ft]) + HIST(Ccharge[chrg]) + HIST("hMIPVsPhiVsEta"), track.phi(), dEdx, track.eta()); registryData.fill(HIST(Cprefix) + HIST(CstatCalib[ft]) + HIST(Ccharge[chrg]) + HIST("hMIPNClTPCPidvsEta"), track.eta(), track.tpcNClsPID()); } - if (dEdx > trkSelOpt.cfgDeDxMIPMax + 10. && dEdx < trkSelOpt.cfgDeDxMIPMax + 30.) { // Plateau electrons - if (std::abs(track.beta() - 1) < trkSelOpt.cfgBetaPlateuMax) { - if (cfgStoreThnSparse) { + if (dEdx > trkSelOpt.dEdxMIPMax + 10. && dEdx < trkSelOpt.dEdxMIPMax + 30.) { // Plateau electrons + if (std::abs(track.beta() - 1) < trkSelOpt.betaPlateuMax) { + if (defOpt.storeThnSparse) { registryData.fill(HIST(Cprefix) + HIST(CstatCalib[ft]) + HIST(Ccharge[chrg]) + HIST("hPlateau"), mult, flat, track.eta(), dEdx); } else { registryData.fill(HIST(Cprefix) + HIST(CstatCalib[ft]) + HIST(Ccharge[chrg]) + HIST("hPlateau"), track.eta(), dEdx); @@ -1747,7 +1767,7 @@ struct FlattenictyPikp { if constexpr (fillHist) { registryQC.fill(HIST("Events/hEvtSel"), evtSelAll); } - if (evtSelOpt.cfgCustomTVX) { + if (evtSelOpt.customTVX) { if (!collision.selection_bit(aod::evsel::kIsTriggerTVX)) { return false; } @@ -1759,43 +1779,43 @@ struct FlattenictyPikp { if constexpr (fillHist) { registryQC.fill(HIST("Events/hEvtSel"), evtSelSel8); } - if (evtSelOpt.cfgRemoveITSROFrameBorder && !collision.selection_bit(aod::evsel::kNoITSROFrameBorder)) { + if (evtSelOpt.removeITSROFrameBorder && !collision.selection_bit(aod::evsel::kNoITSROFrameBorder)) { return false; } if constexpr (fillHist) { registryQC.fill(HIST("Events/hEvtSel"), evtSelNoITSROFrameBorder); } - if (evtSelOpt.cfgRemoveNoTimeFrameBorder && !collision.selection_bit(aod::evsel::kNoTimeFrameBorder)) { + if (evtSelOpt.removeNoTimeFrameBorder && !collision.selection_bit(aod::evsel::kNoTimeFrameBorder)) { return false; } if constexpr (fillHist) { registryQC.fill(HIST("Events/hEvtSel"), evtSelkNoTimeFrameBorder); } - if (evtSelOpt.cfgRemoveNoSameBunchPileup && !collision.selection_bit(aod::evsel::kNoSameBunchPileup)) { + if (evtSelOpt.removeNoSameBunchPileup && !collision.selection_bit(aod::evsel::kNoSameBunchPileup)) { return false; } if constexpr (fillHist) { registryQC.fill(HIST("Events/hEvtSel"), evtSelkNoSameBunchPileup); } - if (evtSelOpt.cfgRequireIsGoodZvtxFT0vsPV && !collision.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) { + if (evtSelOpt.requireIsGoodZvtxFT0vsPV && !collision.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) { return false; } if constexpr (fillHist) { registryQC.fill(HIST("Events/hEvtSel"), evtSelkIsGoodZvtxFT0vsPV); } - if (evtSelOpt.cfgRequireIsVertexITSTPC && !collision.selection_bit(aod::evsel::kIsVertexITSTPC)) { + if (evtSelOpt.requireIsVertexITSTPC && !collision.selection_bit(aod::evsel::kIsVertexITSTPC)) { return false; } if constexpr (fillHist) { registryQC.fill(HIST("Events/hEvtSel"), evtSelkIsVertexITSTPC); } - if (evtSelOpt.cfgRequirekIsVertexTOFmatched && !collision.selection_bit(aod::evsel::kIsVertexTOFmatched)) { + if (evtSelOpt.requirekIsVertexTOFmatched && !collision.selection_bit(aod::evsel::kIsVertexTOFmatched)) { return false; } if constexpr (fillHist) { registryQC.fill(HIST("Events/hEvtSel"), evtSelkIsVertexTOFmatched); } - if (std::abs(collision.posZ()) > evtSelOpt.cfgCutVtxZ) { + if (std::abs(collision.posZ()) > evtSelOpt.cutVtxZ) { return false; } if constexpr (fillHist) { @@ -1917,7 +1937,7 @@ struct FlattenictyPikp { float getMult(C const& collision) { float val = -999.0; - switch (multEst) { + switch (defOpt.multEst) { case MultE::CnoMult: return val; break; @@ -1932,7 +1952,7 @@ struct FlattenictyPikp { if constexpr (!isMC) { return collision.multTPC(); } else { - LOG(fatal) << "No valid multiplicity estimator: " << multEst; + LOG(fatal) << "No valid multiplicity estimator: " << defOpt.multEst; return val; } break; @@ -1999,13 +2019,13 @@ struct FlattenictyPikp { if constexpr (fillHist) { registryQC.fill(HIST("FV0/hFV0amp"), chv0, amplCh); registryQC.fill(HIST("FV0/pFV0amp"), chv0, amplCh); - if (applyCalibGain) { + if (defOpt.applyCalibGainFromCCDB) { registryQC.fill(HIST("FV0/hFV0ampCorr"), chv0, amplCh / fv0AmplCorr[chv0]); registryQC.fill(HIST("FV0/pFV0ampCorr"), chv0, amplCh / fv0AmplCorr[chv0]); } } if (amplCh > Cnull) { - if (applyCalibGain) { // equalize gain channel-by-channel + if (defOpt.applyCalibGainFromCCDB) { // equalize gain channel-by-channel amplCh /= fv0AmplCorr[chv0]; } if (chv0phi > Cnull) { @@ -2021,7 +2041,7 @@ struct FlattenictyPikp { if constexpr (fillHist) { registryQC.fill(HIST("FV0/hFV0AmplvsVtxzWoCalib"), collision.posZ(), rhoLatticeFV0[chv0phi]); } - if (applyCalibVtx) { + if (defOpt.applyCalibVtxFromCCDB) { rhoLatticeFV0[chv0phi] *= zVtxMap->GetBinContent(zVtxMap->GetXaxis()->FindBin(chv0phi), zVtxMap->GetYaxis()->FindBin(collision.posZ())); if constexpr (fillHist) { registryQC.fill(HIST("FV0/hFV0AmplvsVtxzCalib"), collision.posZ(), rhoLatticeFV0[chv0phi]); @@ -2037,6 +2057,27 @@ struct FlattenictyPikp { return oneMinusFlat; } + template + bool isDCAParamCut(T const& track) const + { + const float dcaXY = track.dcaXY(); + const float dcaZ = track.dcaZ(); + const float pt = track.pt(); + float selDCAxy = 0.f; + float selDCAz = 0.f; + + if (dcaparam.lCalibLoaded) { + selDCAxy = dcaparam.hDCAxyParam->GetBinContent(1) + dcaparam.hDCAxyParam->GetBinContent(2) / std::pow(std::abs(pt), dcaparam.hDCAxyParam->GetBinContent(3)); + selDCAxy *= trkSelOpt.nsigmaDCAxy.value; + selDCAz = dcaparam.hDCAzParam->GetBinContent(1) + dcaparam.hDCAzParam->GetBinContent(2) / std::pow(std::abs(pt), dcaparam.hDCAzParam->GetBinContent(3)); + selDCAz *= trkSelOpt.nsigmaDCAz.value; + if (std::abs(dcaXY) > selDCAxy || std::abs(dcaZ) > selDCAz) { + return false; + } + } + return true; + } + template bool isDCAxyCut(T const& track) const { @@ -2091,7 +2132,7 @@ struct FlattenictyPikp { auto v0sPerCollision = v0s.sliceBy(perColV0s, collision.globalIndex()); v0sPerCollision.bindExternalIndices(&tracks); filldEdx(tracksPerCollision, v0sPerCollision, collision, bcs); - if (cfgFillDCAxyHist) { + if (defOpt.fillDCAxyHist) { static_for<0, 4>([&](auto i) { fillDCA(tracksPerCollision, collision, bcs); }); @@ -2251,10 +2292,10 @@ struct FlattenictyPikp { if (!isChrgParticle(mcParticle.pdgCode())) { return; } - if (std::abs(mcParticle.eta()) > trkSelOpt.cfgTrkEtaMax) { + if (std::abs(mcParticle.eta()) > trkSelOpt.trkEtaMax) { return; } - if (mcParticle.pt() < trkSelOpt.cfgTrkPtMin) { + if (mcParticle.pt() < trkSelOpt.trkPtMin) { return; } if (!isPID(mcParticle)) { @@ -2359,7 +2400,7 @@ struct FlattenictyPikp { { LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); auto multMC = -1.; - if (evtSelOpt.useMultMCmidrap || multEst == CtwoInt) { // use generated Nch in ∣eta∣ < 0.8 + if (evtSelOpt.useMultMCmidrap || defOpt.multEst == CtwoInt) { // use generated Nch in ∣eta∣ < 0.8 multMC = countPart(particles); } else { multMC = getMultMC(mcCollision); // using McCentFT0Ms @@ -2370,7 +2411,7 @@ struct FlattenictyPikp { // Loop on rec collisions // Obtain here: Numerator of tracking efficiency; Secondary contamination correction for (const auto& collision : collisions) { - if (trkSelOpt.cfgRejectTrkAtTPCSector || applyCalibGain || applyCalibVtx) { + if (trkSelOpt.rejectTrkAtTPCSector || defOpt.applyCalibGainFromCCDB || defOpt.applyCalibVtxFromCCDB) { auto bc = collision.bc_as(); int currentRun = bc.runNumber(); if (runNumber != currentRun) { @@ -2379,7 +2420,7 @@ struct FlattenictyPikp { } } registryMC.fill(HIST("Events/hCentVsFlatRecINELgt0"), getMult(collision), fillFlat(collision)); // Evt split den - if (evtSelOpt.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { + if (evtSelOpt.removeSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { continue; } registryMC.fill(HIST("Events/hCentVsFlatRecINELgt0wRecEvt"), getMult(collision), fillFlat(collision)); // Evt split num, w/ Nrec > 0 @@ -2391,10 +2432,10 @@ struct FlattenictyPikp { if (!particle.isPhysicalPrimary()) { continue; } - if (std::abs(particle.eta()) > trkSelOpt.cfgTrkEtaMax) { + if (std::abs(particle.eta()) > trkSelOpt.trkEtaMax) { continue; } - if (particle.pt() < trkSelOpt.cfgTrkPtMin) { + if (particle.pt() < trkSelOpt.trkPtMin) { continue; } static_for<0, 1>([&](auto pidSgn) { @@ -2423,10 +2464,10 @@ struct FlattenictyPikp { if (!particle.isPhysicalPrimary()) { continue; } - if (std::abs(particle.eta()) > trkSelOpt.cfgTrkEtaMax) { + if (std::abs(particle.eta()) > trkSelOpt.trkEtaMax) { continue; } - if (particle.pt() < trkSelOpt.cfgTrkPtMin) { + if (particle.pt() < trkSelOpt.trkPtMin) { continue; } static_for<0, 1>([&](auto pidSgn) { @@ -2451,24 +2492,7 @@ struct FlattenictyPikp { if (!track.has_collision()) { continue; } - if (std::abs(track.eta()) > trkSelOpt.cfgTrkEtaMax) { - continue; - } - if (track.pt() < trkSelOpt.cfgTrkPtMin) { - continue; - } - if (trkSelOpt.cfgApplyNcl && track.tpcNClsFound() < trkSelOpt.cfgNclTPCMin) { - continue; - } - if (trkSelOpt.cfgApplyNclPID && track.tpcNClsPID() < trkSelOpt.cfgNclPidTPCMin) { - continue; - } - float phiModn = track.phi(); - phiMod(phiModn, magField, track.sign()); - if (trkSelOpt.cfgRejectTrkAtTPCSector && (track.pt() >= trkSelOpt.cfgPhiCutPtMin && phiModn < fPhiCutHigh->Eval(track.pt()) && phiModn > fPhiCutLow->Eval(track.pt()))) { - continue; - } - if (!isDCAxyWoCut(track)) { + if (!isGoodTrack(track, magField)) { continue; } if (!track.has_mcParticle()) { @@ -2482,10 +2506,10 @@ struct FlattenictyPikp { if (!isChrgParticle(particle.pdgCode())) { continue; } - if (std::abs(particle.eta()) > trkSelOpt.cfgTrkEtaMax) { + if (std::abs(particle.eta()) > trkSelOpt.trkEtaMax) { continue; } - if (particle.pt() < trkSelOpt.cfgTrkPtMin) { + if (particle.pt() < trkSelOpt.trkPtMin) { continue; } static_for<0, 1>([&](auto pidSgn) { // for checking purposes only: use gen Nch, gen Flat @@ -2509,10 +2533,10 @@ struct FlattenictyPikp { registryMC.fill(HIST(Cprefix) + HIST(CspeciesAll[Cidx]) + HIST(CpTvsDCAxyAll), multRecGt1, flatRec, track.pt(), track.dcaXY()); } }); - if (isDCAxyCut(track)) { + if (isGoodTrack(track, magField)) { static_for<0, 4>([&](auto i) { constexpr int Cidx = i.value; - if (std::sqrt(std::pow(std::fabs(o2::aod::pidutils::tpcNSigma(track)), 2) + std::pow(std::fabs(o2::aod::pidutils::tofNSigma(track)), 2) < trkSelOpt.cfgDcaNsigmaCombinedMax)) { + if (std::sqrt(std::pow(std::fabs(o2::aod::pidutils::tpcNSigma(track)), 2) + std::pow(std::fabs(o2::aod::pidutils::tofNSigma(track)), 2) < trkSelOpt.dcaNsigmaCombinedMax)) { if (std::fabs(particle.pdgCode()) == pDGs[Cidx]) { if (particle.isPhysicalPrimary()) { registryMC.fill(HIST(Cprefix) + HIST(CspeciesAll[Cidx]) + HIST(CdEdxMcRecPrimSel), track.eta(), multRecGt1, flatRec, track.p(), track.tpcSignal()); @@ -2541,10 +2565,10 @@ struct FlattenictyPikp { if (!isChrgParticle(particle.pdgCode())) { continue; } - if (std::abs(particle.eta()) > trkSelOpt.cfgTrkEtaMax) { + if (std::abs(particle.eta()) > trkSelOpt.trkEtaMax) { continue; } - if (particle.pt() < trkSelOpt.cfgTrkPtMin) { + if (particle.pt() < trkSelOpt.trkPtMin) { continue; } static_for<0, 1>([&](auto pidSgn) { @@ -2557,7 +2581,7 @@ struct FlattenictyPikp { // Obtain here: Denominator of signal loss and event loss; MC closure // registryMC.fill(HIST("Events/hEvtMcGen"), 0.5); - if (evtSelOpt.useZVtxCutMC && std::abs(mcCollision.posZ()) > evtSelOpt.cfgCutVtxZ) { + if (evtSelOpt.zVtxCutMC && std::abs(mcCollision.posZ()) > evtSelOpt.cutVtxZ) { return; } registryMC.fill(HIST("Events/hVtxZGen"), mcCollision.posZ()); @@ -2568,7 +2592,7 @@ struct FlattenictyPikp { } } registryMC.fill(HIST("Events/hEvtMcGen"), 2.5); - if (evtSelOpt.cfgUseInelgt0wTVX && !isInelGt0wTVX(particles)) { // TVX trigger: FT0A + FT0C acceptance + if (evtSelOpt.useInelgt0wTVX && !isInelGt0wTVX(particles)) { // TVX trigger: FT0A + FT0C acceptance return; } registryMC.fill(HIST("Events/hEvtMcGen"), 3.5); @@ -2578,10 +2602,10 @@ struct FlattenictyPikp { if (!isChrgParticle(particle.pdgCode())) { continue; } - if (std::abs(particle.eta()) > trkSelOpt.cfgTrkEtaMax) { + if (std::abs(particle.eta()) > trkSelOpt.trkEtaMax) { continue; } - if (particle.pt() < trkSelOpt.cfgTrkPtMin) { + if (particle.pt() < trkSelOpt.trkPtMin) { continue; } static_for<0, 1>([&](auto pidSgn) {