diff --git a/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx b/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx index 21784752a8e..c6bc03db737 100644 --- a/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx +++ b/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx @@ -63,6 +63,7 @@ #include #include +using std::string; using namespace o2; using namespace o2::framework; using namespace o2::constants::math; @@ -216,6 +217,7 @@ struct FlattenictyPikp { 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", false, "use CCDB-based calibration of dedx signal"}; Configurable cfgFillTrackQaHist{"cfgFillTrackQaHist", false, "fill track QA histograms"}; Configurable cfgFilldEdxCalibHist{"cfgFilldEdxCalibHist", false, "fill dEdx calibration histograms"}; Configurable cfgFilldEdxQaHist{"cfgFilldEdxQaHist", false, "fill dEdx QA histograms"}; @@ -225,8 +227,12 @@ struct FlattenictyPikp { Configurable> paramsFuncMIPpos{"paramsFuncMIPpos", std::vector{-1.f}, "parameters of pol2"}; Configurable> paramsFuncMIPneg{"paramsFuncMIPneg", std::vector{-1.f}, "parameters of pol2"}; Configurable> paramsFuncMIPall{"paramsFuncMIPall", std::vector{-1.f}, "parameters of pol2"}; + Configurable> paramsFuncPlateaUpos{"paramsFuncPlateaUpos", std::vector{-1.f}, "parameters of pol2"}; + Configurable> paramsFuncPlateaUneg{"paramsFuncPlateaUneg", std::vector{-1.f}, "parameters of pol2"}; + Configurable> paramsFuncPlateaUall{"paramsFuncPlateaUall", std::vector{-1.f}, "parameters of pol2"}; 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 cfgUseCcdbForRun{"cfgUseCcdbForRun", true, "Get ccdb object based on run number instead of timestamp"}; Configurable cfgStoreThnSparse{"cfgStoreThnSparse", false, "Store histograms as THnSparse"}; @@ -301,9 +307,6 @@ struct FlattenictyPikp { Configurable cfgNsigmaPrTOF{"cfgNsigmaPrTOF", 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"}; - //!! >>>>>>>> - // Configurable cfgV0DaughterTpcMomMax{"cfgV0DaughterTpcMomMax", 0.6f, "Maximum momentum of V0 daughter tracks in TPC"}; - //!! >>>>>>>> // standad parameters for V0 selection Configurable cfgV0etamax{"cfgV0etamax", 0.8f, "max eta of V0s"}; Configurable cfgTPCnClsmin{"cfgTPCnClsmin", 70.0f, "cfgTPCnClsmin"}; @@ -331,6 +334,7 @@ struct FlattenictyPikp { Configurable cfgArmPodGammasalpha{"cfgArmPodGammasalpha", 0.45f, "Armenteros-Podolanski alpha cut for Gammas"}; Configurable cfgArmPodGammasqT{"cfgArmPodGammasqT", 0.01f, "Armenteros-Podolanski qT cut for Gammas"}; ConfigurableAxis axisGammaMass{"axisGammaMass", {200, 0.0f, 0.5f}, "Gamma mass binning"}; + Configurable cfgdEdxPlateauSel{"cfgdEdxPlateauSel", 5, "dEdx selection sensitivity for electrons"}; } v0SelOpt; Service ccdb; @@ -341,6 +345,17 @@ struct FlattenictyPikp { Configurable grpPath{"grpPath", "GLO/GRP/GRP", "Path of the grp file"}; } ccdbConf; + struct DeDxCalib { + TList* lCalibObjects = nullptr; + TH1F* hMIPcalibPos = nullptr; + TH1F* hMIPcalibNeg = nullptr; + TH1F* hMIPcalibAll = nullptr; + TH1F* hPlateauCalibPos = nullptr; + TH1F* hPlateauCalibNeg = nullptr; + TH1F* hPlateauCalibAll = nullptr; + bool lCalibLoaded = false; + } dedxcalib; + TrackSelection selTrkGlobal; Configurable isCustomTracks{"isCustomTracks", true, "Use custom track cuts"}; Configurable requirePt{"requirePt", 0.15f, "Set minimum pT of tracks"}; @@ -373,26 +388,44 @@ struct FlattenictyPikp { TF1* fPhiCutHigh = nullptr; std::vector> fDeDxVsEta; - std::vector> vecParams; + std::vector> vecParamsMIP; + std::vector> fEDeDxVsEta; + std::vector> vecParamsPLA; void init(InitContext&) { auto vecParamsMIPpos = (std::vector)paramsFuncMIPpos; auto vecParamsMIPneg = (std::vector)paramsFuncMIPneg; auto vecParamsMIPall = (std::vector)paramsFuncMIPall; - - auto addVec = [&](std::vector>& targetVec, const std::string& name) { - targetVec.emplace_back(vecParamsMIPpos); - targetVec.emplace_back(vecParamsMIPneg); - targetVec.emplace_back(vecParamsMIPall); - if (!vecParams.size()) { - LOG(info) << "size of " << name << "is zero."; + auto vecParamsPLApos = (std::vector)paramsFuncPlateaUpos; + auto vecParamsPLAneg = (std::vector)paramsFuncPlateaUneg; + auto vecParamsPLAall = (std::vector)paramsFuncPlateaUall; + + auto addVec = [&](std::vector>& targetVec, const std::string& name, bool isMIP) { + if (isMIP) { + targetVec.emplace_back(vecParamsMIPpos); + targetVec.emplace_back(vecParamsMIPneg); + targetVec.emplace_back(vecParamsMIPall); + if (!vecParamsMIP.size()) { + LOG(info) << "size of " << name << "is zero."; + } + } else { + targetVec.emplace_back(vecParamsPLApos); + targetVec.emplace_back(vecParamsPLAneg); + targetVec.emplace_back(vecParamsPLAall); + if (!vecParamsPLA.size()) { + LOG(info) << "size of " << name << "is zero."; + } } }; - addVec(vecParams, "vecParams"); - for (const auto& params : vecParams) { + addVec(vecParamsMIP, "vecParamsMIP", true); + for (const auto& params : vecParamsMIP) { fDeDxVsEta.emplace_back(setFuncPars(params)); } + addVec(vecParamsPLA, "vecParamsPLA", false); + for (const auto& params : vecParamsPLA) { + fEDeDxVsEta.emplace_back(setFuncPars(params)); + } ccdb->setURL(ccdbConf.ccdbUrl.value); ccdb->setCaching(true); @@ -607,8 +640,8 @@ struct FlattenictyPikp { flatchrg.add({"Tracks/CleanV0/pos/hPiV0", "; #eta; mult; flat; #it{p} (GeV/#it{c}); dEdx", {kTHnSparseF, {etaAxis, multAxis, flatAxis, pAxis, dEdxAxis}}}); flatchrg.add({"Tracks/CleanV0/pos/hPV0", "; #eta; mult; flat; #it{p} (GeV/#it{c}); dEdx", {kTHnSparseF, {etaAxis, multAxis, flatAxis, pAxis, dEdxAxis}}}); } else { - flatchrg.add("Tracks/CleanTof/hBetaVsP", ";Momentum (GeV/#it{c}); #beta", kTH2F, {{{ptAxisV0s}, {120, 0., 1.2}}}); - flatchrg.add("Tracks/CleanTof/hTofExpPi", ";Momentum (GeV/#it{c});#it{t}^{#pi}_{Exp}/#it{t}_{TOF}", kTH2F, {{{ptAxisV0s}, {100, 0.2, 1.2}}}); + flatchrg.add("Tracks/CleanTof/all/hBetaVsP", ";Momentum (GeV/#it{c}); #beta", kTH2F, {{{ptAxisV0s}, {120, 0., 1.2}}}); + flatchrg.add("Tracks/CleanTof/all/hTofExpPi", ";Momentum (GeV/#it{c});#it{t}^{#pi}_{Exp}/#it{t}_{TOF}", kTH2F, {{{ptAxisV0s}, {100, 0.2, 1.2}}}); flatchrg.add({"Tracks/CleanTof/all/hPiTof", "; #eta; mult; flat; #it{p} (GeV/#it{c}); dEdx", {kTH3F, {etaAxis, pAxis, dEdxAxis}}}); flatchrg.add({"Tracks/CleanV0/pos/hEV0", "; #eta; mult; flat; #it{p} (GeV/#it{c}); dEdx", {kTH3F, {etaAxis, pAxis, dEdxAxis}}}); flatchrg.add({"Tracks/CleanV0/pos/hPiV0", "; #eta; mult; flat; #it{p} (GeV/#it{c}); dEdx", {kTH3F, {etaAxis, pAxis, dEdxAxis}}}); @@ -723,6 +756,8 @@ struct FlattenictyPikp { fv0AmplCorr = {}; std::string fullPathCalibGain; std::string fullPathCalibVtx; + std::string fullPathCalibDeDxMip; + std::string fullPathCalibDeDxPlateau; auto timestamp = bc.timestamp(); auto runnumber = bc.runNumber(); @@ -752,6 +787,46 @@ struct FlattenictyPikp { fullPathCalibVtx += "/FV0"; zVtxMap = getForTsOrRun(fullPathCalibVtx, timestamp, runnumber); } + + if (applyCalibDeDxFromCCDB) { + fullPathCalibDeDxMip = cfgDeDxCalibCcdbPath; + fullPathCalibDeDxMip += "/MIP"; + fullPathCalibDeDxPlateau = cfgDeDxCalibCcdbPath; + fullPathCalibDeDxPlateau += "/Plateau"; + if (fullPathCalibDeDxMip.empty() == false) { + dedxcalib.lCalibObjects = getForTsOrRun(fullPathCalibDeDxMip, timestamp, runnumber); + if (dedxcalib.lCalibObjects) { + LOG(info) << "CCDB objects loaded successfully"; + dedxcalib.hMIPcalibPos = static_cast(dedxcalib.lCalibObjects->FindObject("hMIPcalibPos")); + dedxcalib.hMIPcalibNeg = static_cast(dedxcalib.lCalibObjects->FindObject("hMIPcalibNeg")); + dedxcalib.hMIPcalibAll = static_cast(dedxcalib.lCalibObjects->FindObject("hMIPcalibAll")); + dedxcalib.lCalibLoaded = true; + if (!dedxcalib.hMIPcalibPos || !dedxcalib.hMIPcalibNeg || !dedxcalib.hMIPcalibAll) { + LOGF(error, "Problem loading CCDB objects! Please check"); + dedxcalib.lCalibLoaded = false; + } + } else { + LOGF(fatal, "Could not load hMIPcalib from %s", fullPathCalibDeDxMip.c_str()); + dedxcalib.lCalibLoaded = false; + } + } + if (fullPathCalibDeDxPlateau.empty() == false) { + dedxcalib.lCalibObjects = getForTsOrRun(fullPathCalibDeDxPlateau, timestamp, runnumber); + if (dedxcalib.lCalibObjects) { + LOG(info) << "CCDB objects loaded successfully"; + dedxcalib.hPlateauCalibPos = static_cast(dedxcalib.lCalibObjects->FindObject("hPlateauCalibPos")); + dedxcalib.hPlateauCalibNeg = static_cast(dedxcalib.lCalibObjects->FindObject("hPlateauCalibNeg")); + dedxcalib.hPlateauCalibAll = static_cast(dedxcalib.lCalibObjects->FindObject("hPlateauCalibAll")); + dedxcalib.lCalibLoaded = true; + if (!dedxcalib.hPlateauCalibPos || !dedxcalib.hPlateauCalibNeg || !dedxcalib.hPlateauCalibAll) { + LOGF(error, "Problem loading CCDB objects! Please check"); + dedxcalib.lCalibLoaded = false; + } + } else { + LOGF(fatal, "Could not load hPlateauCalib from %s", fullPathCalibDeDxPlateau.c_str()); + } + } + } } using MyCollisions = soa::Join; @@ -796,7 +871,7 @@ struct FlattenictyPikp { track.passedTPCRefit()); } - template + template bool selTOFPi(T const& track) { if (track.hasTOF() && track.goodTOFMatch()) { @@ -804,9 +879,9 @@ struct FlattenictyPikp { const float trkLength = track.length(); const float tExpPiTOF = track.tofExpSignalPi(tTOF); if (track.p() >= trkSelOpt.cfgMomSelPiTOF && trkLength > kNull && tTOF > kNull) { - flatchrg.fill(HIST("Tracks/CleanTof/hTofExpPi"), track.p(), tExpPiTOF / tTOF); + flatchrg.fill(HIST(kPrefixCleanTof) + HIST(kCharge[kAll]) + HIST("hTofExpPi"), track.p(), tExpPiTOF / tTOF); if (std::abs((tExpPiTOF / tTOF) - kOne) < trkSelOpt.cfgTofBetaPiMax) { - flatchrg.fill(HIST("Tracks/CleanTof/hBetaVsP"), track.p(), track.beta()); + flatchrg.fill(HIST(kPrefixCleanTof) + HIST(kCharge[kAll]) + HIST("hBetaVsP"), track.p(), track.beta()); // if (std::abs(track.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC && std::abs(track.tofNSigmaPi()) < v0SelOpt.cfgNsigmaPiTOF) { return true; // } @@ -866,16 +941,31 @@ struct FlattenictyPikp { } if (applyCalibDeDx) { if (cfgFillChrgType) { - dEdx *= (50.0 / getCalibration(fDeDxVsEta, track)); - if (cfgFilldEdxQaHist) { - if (track.sign() * track.tpcInnerParam() > kNull) { + if (track.sign() * track.tpcInnerParam() > kNull) { + if (applyCalibDeDxFromCCDB) { + dEdx *= (50.0 / dedxcalib.hMIPcalibPos->GetBinContent(dedxcalib.hMIPcalibPos->FindBin(track.eta()))); + } else { + dEdx *= (50.0 / getCalibration(fDeDxVsEta, track)); + } + if (cfgFilldEdxQaHist) { filldEdxQA(track, collision, dEdx); + } + } else { + if (applyCalibDeDxFromCCDB) { + dEdx *= (50.0 / dedxcalib.hMIPcalibNeg->GetBinContent(dedxcalib.hMIPcalibNeg->FindBin(track.eta()))); } else { + dEdx *= (50.0 / getCalibration(fDeDxVsEta, track)); + } + if (cfgFilldEdxQaHist) { filldEdxQA(track, collision, dEdx); } } } else { - dEdx *= (50.0 / getCalibration(fDeDxVsEta, track)); + if (applyCalibDeDxFromCCDB) { + dEdx *= (50.0 / dedxcalib.hMIPcalibAll->GetBinContent(dedxcalib.hMIPcalibAll->FindBin(track.eta()))); + } else { + dEdx *= (50.0 / getCalibration(fDeDxVsEta, track)); + } if (cfgFilldEdxQaHist) { filldEdxQA(track, collision, dEdx); } @@ -895,7 +985,7 @@ struct FlattenictyPikp { // TOF pions if (cfgFillV0Hist) { - if (selTOFPi(track)) { + if (selTOFPi(track)) { if (cfgFillChrgType) { if (track.sign() * track.tpcInnerParam() > kNull) { if (cfgStoreThnSparse) { @@ -937,11 +1027,31 @@ struct FlattenictyPikp { float dEdxNeg = negTrack.tpcSignal(); if (applyCalibDeDx) { - dEdxPos *= (50.0 / getCalibration(fDeDxVsEta, posTrack)); - dEdxNeg *= (50.0 / getCalibration(fDeDxVsEta, negTrack)); + if (applyCalibDeDxFromCCDB) { + dEdxPos *= (50.0 / dedxcalib.hMIPcalibAll->GetBinContent(dedxcalib.hMIPcalibAll->FindBin(posTrack.eta()))); + dEdxNeg *= (50.0 / dedxcalib.hMIPcalibAll->GetBinContent(dedxcalib.hMIPcalibAll->FindBin(negTrack.eta()))); + } else { + dEdxPos *= (50.0 / getCalibration(fDeDxVsEta, posTrack)); + dEdxNeg *= (50.0 / getCalibration(fDeDxVsEta, negTrack)); + } } if (selectTypeV0s(collision, v0, posTrack, negTrack) == kGa) { // Gamma selection + if (applyCalibDeDx) { + if (applyCalibDeDxFromCCDB) { + const float dEdxPosGa = dedxcalib.hPlateauCalibAll->GetBinContent(dedxcalib.hPlateauCalibAll->FindBin(posTrack.eta())); + const float dEdxNegGa = dedxcalib.hPlateauCalibAll->GetBinContent(dedxcalib.hPlateauCalibAll->FindBin(negTrack.eta())); + if (std::abs(dEdxPos - dEdxPosGa) >= v0SelOpt.cfgdEdxPlateauSel || std::abs(dEdxNeg - dEdxNegGa) >= v0SelOpt.cfgdEdxPlateauSel) { + continue; + } + } else { + const float dEdxPosGa = getCalibration(fEDeDxVsEta, posTrack); + const float dEdxNegGa = getCalibration(fEDeDxVsEta, negTrack); + if (std::abs(dEdxPos - dEdxPosGa) >= v0SelOpt.cfgdEdxPlateauSel || std::abs(dEdxNeg - dEdxNegGa) >= v0SelOpt.cfgdEdxPlateauSel) { + continue; + } + } + } if (cfgStoreThnSparse) { flatchrg.fill(HIST(kPrefixCleanV0) + HIST(kCharge[kPos]) + HIST("hEV0"), posTrack.eta(), mult, flat, posTrack.sign() * posTrack.tpcInnerParam(), dEdxPos); flatchrg.fill(HIST(kPrefixCleanV0) + HIST(kCharge[kNeg]) + HIST("hEV0"), negTrack.eta(), mult, flat, negTrack.sign() * negTrack.tpcInnerParam(), dEdxNeg); @@ -1090,12 +1200,12 @@ struct FlattenictyPikp { if (v0.mGamma() < v0SelOpt.cfgdmassG) { // inv mass cut if (std::abs(yGamma) < v0SelOpt.cfgV0Ymax) { // rapidity cut if (std::abs(v0.alpha()) < v0SelOpt.cfgArmPodGammasalpha && v0.qtarm() < v0SelOpt.cfgArmPodGammasqT) { // - if (/*postrk.tpcInnerParam() < v0SelOpt.cfgV0DaughterTpcMomMax &&*/ postrk.hasTPC() && std::abs(postrk.tpcNSigmaEl()) < v0SelOpt.cfgNsigmaElTPC) { + if (postrk.hasTPC() && std::abs(postrk.tpcNSigmaEl()) < v0SelOpt.cfgNsigmaElTPC) { if (postrk.hasTOF() && std::abs(postrk.tofNSigmaEl()) < v0SelOpt.cfgNsigmaElTOF) { return kGa; } } - if (/*negtrk.tpcInnerParam() < v0SelOpt.cfgV0DaughterTpcMomMax &&*/ negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaEl()) < v0SelOpt.cfgNsigmaElTPC) { + if (negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaEl()) < v0SelOpt.cfgNsigmaElTPC) { if (negtrk.hasTOF() && std::abs(negtrk.tofNSigmaEl()) < v0SelOpt.cfgNsigmaElTOF) { return kGa; } @@ -1114,12 +1224,12 @@ struct FlattenictyPikp { 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.tpcInnerParam() < v0SelOpt.cfgV0DaughterTpcMomMax &&*/ postrk.hasTPC() && std::abs(postrk.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC) { + if (postrk.hasTPC() && std::abs(postrk.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC) { if (postrk.hasTOF() && std::abs(postrk.tofNSigmaPi()) < v0SelOpt.cfgNsigmaPiTOF) { return kKz; } } - if (/*negtrk.tpcInnerParam() < v0SelOpt.cfgV0DaughterTpcMomMax &&*/ negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC) { + if (negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC) { if (negtrk.hasTOF() && std::abs(negtrk.tofNSigmaPi()) < v0SelOpt.cfgNsigmaPiTOF) { return kKz; } @@ -1139,7 +1249,7 @@ struct FlattenictyPikp { 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.tpcInnerParam() < v0SelOpt.cfgV0DaughterTpcMomMax &&*/ postrk.hasTPC() && std::abs(postrk.tpcNSigmaPr()) < v0SelOpt.cfgNsigmaPrTPC && negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC) { + 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) { return kLam; } @@ -1159,7 +1269,7 @@ struct FlattenictyPikp { 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.tpcInnerParam() < v0SelOpt.cfgV0DaughterTpcMomMax &&*/ postrk.hasTPC() && std::abs(postrk.tpcNSigmaPi()) < v0SelOpt.cfgNsigmaPiTPC && negtrk.hasTPC() && std::abs(negtrk.tpcNSigmaPr()) < v0SelOpt.cfgNsigmaPrTPC) { + 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) { return kaLam; }