From 6ace151461bfc2c7ebf1452eb9f442369b6d0c9b Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Fri, 6 Nov 2020 23:58:37 +0100 Subject: [PATCH 01/14] First version of skimming for Lc some changes update Expect that v0s are already built and preselected some more work A bit further, but not compiling just a temp commit Compiling version - still refinements needed further work temp not working not working again, needed for debug ppp working version - cuts still to be tuned clang few changes clang further work forgotten file forgotten file Fixing copy/paste error clang --- .../AnalysisDataModel/HFSecondaryVertex.h | 65 ++++- Analysis/Tasks/PWGHF/CMakeLists.txt | 5 + .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 209 ++++++++++++++ .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 267 +++++++++++++++++- 4 files changed, 539 insertions(+), 7 deletions(-) create mode 100644 Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h index 8d4a61c89cf4a..c0fdf04b85a01 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h @@ -21,6 +21,7 @@ #include "AnalysisCore/RecoDecay.h" #include "AnalysisCore/HFSelectorCuts.h" #include "AnalysisDataModel/PID/PIDResponse.h" +#include "AnalysisDataModel/StrangenessTables.h" using namespace o2::analysis; @@ -43,6 +44,7 @@ using BigTracksMC = soa::Join; using BigTracksPID = soa::Join; +using V0DataExt = aod::V0DataExt; // FIXME: this is a workaround until we get the index columns to work with joins. @@ -52,6 +54,7 @@ DECLARE_SOA_INDEX_COLUMN_FULL(Index0, index0, int, Tracks, "_0"); //! DECLARE_SOA_INDEX_COLUMN_FULL(Index1, index1, int, Tracks, "_1"); //! DECLARE_SOA_INDEX_COLUMN_FULL(Index2, index2, int, Tracks, "_2"); //! DECLARE_SOA_INDEX_COLUMN_FULL(Index3, index3, int, Tracks, "_3"); //! + DECLARE_SOA_INDEX_COLUMN_FULL(IndexV0, indexV0, int, V0DataExt, "_V0"); //! DECLARE_SOA_COLUMN(HFflag, hfflag, uint8_t); //! DECLARE_SOA_COLUMN(D0ToKPiFlag, d0ToKPiFlag, uint8_t); //! @@ -68,7 +71,12 @@ DECLARE_SOA_TABLE(HfTrackIndexProng2, "AOD", "HFTRACKIDXP2", //! hf_track_index::Index1Id, hf_track_index::HFflag); -DECLARE_SOA_TABLE(HfCutStatusProng2, "AOD", "HFCUTSTATUSP2", //! + DECLARE_SOA_TABLE(HfTrackIndexCasc, "AOD", "HFTRACKIDXCASC", //! + hf_track_index::IndexV0Id, + hf_track_index::Index0Id, + hf_track_index::HFflag); + + DECLARE_SOA_TABLE(HfCutStatusProng2, "AOD", "HFCUTSTATUSP2", //! hf_track_index::D0ToKPiFlag, hf_track_index::JpsiToEEFlag); @@ -357,6 +365,61 @@ DECLARE_SOA_TABLE(HfCandProng2MCGen, "AOD", "HFCANDP2MCGEN", //! hf_cand_prong2::FlagMCMatchGen, hf_cand_prong2::OriginMCGen); +// cascade decay candidate table + +namespace hf_cand_casc +{ +DECLARE_SOA_EXPRESSION_COLUMN(Px, px, float, 1.f * aod::hf_cand::pxProng0 + 1.f * aod::hf_cand::pxProng1); +DECLARE_SOA_EXPRESSION_COLUMN(Py, py, float, 1.f * aod::hf_cand::pyProng0 + 1.f * aod::hf_cand::pyProng1); +DECLARE_SOA_EXPRESSION_COLUMN(Pz, pz, float, 1.f * aod::hf_cand::pzProng0 + 1.f * aod::hf_cand::pzProng1); +} // namespace hf_cand_casc + +DECLARE_SOA_TABLE(HfCandCascBase, "AOD", "HFCANDCASCBASE", + // general columns + HFCAND_COLUMNS, + // cascade specific columns + hf_cand::PxProng0, hf_cand::PyProng0, hf_cand::PzProng0, + hf_cand::PxProng1, hf_cand::PyProng1, hf_cand::PzProng1, + hf_cand::ImpactParameter0, hf_cand::ImpactParameter1, + hf_cand::ErrorImpactParameter0, hf_cand::ErrorImpactParameter1, + hf_track_index::IndexV0Id, // V0 index + hf_track_index::Index0Id, + hf_track_index::HFflag, + // V0 + v0data::X, v0data::Y, v0data::Z, + v0data::DCAV0Daughters, + /* dynamic columns */ + hf_cand_prong2::M, + hf_cand_prong2::M2, + hf_cand_prong2::ImpactParameterProduct, + hf_cand_prong2::CosThetaStar, + hf_cand_prong2::ImpactParameterProngSqSum, + /* dynamic columns that use candidate momentum components */ + hf_cand::Pt, + hf_cand::Pt2, + hf_cand::P, + hf_cand::P2, + hf_cand::PVector, + hf_cand::CPA, + hf_cand::CPAXY, + hf_cand::Ct, + hf_cand::ImpactParameterXY, + hf_cand_prong2::MaxNormalisedDeltaIP, + hf_cand::Eta, + hf_cand::Phi, + hf_cand::Y, + hf_cand::E, + hf_cand::E2, + // dynamic columns from V0 + v0data::V0Radius, + v0data::V0CosPA); + +// extended table with expression columns that can be used as arguments of dynamic columns +DECLARE_SOA_EXTENDED_TABLE_USER(HfCandCascExt, HfCandCascBase, "HFCANDCASCEXT", + hf_cand_casc::Px, hf_cand_casc::Py, hf_cand_casc::Pz); + +using HfCandCascade = HfCandCascExt; + // specific 3-prong decay properties namespace hf_cand_prong3 { diff --git a/Analysis/Tasks/PWGHF/CMakeLists.txt b/Analysis/Tasks/PWGHF/CMakeLists.txt index 6fb285562c45d..c66fcf4597fc6 100644 --- a/Analysis/Tasks/PWGHF/CMakeLists.txt +++ b/Analysis/Tasks/PWGHF/CMakeLists.txt @@ -38,6 +38,11 @@ o2_add_dpl_workflow(hf-tree-creator-d0-tokpi PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing ROOT::EG COMPONENT_NAME Analysis) +o2_add_dpl_workflow(hf-candidate-creator-cascade + SOURCES HFCandidateCreatorCascade.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing ROOT::EG + COMPONENT_NAME Analysis) + o2_add_dpl_workflow(hf-candidate-creator-3prong SOURCES HFCandidateCreator3Prong.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing ROOT::EG diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx new file mode 100644 index 0000000000000..e20311c39c316 --- /dev/null +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -0,0 +1,209 @@ +// Copyright CERN and copyright holders of ALICE O2. This software is +// distributed under the terms of the GNU General Public License v3 (GPL +// Version 3), copied verbatim in the file "COPYING". +// +// See http://alice-o2.web.cern.ch/license for full licensing information. +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file HFCandidateCreatorCascade.cxx +/// \brief Reconstruction of heavy-flavour cascade decay candidates +/// + +#include "Framework/AnalysisTask.h" +#include "DetectorsVertexing/DCAFitterN.h" +#include "AnalysisDataModel/HFSecondaryVertex.h" +#include "AnalysisCore/trackUtilities.h" +#include "ReconstructionDataFormats/DCA.h" +#include "ReconstructionDataFormats/V0.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::aod::hf_cand_prong2; + +void customize(std::vector& workflowOptions) +{ + ConfigParamSpec optionDoMC{"doMC", VariantType::Bool, false, {"Perform MC matching."}}; + workflowOptions.push_back(optionDoMC); +} + +#include "Framework/runDataProcessing.h" + +/// Reconstruction of heavy-flavour cascade decay candidates +struct HFCandidateCreatorCascade { + + Produces rowCandidateBase; + + Configurable d_bz{"d_bz", 5., "magnetic field"}; + Configurable b_propdca{"b_propdca", true, "create tracks version propagated to PCA"}; + Configurable d_maxr{"d_maxr", 200., "reject PCA's above this radius"}; + Configurable d_maxdzini{"d_maxdzini", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; + Configurable d_minparamchange{"d_minparamchange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable d_minrelchi2change{"d_minrelchi2change", 0.9, "stop iterations is chi2/chi2old > this"}; + Configurable b_dovalplots{"b_dovalplots", true, "do validation plots"}; + + OutputObj hmass2{TH1F("hmass2", "2-prong candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", 500, 0., 5.)}; + OutputObj hCovPVXX{TH1F("hCovPVXX", "2-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; + OutputObj hCovSVXX{TH1F("hCovSVXX", "2-prong candidates;XX element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; + + double massP = RecoDecay::getMassPDG(kProton); + double massK0s = RecoDecay::getMassPDG(kK0Short); + double massPi = RecoDecay::getMassPDG(kPiPlus); + double massLc = RecoDecay::getMassPDG(4122); + double mass2K0sP{0.}; + + void process(aod::Collisions const& collisions, + aod::HfTrackIndexCasc const& rowsTrackIndexCasc, + aod::BigTracks const& tracks, + aod::V0DataExt const& V0s) + { + // 2-prong vertex fitter + o2::vertexing::DCAFitterN<2> df; + df.setBz(d_bz); + df.setPropagateToPCA(b_propdca); + df.setMaxR(d_maxr); + df.setMaxDZIni(d_maxdzini); + df.setMinParamChange(d_minparamchange); + df.setMinRelChi2Change(d_minrelchi2change); + df.setUseAbsDCA(true); + + // loop over pairs of track indeces + for (const auto& casc : rowsTrackIndexCasc) { + auto trackParCovBach = getTrackParCov(casc.index0()); + const auto& v0 = casc.indexV0_as(); + const auto& posTrack = v0.posTrack_as(); + const auto& negTrack = v0.negTrack_as(); + auto posTrackParCov = getTrackParCov(posTrack); // check that BigTracks does not need TracksExtended! + auto negTrackParCov = getTrackParCov(negTrack); // check that BigTracks does not need TracksExtended! + posTrackParCov.propagateTo(v0.posX(), d_bz); // propagate the track to the X closest to the V0 vertex + negTrackParCov.propagateTo(v0.negX(), d_bz); // propagate the track to the X closest to the V0 vertex + const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; + const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; + // we build the neutral track to then build the cascade + auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, posTrack.globalIndex(), negTrack.globalIndex()); // build the V0 track + + auto collision = casc.index0().collision(); + + // reconstruct the cascade secondary vertex + if (df.process(trackV0, trackParCovBach) == 0) { + continue; + } + const auto& secondaryVertex = df.getPCACandidate(); + auto chi2PCA = df.getChi2AtPCACandidate(); + auto covMatrixPCA = df.calcPCACovMatrix().Array(); + hCovSVXX->Fill(covMatrixPCA[0]); // FIXME: Calculation of errorDecayLength(XY) gives wrong values without this line. + // do I have to call "df.propagateTracksToVertex();"? + auto trackParVarv0 = df.getTrack(0); + auto trackParVarbach = df.getTrack(1); + + // get track momenta + array pvecv0; + array pvecbach; + trackParVarv0.getPxPyPzGlo(pvecv0); + trackParVarbach.getPxPyPzGlo(pvecbach); + + // get track impact parameters + // This modifies track momenta! + auto primaryVertex = getPrimaryVertex(collision); + auto covMatrixPV = primaryVertex.getCov(); + hCovPVXX->Fill(covMatrixPV[0]); + o2::dataformats::DCA impactParameterv0; + o2::dataformats::DCA impactParameterbach; + trackParVarv0.propagateToDCA(primaryVertex, d_bz, &impactParameterv0); // we do this wrt the primary vtx + trackParVarbach.propagateToDCA(primaryVertex, d_bz, &impactParameterbach); + + // get uncertainty of the decay length + double phi, theta; + getPointDirection(array{collision.posX(), collision.posY(), collision.posZ()}, secondaryVertex, phi, theta); + auto errorDecayLength = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, theta) + getRotatedCovMatrixXX(covMatrixPCA, phi, theta)); + auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixPCA, phi, 0.)); + + // fill candidate table rows + rowCandidateBase(collision.posX(), collision.posY(), collision.posZ(), + secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], + errorDecayLength, errorDecayLengthXY, + chi2PCA, + pvecv0[0], pvecv0[1], pvecv0[2], + pvecbach[0], pvecbach[1], pvecbach[2], + impactParameterv0.getY(), impactParameterbach.getY(), + std::sqrt(impactParameterv0.getSigmaY2()), std::sqrt(impactParameterbach.getSigmaY2()), + casc.indexV0Id(), casc.index0Id(), + casc.hfflag(), + v0.x(), v0.y(), v0.z(), + v0.dcaV0daughters()); + + //--> Missing: DCA between V0 daughters; radius V0; cosPA --> can these be dynamic? to be checked + + // fill histograms + if (b_dovalplots) { + // calculate invariant masses + auto arrayMomenta = array{pvecv0, pvecbach}; + mass2K0sP = RecoDecay::M(arrayMomenta, array{massK0s, massP}); + hmass2->Fill(mass2K0sP); + } + } + } +}; + +/// Extends the base table with expression columns. +struct HFCandidateCreatorCascadeExpressions { + Spawns rowCandidateCasc; + void init(InitContext const&) {} +}; +/* +/// Performs MC matching. +struct HFCandidateCreator2ProngMC { + Produces rowMCMatchRec; + Produces rowMCMatchGen; + + void process(aod::HfCandProng2 const& candidates, + aod::BigTracksMC const& tracks, + aod::McParticles const& particlesMC) + { + int8_t sign = 0; + int8_t result = N2ProngDecays; + + // Match reconstructed candidates. + for (auto& candidate : candidates) { + //Printf("New rec. candidate"); + result = N2ProngDecays; + auto arrayDaughters = array{candidate.index0_as(), candidate.index1_as()}; + + // D0(bar) → π± K∓ + //Printf("Checking D0(bar) → π± K∓"); + if (RecoDecay::getMatchedMCRec(particlesMC, std::move(arrayDaughters), 421, array{+kPiPlus, -kKPlus}, true, &sign) > -1) { + result = sign * D0ToPiK; + } + + rowMCMatchRec(result); + } + + // Match generated particles. + for (auto& particle : particlesMC) { + //Printf("New gen. candidate"); + result = N2ProngDecays; + + // D0(bar) → π± K∓ + //Printf("Checking D0(bar) → π± K∓"); + if (RecoDecay::isMatchedMCGen(particlesMC, particle, 421, array{+kPiPlus, -kKPlus}, true, &sign)) { + result = sign * D0ToPiK; + } + + rowMCMatchGen(result); + } + } +}; +*/ +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + WorkflowSpec workflow{ + adaptAnalysisTask("hf-cand-creator-cascade"), + adaptAnalysisTask("hf-cand-creator-cascade-expressions")}; + const bool doMC = cfgc.options().get("doMC"); + //if (doMC) { + // workflow.push_back(adaptAnalysisTask("hf-cand-creator-2prong-mc")); + //} + return workflow; +} diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index 4de9237723504..12d5eba18f880 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -23,6 +23,12 @@ #include "AnalysisCore/trackUtilities.h" #include "AnalysisCore/HFConfigurables.h" //#include "AnalysisDataModel/Centrality.h" +#include "AnalysisDataModel/StrangenessTables.h" +#include "AnalysisDataModel/TrackSelectionTables.h" +#include "ReconstructionDataFormats/V0.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisDataModel.h" + #include using namespace o2; @@ -58,7 +64,12 @@ struct SelectTracks { Configurable ptmintrack_3prong{"ptmintrack_3prong", -1., "min. track pT for 3 prong candidate"}; Configurable> cutsTrack3Prong{"cuts_singletrack_3prong", {hf_cuts_single_track::cutsTrack[0], npTBinsTrack, nCutVarsTrack, pTBinLabelsTrack, cutVarLabelsTrack}, "Single-track selections per pT bin for 3-prong candidates"}; Configurable etamax_3prong{"etamax_3prong", 4., "max. pseudorapidity for 3 prong candidate"}; - + // bachelor cuts (when using cascades) + Configurable ptmintrack_bach{"ptmintrack_bach", 0.3, "min. track pT for bachelor in cascade candidate"}; // 0.5 for PbPb 2015? + Configurable dcatoprimxy_maxpt_bach{"dcatoprimxy_maxpt_bach", 2., "max pt cut for min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; + Configurable dcatoprimxymin_bach{"dcatoprimxymin_bach", 0., "min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; // for PbPb 2018, the cut should be 0.0025 + Configurable dcatoprimxymax_bach{"dcatoprimxymax_bach", 1.0, "max. DCAXY to prim. vtx. for bachelor in cascade candidate"}; + Configurable etamax_bach{"etamax_bach", 0.8, "max. pseudorapidity for bachelor in cascade candidate"}; HistogramRegistry registry{ "registry", {{"hpt_nocuts", "all tracks;#it{p}_{T}^{track} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, @@ -70,6 +81,12 @@ struct SelectTracks { {"hpt_cuts_3prong", "tracks selected for 3-prong vertexing;#it{p}_{T}^{track} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, {"hdcatoprimxy_cuts_3prong", "tracks selected for 3-prong vertexing;DCAxy to prim. vtx. (cm);entries", {HistType::kTH1F, {{400, -2., 2.}}}}, {"heta_cuts_3prong", "tracks selected for 3-prong vertexing;#it{#eta};entries", {HistType::kTH1F, {{static_cast(1.2 * etamax_3prong * 100), -1.2 * etamax_3prong, 1.2 * etamax_3prong}}}}}}; + // bachelor (for cascades) histograms + {"hpt_cuts_bach", "bachelor tracks selected for cascade vertexing;#it{p}_{T}^{track} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hdcatoprimxy_cuts_bach", "bachelor tracks selected for cascade vertexing;DCAxy to prim. vtx. (cm);entries", {HistType::kTH1F, {{100, -1., 1.}}}}, + {"heta_cuts_bach", "bachelortracks selected for cascade vertexing;#it{#eta};entries", {HistType::kTH1F, {{100, -1., 1.}}}} + + }}; // array of 2-prong and 3-prong single-track cuts std::array, 2> cutsSingleTrack; @@ -106,7 +123,7 @@ struct SelectTracks { math_utils::Point3D vtxXYZ(collision.posX(), collision.posY(), collision.posZ()); for (auto& track : tracks) { - int status_prong = 3; // selection flag , 2 bits on + int status_prong = 7; // selection flag , 3 bits on auto trackPt = track.pt(); if (b_dovalplots.value) { @@ -120,6 +137,9 @@ struct SelectTracks { if (trackPt < ptmintrack_3prong) { status_prong = status_prong & ~(1 << 1); } + if (track.pt() < ptmintrack_bach) { + status_prong = status_prong & ~(1 << 2); + } auto trackEta = track.eta(); // eta cut @@ -129,11 +149,14 @@ struct SelectTracks { if ((status_prong & (1 << 1)) && abs(trackEta) > etamax_3prong) { status_prong = status_prong & ~(1 << 1); } + if ((status_prong & (1 << 2)) && abs(track.eta()) > etamax_bach) { + status_prong = status_prong & ~(1 << 2); + } // quality cut if (doCutQuality.value && status_prong > 0) { // FIXME to make a more complete selection e.g track.flags() & o2::aod::track::TPCrefit && track.flags() & o2::aod::track::GoldenChi2 && UChar_t clustermap = track.itsClusterMap(); - if (!(track.tpcNClsFound() >= d_tpcnclsfound.value && + if (!(track.tpcNClsFound() >= d_tpcnclsfound.value && // is this the number of TPC clusters? It should not be used track.flags() & o2::aod::track::ITSrefit && (TESTBIT(clustermap, 0) || TESTBIT(clustermap, 1)))) { status_prong = 0; @@ -143,6 +166,7 @@ struct SelectTracks { // DCA cut array dca; if (status_prong > 0) { + double dcatoprimxymin_bach_ptdep = dcatoprimxymin_bach * TMath::Max(0., (1 - TMath::Floor(trackPt / dcatoprimxy_maxpt_bach))); auto trackparvar0 = getTrackParCov(track); if (!trackparvar0.propagateParamToDCA(vtxXYZ, d_bz, &dca, 100.)) { // get impact parameters status_prong = 0; @@ -153,6 +177,9 @@ struct SelectTracks { if ((status_prong & (1 << 1)) && !isSelectedTrack(track, dca, Cand3Prong)) { status_prong = status_prong & ~(1 << 1); } + if ((status_prong & (1 << 2)) && (abs(dca[0]) < dcatoprimxymin_bach_ptdep || abs(dca[0]) > dcatoprimxymax_bach)) { + status_prong = status_prong & ~(1 << 2); + } } // fill histograms @@ -167,6 +194,11 @@ struct SelectTracks { registry.get(HIST("hdcatoprimxy_cuts_3prong"))->Fill(dca[0]); registry.get(HIST("heta_cuts_3prong"))->Fill(trackEta); } + if (status_prong & (1 << 2)) { + registry.get(HIST("hpt_cuts_bach"))->Fill(trackPt); + registry.get(HIST("hdcatoprimxy_cuts_bach"))->Fill(dca[0]); + registry.get(HIST("heta_cuts_bach"))->Fill(trackEta); + } } // fill table row @@ -175,6 +207,228 @@ struct SelectTracks { } }; +//________________________________________________________________________________________________________________________ + +/// Pre-selection of cascade secondary vertices +/// It will produce in any case a HfTrackIndexProng2 object, but mixing a V0 +/// with a track, instead of 2 tracks + +/// to run: o2-analysis-weak-decay-indices --aod-file AO2D.root -b | o2-analysis-lambdakzerobuilder -b | +/// o2-analysis-trackextension -b | o2-analysis-hf-track-index-skims-creator -b + +struct HFTrackIndexSkimsCreatorCascades { + Produces rowTrackIndexCasc; + // Produces rowTrackIndexCasc; + + // whether to do or not validation plots + Configurable b_dovalplots{"b_dovalplots", true, "fill histograms"}; + + // event selection + //Configurable triggerindex{"triggerindex", -1, "trigger index"}; + + // vertexing parameters + Configurable d_bz{"d_bz", 5., "magnetic field"}; + Configurable b_propdca{"b_propdca", true, "create tracks version propagated to PCA"}; + Configurable d_maxr{"d_maxr", 200., "reject PCA's above this radius"}; + Configurable d_maxdzini{"d_maxdzini", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; + Configurable d_minparamchange{"d_minparamchange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable d_minrelchi2change{"d_minrelchi2change", 0.9, "stop iterations if chi2/chi2old > this"}; + Configurable d_UseAbsDCA{"d_UseAbsDCA", true, "Use Abs DCAs"}; + + // quality cut + Configurable doCutQuality{"doCutQuality", true, "apply quality cuts"}; + + // track cuts for V0 daughters + Configurable tpcrefit{"tpcrefit", true, "request TPC refit V0 daughters"}; + Configurable mincrossedrows{"mincrossedrows", 50, "min crossed rows V0 daughters"}; + Configurable etamax{"etamax", 1.1, "max. pseudorapidity V0 daughters"}; + Configurable ptmin{"ptmin", 0.05, "min. pT V0 daughters"}; + + // bachelor cuts + // Configurable dcabachtopv{"dcabachtopv", .1, "DCA Bach To PV"}; + // Configurable ptminbach{"ptminbach", -1., "min. track pT bachelor"}; + + // v0 cuts + Configurable cospaV0{"cospaV0", .995, "CosPA V0"}; // as in the task that create the V0s + Configurable dcaXYnegtopv{"dcaXYnegtopv", .1, "DCA_XY Neg To PV"}; // check: in HF Run 2, it was 0 at filtering + Configurable dcaXYpostopv{"dcaXYpostopv", .1, "DCA_XY Pos To PV"}; // check: in HF Run 2, it was 0 at filtering + Configurable cutInvMassV0{"cutInvMassV0", 0.05, "V0 candidate invariant mass difference wrt PDG"}; + + // cascade cuts + Configurable cutCascPtCandMin{"cutCascPtCandMin", -1., "min. pT of the 2-prong candidate"}; // PbPb 2018: use 1 + Configurable cutCascInvMassLc{"cutCascInvMassLc", 1., "Lc candidate invariant mass difference wrt PDG"}; // for PbPb 2018: use 0.2 + //Configurable cutCascDCADaughters{"cutCascDCADaughters", .1, "DCA between V0 and bachelor in cascade"}; + + // histograms + HistogramRegistry registry{ + "registry", + {{"hvtx2_x", "2-prong candidates;#it{x}_{sec. vtx.} (cm);entries", {HistType::kTH1F, {{1000, -2., 2.}}}}, + {"hvtx2_y", "2-prong candidates;#it{y}_{sec. vtx.} (cm);entries", {HistType::kTH1F, {{1000, -2., 2.}}}}, + {"hvtx2_z", "2-prong candidates;#it{z}_{sec. vtx.} (cm);entries", {HistType::kTH1F, {{1000, -20., 20.}}}}, + {"hmass2", "2-prong candidates;inv. mass (K0s p) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}}}; + + // NB: using FullTracks = soa::Join; defined in Framework/Core/include/Framework/AnalysisDataModel.h + using MyTracks = soa::Join; + //Partition selectedTracks = aod::hf_seltrack::isSelProng >= 4; + // using SelectedV0s = soa::Filtered; + double massP = RecoDecay::getMassPDG(kProton); + double massK0s = RecoDecay::getMassPDG(kK0Short); + double massPi = RecoDecay::getMassPDG(kPiPlus); + double massLc = RecoDecay::getMassPDG(4122); + double mass2K0sP{0.}; // WHY HERE? + // Filter filterV0s = aod::v0data::dcapostopv > dcapostopv && + // aod::v0data::dcanegtopv > dcanegtopv; // add here the cuts on the V0s + + using FullTracksExt = soa::Join; + + void process(aod::Collision const& collision, + aod::BCs const& bcs, + //soa::Filtered const& V0s, + aod::V0DataExt const& V0s, + MyTracks const& tracks) // TODO: I am now assuming that the V0s are already filtered with my cuts (David's work to come) + { + + //Define o2 fitter, 2-prong + o2::vertexing::DCAFitterN<2> fitter; + fitter.setBz(d_bz); + fitter.setPropagateToPCA(b_propdca); + fitter.setMaxR(d_maxr); + fitter.setMinParamChange(d_minparamchange); + fitter.setMinRelChi2Change(d_minrelchi2change); + //fitter.setMaxDZIni(1e9); // used in cascadeproducer.cxx, but not for the 2 prongs + //fitter.setMaxChi2(1e9); // used in cascadeproducer.cxx, but not for the 2 prongs + fitter.setUseAbsDCA(d_UseAbsDCA); + + // fist we loop over the bachelor candidate + + //for (const auto& bach : selectedTracks) { + for (const auto& bach : tracks) { + + // selections on the bachelor + // pT cut + if (bach.isSelProng() < 4) { + continue; + } + + if (tpcrefit) { + if (!(bach.trackType() & o2::aod::track::TPCrefit)) + continue; + } + if (bach.tpcNClsCrossedRows() < mincrossedrows) + continue; + + auto bachTrack = getTrackParCov(bach); + + // now we loop over the V0s + for (const auto& v0 : V0s) { + // selections on the V0 daughters + const auto& posTrack = v0.posTrack_as(); + const auto& negTrack = v0.negTrack_as(); + if (tpcrefit) { + if (!(posTrack.trackType() & o2::aod::track::TPCrefit) || + !(negTrack.trackType() & o2::aod::track::TPCrefit)) + continue; + } + if (posTrack.tpcNClsCrossedRows() < mincrossedrows || + negTrack.tpcNClsCrossedRows() < mincrossedrows) { + continue; + } + // + // if (posTrack.dcaXY() < dcapostopv || // to the filters? + // negTrack.dcaXY() < dcanegtopv) { + // continue; + // } + // + if (posTrack.pt() < ptmin || // to the filters? I can't for now, it is not in the tables + negTrack.pt() < ptmin) { + continue; + } + if (abs(posTrack.eta()) > etamax || // to the filters? I can't for now, it is not in the tables + abs(negTrack.eta()) > etamax) { + continue; + } + + // V0 invariant mass selection + if (std::abs(v0.mK0Short() - massK0s) > cutInvMassV0) + continue; // should go to the filter, but since it is a dynamic column, I cannot use it there + + // V0 cosPointingAngle selection + if (v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < cospaV0) + continue; + + auto posTrackParCov = getTrackParCov(posTrack); + posTrackParCov.propagateTo(v0.posX(), d_bz); // propagate the track to the X closest to the V0 vertex + auto negTrackParCov = getTrackParCov(negTrack); + negTrackParCov.propagateTo(v0.negX(), d_bz); // propagate the track to the X closest to the V0 vertex + std::array pvecv0 = {0., 0., 0.}; + std::array pvecbach = {0., 0., 0.}; + + const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; + const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; + + // we build the neutral track to then build the cascade + auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, posTrack.globalIndex(), negTrack.globalIndex()); // build the V0 track + + // now we find the DCA between the V0 and the bachelor, for the cascade + int nCand2 = fitter.process(trackV0, bachTrack); + + std::array pVecCandCasc = {0., 0., 0.}; + if (nCand2 != 0) { + fitter.propagateTracksToVertex(); // propagate the bach and V0 to the Lc vertex + fitter.getTrack(0).getPxPyPzGlo(pvecv0); // take the momentum at the Lc vertex + fitter.getTrack(1).getPxPyPzGlo(pvecbach); + + // HF code for the 2 prongs would use: + //auto pVecCandCasc = array{bachTrack.px() + trackV0.px(), + // bachTrack.py() + trackV0.py(), + // bachTrack.pz() + trackV0.pz()}; + // but I think this is equivalent, and I understand it better where it comes from + pVecCandCasc = array{pvecbach[0] + pvecv0[0], + pvecbach[1] + pvecv0[1], + pvecbach[2] + pvecv0[2]}; + + // cascade candidate pT cut + if (RecoDecay::Pt(pVecCandCasc) < cutCascPtCandMin) { + continue; + } + + // invariant mass + // calculate invariant masses + auto arrMom = array{pvecbach, pvecv0}; + mass2K0sP = RecoDecay::M(arrMom, array{massP, massK0s}); + // invariant-mass cut + if (cutCascInvMassLc >= 0.) { + if (std::abs(mass2K0sP - massLc) < cutCascInvMassLc) { + continue; + } + } + std::array posCasc = {0., 0., 0.}; + const auto& cascvtx = fitter.getPCACandidate(); + for (int i = 0; i < 3; i++) { + posCasc[i] = cascvtx[i]; + } + + // fill table row + rowTrackIndexCasc(v0.globalIndex(), + bach.globalIndex(), + 1); // 1 should be the value for the Lc + // fill histograms + if (b_dovalplots) { + registry.get(HIST("hvtx2_x"))->Fill(posCasc[0]); + registry.get(HIST("hvtx2_y"))->Fill(posCasc[1]); + registry.get(HIST("hvtx2_z"))->Fill(posCasc[2]); + registry.get(HIST("hmass2"))->Fill(mass2K0sP); + } + + } // we could build the cascade + } // loop over V0s + + } // loop over tracks + } // process +}; + +//____________________________________________________________________________________________________________________________________________ + /// Pre-selection of 2-prong and 3-prong secondary vertices struct HFTrackIndexSkimsCreator { Produces rowTrackIndexProng2; @@ -220,8 +474,7 @@ struct HFTrackIndexSkimsCreator { {"hmassDsToPiKK", "D_{s} candidates;inv. mass (K K #pi) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}, {"hmassXicToPKPi", "#Xi_{c} candidates;inv. mass (p K #pi) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}}}; - Filter filterSelectTracks = (aod::hf_seltrack::isSelProng > 0); - + Filter filterSelectTracks = (aod::hf_seltrack::isSelProng > 0 || aod::hf_seltrack::isSelProng < 4); using SelectedTracks = soa::Filtered>; // FIXME @@ -911,5 +1164,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ adaptAnalysisTask(cfgc, TaskName{"hf-produce-sel-track"}), - adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-creator"})}; + adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-creator"}), + adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-cascades-creator"})}; + } From c8884fd66314869b98f68f7457c81df13f42479a Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Sat, 13 Feb 2021 00:06:22 +0100 Subject: [PATCH 02/14] Selector for Lc --> K0s+p added clang-format --- .../HFCandidateSelectionTables.h | 7 + .../AnalysisDataModel/HFSecondaryVertex.h | 28 +- Analysis/Tasks/PWGHF/CMakeLists.txt | 5 + .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 6 +- .../Tasks/PWGHF/HFLcK0spCandidateSelector.cxx | 317 ++++++++++++++++++ 5 files changed, 360 insertions(+), 3 deletions(-) create mode 100644 Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h b/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h index 8a664269bb901..0c24a40e303aa 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h @@ -42,6 +42,13 @@ DECLARE_SOA_COLUMN(IsSelJpsiToEE, isSelJpsiToEE, int); //! } // namespace hf_selcandidate_jpsi DECLARE_SOA_TABLE(HFSelJpsiToEECandidate, "AOD", "HFSELJPSICAND", //! hf_selcandidate_jpsi::IsSelJpsiToEE); +namespace hf_selcandidate_lc_k0sp +{ +DECLARE_SOA_COLUMN(IsSelLcK0sp, isSelLcK0sp, int); +} // namespace hf_selcandidate_lc_k0sp + DECLARE_SOA_TABLE(HFSelLcK0spCandidate, "AOD", "HFSELLCK0SPCAND", //! + hf_selcandidate_lc_k0sp::IsSelLcK0sp); + } // namespace o2::aod namespace o2::aod diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h index c0fdf04b85a01..d7c799357f550 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h @@ -372,6 +372,20 @@ namespace hf_cand_casc DECLARE_SOA_EXPRESSION_COLUMN(Px, px, float, 1.f * aod::hf_cand::pxProng0 + 1.f * aod::hf_cand::pxProng1); DECLARE_SOA_EXPRESSION_COLUMN(Py, py, float, 1.f * aod::hf_cand::pyProng0 + 1.f * aod::hf_cand::pyProng1); DECLARE_SOA_EXPRESSION_COLUMN(Pz, pz, float, 1.f * aod::hf_cand::pzProng0 + 1.f * aod::hf_cand::pzProng1); +DECLARE_SOA_DYNAMIC_COLUMN(M, m, [](float px0, float py0, float pz0, float px1, float py1, float pz1, const array& m) { return RecoDecay::M(array{array{px0, py0, pz0}, array{px1, py1, pz1}}, m); }); + +template +auto InvMassLc(const T& candidate) +{ + return candidate.m(array{RecoDecay::getMassPDG(kK0Short), RecoDecay::getMassPDG(kProton)}); // first daughter is K0s +} + +template +auto InvMassGamma(const T& candidate) +{ + return candidate.m(array{RecoDecay::getMassPDG(kElectron), RecoDecay::getMassPDG(kElectron)}); +} + } // namespace hf_cand_casc DECLARE_SOA_TABLE(HfCandCascBase, "AOD", "HFCANDCASCBASE", @@ -387,7 +401,10 @@ DECLARE_SOA_TABLE(HfCandCascBase, "AOD", "HFCANDCASCBASE", hf_track_index::HFflag, // V0 v0data::X, v0data::Y, v0data::Z, + v0data::PxPos, v0data::PyPos, v0data::PzPos, v0data::PxNeg, v0data::PyNeg, v0data::PzNeg, v0data::DCAV0Daughters, + v0data::DCAPosToPV, // this is the impact param wrt prim vtx in xy! + v0data::DCANegToPV, // this is the impact param wrt prim vtx in xy! /* dynamic columns */ hf_cand_prong2::M, hf_cand_prong2::M2, @@ -412,8 +429,15 @@ DECLARE_SOA_TABLE(HfCandCascBase, "AOD", "HFCANDCASCBASE", hf_cand::E2, // dynamic columns from V0 v0data::V0Radius, - v0data::V0CosPA); - + v0data::V0CosPA, + v0data::MLambda, + v0data::MAntiLambda, + v0data::MK0Short); +/*, + v0data::MLambda, + v0data::MAntiLambda, + v0data::MK0Short); +*/ // extended table with expression columns that can be used as arguments of dynamic columns DECLARE_SOA_EXTENDED_TABLE_USER(HfCandCascExt, HfCandCascBase, "HFCANDCASCEXT", hf_cand_casc::Px, hf_cand_casc::Py, hf_cand_casc::Pz); diff --git a/Analysis/Tasks/PWGHF/CMakeLists.txt b/Analysis/Tasks/PWGHF/CMakeLists.txt index c66fcf4597fc6..71ee16eb136cd 100644 --- a/Analysis/Tasks/PWGHF/CMakeLists.txt +++ b/Analysis/Tasks/PWGHF/CMakeLists.txt @@ -78,6 +78,11 @@ o2_add_dpl_workflow(hf-xic-topkpi-candidate-selector PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing COMPONENT_NAME Analysis) +o2_add_dpl_workflow(hf-lck0sp-candidate-selector + SOURCES HFLcK0spCandidateSelector.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing + COMPONENT_NAME Analysis) + o2_add_dpl_workflow(hf-task-d0 SOURCES taskD0.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index e20311c39c316..52afce980ddeb 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -132,7 +132,11 @@ struct HFCandidateCreatorCascade { casc.indexV0Id(), casc.index0Id(), casc.hfflag(), v0.x(), v0.y(), v0.z(), - v0.dcaV0daughters()); + v0.pxpos(), v0.pypos(), v0.pzpos(), + v0.pxneg(), v0.pyneg(), v0.pzneg(), + v0.dcaV0daughters(), + v0.dcapostopv(), + v0.dcanegtopv()); //--> Missing: DCA between V0 daughters; radius V0; cosPA --> can these be dynamic? to be checked diff --git a/Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx b/Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx new file mode 100644 index 0000000000000..54f3b8b1ab0fe --- /dev/null +++ b/Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx @@ -0,0 +1,317 @@ +// Copyright CERN and copyright holders of ALICE O2. This software is +// distributed under the terms of the GNU General Public License v3 (GPL +// Version 3), copied verbatim in the file "COPYING". +// +// See http://alice-o2.web.cern.ch/license for full licensing information. +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file HFLcK0spCandidateSelector.cxx +/// \brief Lc --> K0s+p selection task. +/// +/// \author Chiara Zampolli , CERN + +/// based on HFD0CandidateSelector.cxx + +#include "Framework/runDataProcessing.h" +#include "Framework/AnalysisTask.h" +#include "AnalysisDataModel/HFSecondaryVertex.h" +#include "AnalysisDataModel/HFCandidateSelectionTables.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::aod::hf_cand_casc; + +static const int npTBins = 8; +static const int nCutVars = 8; +//temporary until 2D array in configurable is solved - then move to json +//mK0s(MeV) mLambdas(MeV) mGammas(MeV) ptp ptK0sdau pTLc d0p d0K0sdau +constexpr double cuts[npTBins][nCutVars] = {{8.0, 5., 100, 0.5, 0.3, 0.6, 0.05, 999999}, // 1 < pt < 2 + {8.0, 5., 100, 0.5, 0.4, 1.3, 0.05, 999999}, // 2 < pt < 3 + {9.0, 5., 100, 0.6, 0.4, 1.3, 0.05, 999999}, // 3 < pt < 4 + {11.0, 5., 100, 0.6, 0.4, 1.4, 0.05, 999999}, // 4 < pt < 5 + {13.0, 5., 100, 0.6, 0.4, 1.4, 0.06, 999999}, // 5 < pt < 6 + {13.0, 5., 100, 0.9, 0.4, 1.6, 0.09, 999999}, // 6 < pt < 8 + {16.0, 5., 100, 0.9, 0.4, 1.7, 0.10, 999999}, // 8 < pt < 12 + {19.0, 5., 100, 1.0, 0.4, 1.9, 0.20, 999999}}; // 12 < pt < 24 +/// Struct for applying D0 selection cuts + +struct HFLcK0spCandidateSelector { + + Produces hfSelLcK0spCandidate; + + Configurable d_pTCandMin{"d_pTCandMin", 0., "Lower bound of candidate pT"}; + Configurable d_pTCandMax{"d_pTCandMax", 50., "Upper bound of candidate pT"}; + + // PID + Configurable d_pidTPCMinpT{"d_pidTPCMinpT", 0., "Lower bound of track pT for TPC PID"}; + Configurable d_pidTPCMaxpT{"d_pidTPCMaxpT", 100., "Upper bound of track pT for TPC PID"}; + Configurable d_pidCombMaxp{"d_pidCombMaxp", 4., "Upper bound of track p to use TOF + TPC Bayes PID"}; + Configurable d_nSigmaTPC{"d_nSigmaTPC", 3., "Nsigma cut on TPC only"}; + + // track quality + Configurable d_TPCNClsFindablePIDCut{"d_TPCNClsFindablePIDCut", 50., "Lower bound of TPC findable clusters for good PID"}; + Configurable b_requireTPC{"b_requireTPC", true, "Flag to require a positive Number of found clusters in TPC"}; + + /// Gets corresponding pT bin from cut file array + /// \param candpT is the pT of the candidate + /// \return corresponding bin number of array + template + int getpTBin(T candpT) // This should be taken out of the selector, since it is something in common to everyone; + // it should become parameterized with the pt intervals, and also the pt intervals + // should be configurable from outside + { + double pTBins[npTBins + 1] = {1., 2., 3., 4., 5., 6., 8., 12., 24.}; + if (candpT < pTBins[0] || candpT >= pTBins[npTBins]) { + return -1; + } + for (int i = 0; i < npTBins; i++) { + if (candpT < pTBins[i + 1]) { + return i; + } + } + return -1; + } + + /// Selection on goodness of daughter tracks + /// \note should be applied at candidate selection + /// \param track is daughter track + /// \return true if track is good + template + bool daughterSelection(const T& track) // aren't these checks already in the indexskimscreator? + { + if (track.charge() == 0) { + return false; + } + if (b_requireTPC.value && track.tpcNClsFound() == 0) { + return false; //is it clusters findable or found - need to check + } + return true; + } + + /// Conjugate independent toplogical cuts + /// \param hfCandCascade is candidate + /// \return true if candidate passes all cuts + template + bool selectionTopol(const T& hfCandCascade) + { + auto candpT = hfCandCascade.pt(); + int pTBin = getpTBin(candpT); + if (pTBin == -1) { + return false; + } + + if (candpT < d_pTCandMin || candpT >= d_pTCandMax) { + return false; //check that the candidate pT is within the analysis range + } + + if (std::abs(hfCandCascade.mK0Short() - RecoDecay::getMassPDG(kK0Short)) > cuts[pTBin][0]) { + return false; // mass of the K0s + } + + if ((std::abs(hfCandCascade.mLambda() - RecoDecay::getMassPDG(kLambda0)) < cuts[pTBin][1]) || (std::abs(hfCandCascade.mAntiLambda() - RecoDecay::getMassPDG(kLambda0)) < cuts[pTBin][1])) { + return false; // mass of the Lambda + } + + if (std::abs(InvMassGamma(hfCandCascade) - RecoDecay::getMassPDG(kGamma)) < cuts[pTBin][2]) { + return false; // mass of the Gamma + } + + if (hfCandCascade.ptProng0() > cuts[pTBin][3]) { + return false; // pt of the K0 + } + + if (hfCandCascade.ptProng1() > cuts[pTBin][4]) { + return false; // pt of the p + } + + if (hfCandCascade.pt() > cuts[pTBin][5]) { + return false; // pt of the Lc + } + + if (std::abs(hfCandCascade.impactParameter1()) > cuts[pTBin][6]) { + return false; // d0 of the bachelor + } + + if ((std::abs(hfCandCascade.dcapostopv()) > cuts[pTBin][7]) || (std::abs(hfCandCascade.dcanegtopv()) > cuts[pTBin][7])) { + return false; // d0 of the K0s daughters + } + + return true; + } + + /// Check if track is ok for TPC PID + /// \param track is the track + /// \note function to be expanded + /// \return true if track is ok for TPC PID + template + bool validTPCPID(const T& track) + { + if (TMath::Abs(track.pt()) < d_pidTPCMinpT || TMath::Abs(track.pt()) >= d_pidTPCMaxpT) { + return false; + } + //if (track.TPCNClsFindable() < d_TPCNClsFindablePIDCut) return false; + return true; + } + + /// Check if track is ok for TOF PID + /// \param track is the track + /// \note function to be expanded + /// \return true if track is ok for TOF PID + template + bool validCombPID(const T& track) + { + if (TMath::Abs(track.pt()) > d_pidCombMaxp) { // is the pt sign used for the charge? If it is always positive, we should remove the abs + return false; + } + return true; + } + + /// Check if track is compatible with given TPC Nsigma cut for a given flavour hypothesis + /// \param track is the track + /// \param nPDG is the flavour hypothesis PDG number + /// \param nSigmaCut is the nsigma threshold to test against + /// \note nPDG=211 pion nPDG=321 kaon + /// \return true if track satisfies TPC PID hypothesis for given Nsigma cut + template + bool selectionPIDTPC(const T& track, double nSigmaCut) + { + double nSigma = 100.0; //arbitarily large value + nSigma = track.tpcNSigmaPr(); + return nSigma > nSigmaCut; + } + + /* + /// Check if track is compatible with given TOF NSigma cut for a given flavour hypothesis + /// \param track is the track + /// \param nPDG is the flavour hypothesis PDG number + /// \param nSigmaCut is the nSigma threshold to test against + /// \note nPDG=211 pion nPDG=321 kaon + /// \return true if track satisfies TOF PID hypothesis for given NSigma cut + template + bool selectionPIDTOF(const T& track, int nPDG, double nSigmaCut) + { + double nSigma = 100.0; //arbitarily large value + nPDG = TMath::Abs(nPDG); + if (nPDG == 111) { + nSigma = track.tofNSigmaPi(); + } else if (nPDG == 321) { + nSigma = track.tofNSigmaKa(); + } else { + return false; + } + return nSigma < nSigmaCut; + } + */ + + /// PID selection on daughter track + /// \param track is the daughter track + /// \param nPDG is the PDG code of the flavour hypothesis + /// \note nPDG=211 pion nPDG=321 kaon + /// \return 1 if successful PID match, 0 if successful PID rejection, -1 if no PID info + template + int selectionPID(const T& track) + { + int statusTPC = -1; + // int statusTOF = -1; + + if (validTPCPID(track)) { + if (!selectionPIDTPC(track, d_nSigmaTPC)) { + statusTPC = 0; + /* + if (!selectionPIDTPC(track, nPDG, d_nSigmaTPCCombined)) { + statusTPC = 0; //rejected by PID + } else { + statusTPC = 1; //potential to be acceepted if combined with TOF + } + } else { + statusTPC = 2; //positive PID + } + */ + } else { + statusTPC = 1; + } + } + + return statusTPC; + /* + if (validTOFPID(track)) { + if (!selectionPIDTOF(track, nPDG, d_nSigmaTOF)) { + if (!selectionPIDTOF(track, nPDG, d_nSigmaTOFCombined)) { + statusTOF = 0; //rejected by PID + } else { + statusTOF = 1; //potential to be acceepted if combined with TOF + } + } else { + statusTOF = 2; //positive PID + } + } else { + statusTOF = -1; //no PID info + } + + if (statusTPC == 2 || statusTOF == 2) { + return 1; //what if we have 2 && 0 ? + } else if (statusTPC == 1 && statusTOF == 1) { + return 1; + } else if (statusTPC == 0 || statusTOF == 0) { + return 0; + } else { + return -1; + } + */ + } + + void process(aod::HfCandCascade const& hfCandCascades, aod::BigTracksPID const& tracks) + { + int statusLc = 0; // final selection flag : 0-rejected 1-accepted + bool topolLc = 0; + int pidProton = -1; + int pidLc = -1; + + for (auto& hfCandCasc : hfCandCascades) { //looping over 2 prong candidates + + statusLc = 0; + /* // not needed for the Lc + if (!(hfCandCasc.hfflag() & 1 << D0ToPiK)) { + hfSelD0Candidate(statusLc); + continue; + } + */ + + const auto& bach = hfCandCasc.index0_as(); //bachelor track + + topolLc = true; + pidProton = -1; + + // daughter track validity selection + if (!daughterSelection(bach)) { + hfSelLcK0spCandidate(statusLc); + continue; + } + + //implement filter bit 4 cut - should be done before this task at the track selection level + //need to add special cuts (additional cuts on decay length and d0 norm) + + if (!selectionTopol(hfCandCasc)) { + hfSelLcK0spCandidate(statusLc); + continue; + } + + pidProton = selectionPID(bach); + + if (pidProton == 1) { + statusLc = 1; + } + + hfSelLcK0spCandidate(statusLc); + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const&) +{ + return WorkflowSpec{ + adaptAnalysisTask("hf-lck0sp-candidate-selector")}; +} From 7af9d273a1f3f998bdba0182d7f3b1131d29470f Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Fri, 19 Feb 2021 00:20:04 +0100 Subject: [PATCH 03/14] First version of histogramming task - not compilinggit add Analysis/Tasks/PWGHF/CMakeLists.txt Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx Analysis/Tasks/PWGHF/taskLcK0sp.cxx fix compilation fixes clang --- .../AnalysisDataModel/HFSecondaryVertex.h | 2 +- Analysis/Tasks/PWGHF/CMakeLists.txt | 5 + .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 2 - .../Tasks/PWGHF/HFLcK0spCandidateSelector.cxx | 45 +++-- Analysis/Tasks/PWGHF/taskLcK0sp.cxx | 157 ++++++++++++++++++ 5 files changed, 195 insertions(+), 16 deletions(-) create mode 100644 Analysis/Tasks/PWGHF/taskLcK0sp.cxx diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h index d7c799357f550..0f55a4bea1291 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h @@ -429,7 +429,7 @@ DECLARE_SOA_TABLE(HfCandCascBase, "AOD", "HFCANDCASCBASE", hf_cand::E2, // dynamic columns from V0 v0data::V0Radius, - v0data::V0CosPA, + v0data::V0CosPA, v0data::MLambda, v0data::MAntiLambda, v0data::MK0Short); diff --git a/Analysis/Tasks/PWGHF/CMakeLists.txt b/Analysis/Tasks/PWGHF/CMakeLists.txt index 71ee16eb136cd..2451617395869 100644 --- a/Analysis/Tasks/PWGHF/CMakeLists.txt +++ b/Analysis/Tasks/PWGHF/CMakeLists.txt @@ -122,3 +122,8 @@ o2_add_dpl_workflow(hf-mc-validation SOURCES HFMCValidation.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing COMPONENT_NAME Analysis) + +o2_add_dpl_workflow(hf-task-lck0sp + SOURCES taskLcK0sp.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing + COMPONENT_NAME Analysis) diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index 52afce980ddeb..d881b2e3c99c9 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -138,8 +138,6 @@ struct HFCandidateCreatorCascade { v0.dcapostopv(), v0.dcanegtopv()); - //--> Missing: DCA between V0 daughters; radius V0; cosPA --> can these be dynamic? to be checked - // fill histograms if (b_dovalplots) { // calculate invariant masses diff --git a/Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx b/Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx index 54f3b8b1ab0fe..b70bf52011e34 100644 --- a/Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx +++ b/Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx @@ -27,15 +27,15 @@ using namespace o2::aod::hf_cand_casc; static const int npTBins = 8; static const int nCutVars = 8; //temporary until 2D array in configurable is solved - then move to json -//mK0s(MeV) mLambdas(MeV) mGammas(MeV) ptp ptK0sdau pTLc d0p d0K0sdau -constexpr double cuts[npTBins][nCutVars] = {{8.0, 5., 100, 0.5, 0.3, 0.6, 0.05, 999999}, // 1 < pt < 2 - {8.0, 5., 100, 0.5, 0.4, 1.3, 0.05, 999999}, // 2 < pt < 3 - {9.0, 5., 100, 0.6, 0.4, 1.3, 0.05, 999999}, // 3 < pt < 4 - {11.0, 5., 100, 0.6, 0.4, 1.4, 0.05, 999999}, // 4 < pt < 5 - {13.0, 5., 100, 0.6, 0.4, 1.4, 0.06, 999999}, // 5 < pt < 6 - {13.0, 5., 100, 0.9, 0.4, 1.6, 0.09, 999999}, // 6 < pt < 8 - {16.0, 5., 100, 0.9, 0.4, 1.7, 0.10, 999999}, // 8 < pt < 12 - {19.0, 5., 100, 1.0, 0.4, 1.9, 0.20, 999999}}; // 12 < pt < 24 +//mK0s(GeV) mLambdas(GeV) mGammas(GeV) ptp ptK0sdau pTLc d0p d0K0 +constexpr double cuts[npTBins][nCutVars] = {{0.008, 0.005, 0.1, 0.5, 0.3, 0.6, 0.05, 999999}, // 1 < pt < 2 + {0.008, 0.005, 0.1, 0.5, 0.4, 1.3, 0.05, 999999}, // 2 < pt < 3 + {0.009, 0.005, 0.1, 0.6, 0.4, 1.3, 0.05, 999999}, // 3 < pt < 4 + {0.011, 0.005, 0.1, 0.6, 0.4, 1.4, 0.05, 999999}, // 4 < pt < 5 + {0.013, 0.005, 0.1, 0.6, 0.4, 1.4, 0.06, 999999}, // 5 < pt < 6 + {0.013, 0.005, 0.1, 0.9, 0.4, 1.6, 0.09, 999999}, // 6 < pt < 8 + {0.016, 0.005, 0.1, 0.9, 0.4, 1.7, 0.10, 999999}, // 8 < pt < 12 + {0.019, 0.005, 0.1, 1.0, 0.4, 1.9, 0.20, 999999}}; // 12 < pt < 24 /// Struct for applying D0 selection cuts struct HFLcK0spCandidateSelector { @@ -104,40 +104,56 @@ struct HFLcK0spCandidateSelector { } if (candpT < d_pTCandMin || candpT >= d_pTCandMax) { + LOG(DEBUG) << "cand pt (first check) cut failed: from cascade --> " << candpT << ", cut --> " << d_pTCandMax; return false; //check that the candidate pT is within the analysis range } if (std::abs(hfCandCascade.mK0Short() - RecoDecay::getMassPDG(kK0Short)) > cuts[pTBin][0]) { + LOG(DEBUG) << "massK0s cut failed: from v0 in cascade, K0s --> " << hfCandCascade.mK0Short() << ", in PDG K0s --> " << RecoDecay::getMassPDG(kK0Short) << ", cut --> " << cuts[pTBin][0]; return false; // mass of the K0s } if ((std::abs(hfCandCascade.mLambda() - RecoDecay::getMassPDG(kLambda0)) < cuts[pTBin][1]) || (std::abs(hfCandCascade.mAntiLambda() - RecoDecay::getMassPDG(kLambda0)) < cuts[pTBin][1])) { + LOG(DEBUG) << "mass L cut failed: from v0 in cascade, Lambda --> " << hfCandCascade.mLambda() << ", AntiLambda --> " << hfCandCascade.mAntiLambda() << ", in PDG, Lambda --> " << RecoDecay::getMassPDG(kLambda0) << ", cut --> " << cuts[pTBin][1]; return false; // mass of the Lambda } if (std::abs(InvMassGamma(hfCandCascade) - RecoDecay::getMassPDG(kGamma)) < cuts[pTBin][2]) { + LOG(DEBUG) << "mass gamma cut failed: from v0 in cascade, gamma --> " << InvMassGamma(hfCandCascade) << ", cut --> " << cuts[pTBin][2]; return false; // mass of the Gamma } - if (hfCandCascade.ptProng0() > cuts[pTBin][3]) { + if (hfCandCascade.ptProng0() < cuts[pTBin][3]) { + LOG(DEBUG) << "v0 pt cut failed, from cascade --> " << hfCandCascade.ptProng0() << ", cut --> " << cuts[pTBin][3]; return false; // pt of the K0 } - if (hfCandCascade.ptProng1() > cuts[pTBin][4]) { + if (hfCandCascade.ptProng1() < cuts[pTBin][4]) { + LOG(DEBUG) << "bach pt cut failed, from cascade --> " << hfCandCascade.ptProng1() << " , cut --> " << cuts[pTBin][4]; return false; // pt of the p } - if (hfCandCascade.pt() > cuts[pTBin][5]) { + if (hfCandCascade.pt() < cuts[pTBin][5]) { + LOG(DEBUG) << "cand pt cut failed, from cascade --> " << hfCandCascade.pt() << ", cut --> " << cuts[pTBin][5]; return false; // pt of the Lc } if (std::abs(hfCandCascade.impactParameter1()) > cuts[pTBin][6]) { + LOG(DEBUG) << "d0 bach cut failed, in cascade --> " << hfCandCascade.impactParameter1() << ", cut --> " << cuts[pTBin][6]; return false; // d0 of the bachelor } + /* if ((std::abs(hfCandCascade.dcapostopv()) > cuts[pTBin][7]) || (std::abs(hfCandCascade.dcanegtopv()) > cuts[pTBin][7])) { + LOG(DEBUG) << "v0 daugh cut failed, positive v0 daugh --> " << hfCandCascade.dcapostopv() << ", negative v0 daugh --> " << hfCandCascade.dcanegtopv() << " , cut --> " << cuts[pTBin][7]; return false; // d0 of the K0s daughters } + */ + + if (std::abs(hfCandCascade.impactParameter0()) > cuts[pTBin][6]) { + LOG(DEBUG) << "d0 v0 cut failed, in cascade --> " << hfCandCascade.impactParameter0() << ", cut --> " << cuts[pTBin][7]; + return false; // d0 of the v0 + } return true; } @@ -286,6 +302,7 @@ struct HFLcK0spCandidateSelector { pidProton = -1; // daughter track validity selection + LOG(DEBUG) << "daughterSelection(bach) = " << daughterSelection(bach); if (!daughterSelection(bach)) { hfSelLcK0spCandidate(statusLc); continue; @@ -293,7 +310,7 @@ struct HFLcK0spCandidateSelector { //implement filter bit 4 cut - should be done before this task at the track selection level //need to add special cuts (additional cuts on decay length and d0 norm) - + LOG(DEBUG) << "selectionTopol(hfCandCasc) = " << selectionTopol(hfCandCasc); if (!selectionTopol(hfCandCasc)) { hfSelLcK0spCandidate(statusLc); continue; @@ -301,6 +318,8 @@ struct HFLcK0spCandidateSelector { pidProton = selectionPID(bach); + LOG(DEBUG) << "pidProton = " << pidProton; + if (pidProton == 1) { statusLc = 1; } diff --git a/Analysis/Tasks/PWGHF/taskLcK0sp.cxx b/Analysis/Tasks/PWGHF/taskLcK0sp.cxx new file mode 100644 index 0000000000000..3eda4370021b0 --- /dev/null +++ b/Analysis/Tasks/PWGHF/taskLcK0sp.cxx @@ -0,0 +1,157 @@ +// Copyright CERN and copyright holders of ALICE O2. This software is +// distributed under the terms of the GNU General Public License v3 (GPL +// Version 3), copied verbatim in the file "COPYING". +// +// See http://alice-o2.web.cern.ch/license for full licensing information. +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file taskLcK0sp.cxx +/// \brief LcK0sp analysis task +/// +/// \author Chiara Zampolli, , CERN +/// +/// based on taskD0.cxx, taskLc.cxx + +#include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" +#include "AnalysisDataModel/HFSecondaryVertex.h" +#include "AnalysisDataModel/HFCandidateSelectionTables.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::aod::hf_cand_casc; +using namespace o2::framework::expressions; + +void customize(std::vector& workflowOptions) +{ + ConfigParamSpec optionDoMC{"doMC", VariantType::Bool, false, {"Fill MC histograms."}}; + workflowOptions.push_back(optionDoMC); +} + +#include "Framework/runDataProcessing.h" + +/// LcK0sp analysis task +struct TaskLcK0sp { + HistogramRegistry registry{ + "registry", + {{"hmass", "cascade candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}, + {"hptcand", "cascade candidates;candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hptv0", "cascade candidates;v0 #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hptbach", "cascade candidates;bachelor #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hd0bach", "cascade candidates;bachelor DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -1., 1.}}}}, + {"hd0v0pos", "cascade candidates;pos daugh v0 DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -1., 1.}}}}, + {"hd0v0neg", "cascade candidates;neg daugh v0 DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -1., 1.}}}}, + {"hv0CPA", "cascade candidates;v0 cosine of pointing angle;entries", {HistType::kTH1F, {{110, 0.998, 1.1}}}}, + {"hEta", "cascade candidates;candidate #it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}, + {"hselectionstatus", "cascade candidates;selection status;entries", {HistType::kTH1F, {{5, -0.5, 4.5}}}}}}; + + Configurable d_selectionFlagLcK0sp{"d_selectionFlagLcK0sp", 1, "Selection Flag for LcK0sp"}; + Configurable cutEtaCandMax{"cutEtaCandMax", -1., "max. cand. pseudorapidity"}; + + Filter filterSelectCandidates = (aod::hf_selcandidate_lc_k0sp::isSelLcK0sp >= d_selectionFlagLcK0sp); + + void process(soa::Filtered> const& candidates) + { + //Printf("Candidates: %d", candidates.size()); + for (auto& candidate : candidates) { + /* + // no such selection for LcK0sp for now - it is the only cascade + if (!(candidate.hfflag() & 1 << D0ToPiK)) { + continue; + } + */ + if (cutEtaCandMax >= 0. && std::abs(candidate.eta()) > cutEtaCandMax) { + //Printf("Candidate: eta rejection: %g", candidate.eta()); + continue; + } + registry.fill(HIST("hmass"), InvMassLc(candidate)); + registry.fill(HIST("hptcand"), candidate.pt()); + registry.fill(HIST("hptv0"), candidate.ptProng0()); + registry.fill(HIST("hptbach"), candidate.ptProng1()); + registry.fill(HIST("hd0bach"), candidate.impactParameter1()); + registry.fill(HIST("hd0v0pos"), candidate.dcapostopv()); + registry.fill(HIST("hd0v0neg"), candidate.dcanegtopv()); + registry.fill(HIST("hv0CPA"), candidate.v0cosPA()); + registry.fill(HIST("hEta"), candidate.eta()); + registry.fill(HIST("hselectionstatus"), candidate.isSelLcK0sp()); + } + } +}; +/* +/// Fills MC histograms. +struct TaskD0MC { + HistogramRegistry registry{ + "registry", + {{"hPtRecSig", "2-prong candidates (matched);#it{p}_{T}^{rec.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hPtRecBg", "2-prong candidates (unmatched);#it{p}_{T}^{rec.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hPtGen", "MC particles (matched);#it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hPtGenSig", "2-prong candidates (matched);#it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hCPARecSig", "2-prong candidates (matched);cosine of pointing angle;entries", {HistType::kTH1F, {{110, -1.1, 1.1}}}}, + {"hCPARecBg", "2-prong candidates (unmatched);cosine of pointing angle;entries", {HistType::kTH1F, {{110, -1.1, 1.1}}}}, + {"hEtaRecSig", "2-prong candidates (matched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}, + {"hEtaRecBg", "2-prong candidates (unmatched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}, + {"hEtaGen", "MC particles (matched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}}}; + + Configurable d_selectionFlagD0{"d_selectionFlagD0", 1, "Selection Flag for D0"}; + Configurable d_selectionFlagD0bar{"d_selectionFlagD0bar", 1, "Selection Flag for D0bar"}; + Configurable cutEtaCandMax{"cutEtaCandMax", -1., "max. cand. pseudorapidity"}; + + Filter filterSelectCandidates = (aod::hf_selcandidate_d0::isSelD0 >= d_selectionFlagD0 || aod::hf_selcandidate_d0::isSelD0bar >= d_selectionFlagD0bar); + + void process(soa::Filtered> const& candidates, + soa::Join const& particlesMC, aod::BigTracksMC const& tracks) + { + // MC rec. + //Printf("MC Candidates: %d", candidates.size()); + for (auto& candidate : candidates) { + if (!(candidate.hfflag() & 1 << D0ToPiK)) { + continue; + } + if (cutEtaCandMax >= 0. && std::abs(candidate.eta()) > cutEtaCandMax) { + //Printf("MC Rec.: eta rejection: %g", candidate.eta()); + continue; + } + if (std::abs(candidate.flagMCMatchRec()) == 1 << D0ToPiK) { + // Get the corresponding MC particle. + auto indexMother = RecoDecay::getMother(particlesMC, candidate.index0_as().label_as>(), 421, true); + auto particleMother = particlesMC.iteratorAt(indexMother); + registry.fill(HIST("hPtGenSig"), particleMother.pt()); // gen. level pT + registry.fill(HIST("hPtRecSig"), candidate.pt()); // rec. level pT + registry.fill(HIST("hCPARecSig"), candidate.cpa()); + registry.fill(HIST("hEtaRecSig"), candidate.eta()); + } else { + registry.fill(HIST("hPtRecBg"), candidate.pt()); + registry.fill(HIST("hCPARecBg"), candidate.cpa()); + registry.fill(HIST("hEtaRecBg"), candidate.eta()); + } + } + // MC gen. + //Printf("MC Particles: %d", particlesMC.size()); + for (auto& particle : particlesMC) { + if (cutEtaCandMax >= 0. && std::abs(particle.eta()) > cutEtaCandMax) { + //Printf("MC Gen.: eta rejection: %g", particle.eta()); + continue; + } + if (std::abs(particle.flagMCMatchGen()) == 1 << D0ToPiK) { + registry.fill(HIST("hPtGen"), particle.pt()); + registry.fill(HIST("hEtaGen"), particle.eta()); + } + } + } +}; +*/ +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + WorkflowSpec workflow{ + adaptAnalysisTask("hf-task-lck0sp")}; + const bool doMC = cfgc.options().get("doMC"); + /* + if (doMC) { + workflow.push_back(adaptAnalysisTask("hf-task-d0-mc")); + } + */ + return workflow; +} From 99e18a3868210206faf5f3abd10f77f74d83d3c0 Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Sat, 20 Feb 2021 00:59:11 +0100 Subject: [PATCH 04/14] Avoid passing indices of daughters when building v0 In case, one would need a o2::dataformats::GlobalTrackID.h, but anyway it is not used. Fix --- Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 2 +- Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index d881b2e3c99c9..59254bfbeb337 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -82,7 +82,7 @@ struct HFCandidateCreatorCascade { const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; // we build the neutral track to then build the cascade - auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, posTrack.globalIndex(), negTrack.globalIndex()); // build the V0 track + auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track (indices for v0 daughters set to 0 for now) auto collision = casc.index0().collision(); diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index 12d5eba18f880..807dc80089d41 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -367,7 +367,7 @@ struct HFTrackIndexSkimsCreatorCascades { const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; // we build the neutral track to then build the cascade - auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, posTrack.globalIndex(), negTrack.globalIndex()); // build the V0 track + auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track // now we find the DCA between the V0 and the bachelor, for the cascade int nCand2 = fitter.process(trackV0, bachTrack); From 74aecc662049aeac1c184bcfa8c24bc79b433097 Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Tue, 23 Feb 2021 00:38:28 +0100 Subject: [PATCH 05/14] Comments by Vit clang Fixes for braces clang --- .../HFCandidateSelectionTables.h | 6 +- .../AnalysisDataModel/HFSecondaryVertex.h | 2 +- Analysis/Tasks/PWGHF/CMakeLists.txt | 8 +- .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 62 +-- ...ctor.cxx => HFLcK0sPCandidateSelector.cxx} | 86 ++-- .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 471 +++++++++--------- .../PWGHF/{taskLcK0sp.cxx => taskLcK0sP.cxx} | 12 +- 7 files changed, 328 insertions(+), 319 deletions(-) rename Analysis/Tasks/PWGHF/{HFLcK0spCandidateSelector.cxx => HFLcK0sPCandidateSelector.cxx} (81%) rename Analysis/Tasks/PWGHF/{taskLcK0sp.cxx => taskLcK0sP.cxx} (97%) diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h b/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h index 0c24a40e303aa..a54259b0217f0 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h @@ -44,10 +44,10 @@ DECLARE_SOA_TABLE(HFSelJpsiToEECandidate, "AOD", "HFSELJPSICAND", //! hf_selcandidate_jpsi::IsSelJpsiToEE); namespace hf_selcandidate_lc_k0sp { -DECLARE_SOA_COLUMN(IsSelLcK0sp, isSelLcK0sp, int); +DECLARE_SOA_COLUMN(IsSelLcK0sP, isSelLcK0sP, int); } // namespace hf_selcandidate_lc_k0sp - DECLARE_SOA_TABLE(HFSelLcK0spCandidate, "AOD", "HFSELLCK0SPCAND", //! - hf_selcandidate_lc_k0sp::IsSelLcK0sp); +DECLARE_SOA_TABLE(HFSelLcK0sPCandidate, "AOD", "HFSELLCK0SPCAND", //! + hf_selcandidate_lc_k0sp::IsSelLcK0sP); } // namespace o2::aod diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h index 0f55a4bea1291..b83318143fd03 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h @@ -375,7 +375,7 @@ DECLARE_SOA_EXPRESSION_COLUMN(Pz, pz, float, 1.f * aod::hf_cand::pzProng0 + 1.f DECLARE_SOA_DYNAMIC_COLUMN(M, m, [](float px0, float py0, float pz0, float px1, float py1, float pz1, const array& m) { return RecoDecay::M(array{array{px0, py0, pz0}, array{px1, py1, pz1}}, m); }); template -auto InvMassLc(const T& candidate) +auto InvMassLcToK0sP(const T& candidate) { return candidate.m(array{RecoDecay::getMassPDG(kK0Short), RecoDecay::getMassPDG(kProton)}); // first daughter is K0s } diff --git a/Analysis/Tasks/PWGHF/CMakeLists.txt b/Analysis/Tasks/PWGHF/CMakeLists.txt index 2451617395869..010d55e1a0f76 100644 --- a/Analysis/Tasks/PWGHF/CMakeLists.txt +++ b/Analysis/Tasks/PWGHF/CMakeLists.txt @@ -78,8 +78,8 @@ o2_add_dpl_workflow(hf-xic-topkpi-candidate-selector PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing COMPONENT_NAME Analysis) -o2_add_dpl_workflow(hf-lck0sp-candidate-selector - SOURCES HFLcK0spCandidateSelector.cxx +o2_add_dpl_workflow(hf-lc-tok0sp-candidate-selector + SOURCES HFLcK0sPCandidateSelector.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing COMPONENT_NAME Analysis) @@ -123,7 +123,7 @@ o2_add_dpl_workflow(hf-mc-validation PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing COMPONENT_NAME Analysis) -o2_add_dpl_workflow(hf-task-lck0sp - SOURCES taskLcK0sp.cxx +o2_add_dpl_workflow(hf-task-lc-tok0sp + SOURCES taskLcK0sP.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing COMPONENT_NAME Analysis) diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index 59254bfbeb337..f7a1031774ba5 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -36,13 +36,13 @@ struct HFCandidateCreatorCascade { Produces rowCandidateBase; - Configurable d_bz{"d_bz", 5., "magnetic field"}; - Configurable b_propdca{"b_propdca", true, "create tracks version propagated to PCA"}; - Configurable d_maxr{"d_maxr", 200., "reject PCA's above this radius"}; - Configurable d_maxdzini{"d_maxdzini", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; - Configurable d_minparamchange{"d_minparamchange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; - Configurable d_minrelchi2change{"d_minrelchi2change", 0.9, "stop iterations is chi2/chi2old > this"}; - Configurable b_dovalplots{"b_dovalplots", true, "do validation plots"}; + Configurable d_bZ{"d_bZ", 5., "magnetic field"}; + Configurable b_propDCA{"b_propDCA", true, "create tracks version propagated to PCA"}; + Configurable d_maxR{"d_maxR", 200., "reject PCA's above this radius"}; + Configurable d_maxDZIni{"d_maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; + Configurable d_minParamChange{"d_minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable d_minRelChi2Change{"d_minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; + Configurable b_doValPlots{"b_doValPlots", true, "do validation plots"}; OutputObj hmass2{TH1F("hmass2", "2-prong candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", 500, 0., 5.)}; OutputObj hCovPVXX{TH1F("hCovPVXX", "2-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; @@ -61,12 +61,12 @@ struct HFCandidateCreatorCascade { { // 2-prong vertex fitter o2::vertexing::DCAFitterN<2> df; - df.setBz(d_bz); - df.setPropagateToPCA(b_propdca); - df.setMaxR(d_maxr); - df.setMaxDZIni(d_maxdzini); - df.setMinParamChange(d_minparamchange); - df.setMinRelChi2Change(d_minrelchi2change); + df.setBz(d_bZ); + df.setPropagateToPCA(b_propDCA); + df.setMaxR(d_maxR); + df.setMaxDZIni(d_maxDZIni); + df.setMinParamChange(d_minParamChange); + df.setMinRelChi2Change(d_minRelChi2Change); df.setUseAbsDCA(true); // loop over pairs of track indeces @@ -77,8 +77,8 @@ struct HFCandidateCreatorCascade { const auto& negTrack = v0.negTrack_as(); auto posTrackParCov = getTrackParCov(posTrack); // check that BigTracks does not need TracksExtended! auto negTrackParCov = getTrackParCov(negTrack); // check that BigTracks does not need TracksExtended! - posTrackParCov.propagateTo(v0.posX(), d_bz); // propagate the track to the X closest to the V0 vertex - negTrackParCov.propagateTo(v0.negX(), d_bz); // propagate the track to the X closest to the V0 vertex + posTrackParCov.propagateTo(v0.posX(), d_bZ); // propagate the track to the X closest to the V0 vertex + negTrackParCov.propagateTo(v0.negX(), d_bZ); // propagate the track to the X closest to the V0 vertex const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; // we build the neutral track to then build the cascade @@ -95,24 +95,24 @@ struct HFCandidateCreatorCascade { auto covMatrixPCA = df.calcPCACovMatrix().Array(); hCovSVXX->Fill(covMatrixPCA[0]); // FIXME: Calculation of errorDecayLength(XY) gives wrong values without this line. // do I have to call "df.propagateTracksToVertex();"? - auto trackParVarv0 = df.getTrack(0); - auto trackParVarbach = df.getTrack(1); + auto trackParVarV0 = df.getTrack(0); + auto trackParVarBach = df.getTrack(1); // get track momenta - array pvecv0; - array pvecbach; - trackParVarv0.getPxPyPzGlo(pvecv0); - trackParVarbach.getPxPyPzGlo(pvecbach); + array pVecV0; + array pVecBach; + trackParVarV0.getPxPyPzGlo(pVecV0); + trackParVarBach.getPxPyPzGlo(pVecBach); // get track impact parameters // This modifies track momenta! auto primaryVertex = getPrimaryVertex(collision); auto covMatrixPV = primaryVertex.getCov(); hCovPVXX->Fill(covMatrixPV[0]); - o2::dataformats::DCA impactParameterv0; - o2::dataformats::DCA impactParameterbach; - trackParVarv0.propagateToDCA(primaryVertex, d_bz, &impactParameterv0); // we do this wrt the primary vtx - trackParVarbach.propagateToDCA(primaryVertex, d_bz, &impactParameterbach); + o2::dataformats::DCA impactParameterV0; + o2::dataformats::DCA impactParameterBach; + trackParVarV0.propagateToDCA(primaryVertex, d_bZ, &impactParameterV0); // we do this wrt the primary vtx + trackParVarBach.propagateToDCA(primaryVertex, d_bZ, &impactParameterBach); // get uncertainty of the decay length double phi, theta; @@ -125,10 +125,10 @@ struct HFCandidateCreatorCascade { secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], errorDecayLength, errorDecayLengthXY, chi2PCA, - pvecv0[0], pvecv0[1], pvecv0[2], - pvecbach[0], pvecbach[1], pvecbach[2], - impactParameterv0.getY(), impactParameterbach.getY(), - std::sqrt(impactParameterv0.getSigmaY2()), std::sqrt(impactParameterbach.getSigmaY2()), + pVecV0[0], pVecV0[1], pVecV0[2], + pVecBach[0], pVecBach[1], pVecBach[2], + impactParameterV0.getY(), impactParameterBach.getY(), + std::sqrt(impactParameterV0.getSigmaY2()), std::sqrt(impactParameterBach.getSigmaY2()), casc.indexV0Id(), casc.index0Id(), casc.hfflag(), v0.x(), v0.y(), v0.z(), @@ -139,9 +139,9 @@ struct HFCandidateCreatorCascade { v0.dcanegtopv()); // fill histograms - if (b_dovalplots) { + if (b_doValPlots) { // calculate invariant masses - auto arrayMomenta = array{pvecv0, pvecbach}; + auto arrayMomenta = array{pVecV0, pVecBach}; mass2K0sP = RecoDecay::M(arrayMomenta, array{massK0s, massP}); hmass2->Fill(mass2K0sP); } diff --git a/Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx similarity index 81% rename from Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx rename to Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx index b70bf52011e34..4330f063f5134 100644 --- a/Analysis/Tasks/PWGHF/HFLcK0spCandidateSelector.cxx +++ b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx @@ -24,11 +24,11 @@ using namespace o2; using namespace o2::framework; using namespace o2::aod::hf_cand_casc; -static const int npTBins = 8; +static const int nPtBins = 8; static const int nCutVars = 8; //temporary until 2D array in configurable is solved - then move to json //mK0s(GeV) mLambdas(GeV) mGammas(GeV) ptp ptK0sdau pTLc d0p d0K0 -constexpr double cuts[npTBins][nCutVars] = {{0.008, 0.005, 0.1, 0.5, 0.3, 0.6, 0.05, 999999}, // 1 < pt < 2 +constexpr double cuts[nPtBins][nCutVars] = {{0.008, 0.005, 0.1, 0.5, 0.3, 0.6, 0.05, 999999}, // 1 < pt < 2 {0.008, 0.005, 0.1, 0.5, 0.4, 1.3, 0.05, 999999}, // 2 < pt < 3 {0.009, 0.005, 0.1, 0.6, 0.4, 1.3, 0.05, 999999}, // 3 < pt < 4 {0.011, 0.005, 0.1, 0.6, 0.4, 1.4, 0.05, 999999}, // 4 < pt < 5 @@ -38,17 +38,17 @@ constexpr double cuts[npTBins][nCutVars] = {{0.008, 0.005, 0.1, 0.5, 0.3, 0.6, 0 {0.019, 0.005, 0.1, 1.0, 0.4, 1.9, 0.20, 999999}}; // 12 < pt < 24 /// Struct for applying D0 selection cuts -struct HFLcK0spCandidateSelector { +struct HFLcK0sPCandidateSelector { - Produces hfSelLcK0spCandidate; + Produces hfSelLcK0sPCandidate; Configurable d_pTCandMin{"d_pTCandMin", 0., "Lower bound of candidate pT"}; Configurable d_pTCandMax{"d_pTCandMax", 50., "Upper bound of candidate pT"}; // PID - Configurable d_pidTPCMinpT{"d_pidTPCMinpT", 0., "Lower bound of track pT for TPC PID"}; - Configurable d_pidTPCMaxpT{"d_pidTPCMaxpT", 100., "Upper bound of track pT for TPC PID"}; - Configurable d_pidCombMaxp{"d_pidCombMaxp", 4., "Upper bound of track p to use TOF + TPC Bayes PID"}; + Configurable d_pidTPCMinPt{"d_pidTPCMinPt", 0., "Lower bound of track pT for TPC PID"}; + Configurable d_pidTPCMaxPt{"d_pidTPCMaxPt", 100., "Upper bound of track pT for TPC PID"}; + Configurable d_pidCombMaxP{"d_pidCombMaxP", 4., "Upper bound of track p to use TOF + TPC Bayes PID"}; Configurable d_nSigmaTPC{"d_nSigmaTPC", 3., "Nsigma cut on TPC only"}; // track quality @@ -56,19 +56,19 @@ struct HFLcK0spCandidateSelector { Configurable b_requireTPC{"b_requireTPC", true, "Flag to require a positive Number of found clusters in TPC"}; /// Gets corresponding pT bin from cut file array - /// \param candpT is the pT of the candidate + /// \param candPt is the pT of the candidate /// \return corresponding bin number of array template - int getpTBin(T candpT) // This should be taken out of the selector, since it is something in common to everyone; + int getPtBin(T candPt) // This should be taken out of the selector, since it is something in common to everyone; // it should become parameterized with the pt intervals, and also the pt intervals // should be configurable from outside { - double pTBins[npTBins + 1] = {1., 2., 3., 4., 5., 6., 8., 12., 24.}; - if (candpT < pTBins[0] || candpT >= pTBins[npTBins]) { + double ptBins[nPtBins + 1] = {1., 2., 3., 4., 5., 6., 8., 12., 24.}; + if (candPt < ptBins[0] || candPt >= ptBins[nPtBins]) { return -1; } - for (int i = 0; i < npTBins; i++) { - if (candpT < pTBins[i + 1]) { + for (int i = 0; i < nPtBins; i++) { + if (candPt < ptBins[i + 1]) { return i; } } @@ -97,61 +97,61 @@ struct HFLcK0spCandidateSelector { template bool selectionTopol(const T& hfCandCascade) { - auto candpT = hfCandCascade.pt(); - int pTBin = getpTBin(candpT); - if (pTBin == -1) { + auto candPt = hfCandCascade.pt(); + int ptBin = getPtBin(candPt); + if (ptBin == -1) { return false; } - if (candpT < d_pTCandMin || candpT >= d_pTCandMax) { - LOG(DEBUG) << "cand pt (first check) cut failed: from cascade --> " << candpT << ", cut --> " << d_pTCandMax; + if (candPt < d_pTCandMin || candPt >= d_pTCandMax) { + LOG(DEBUG) << "cand pt (first check) cut failed: from cascade --> " << candPt << ", cut --> " << d_pTCandMax; return false; //check that the candidate pT is within the analysis range } - if (std::abs(hfCandCascade.mK0Short() - RecoDecay::getMassPDG(kK0Short)) > cuts[pTBin][0]) { - LOG(DEBUG) << "massK0s cut failed: from v0 in cascade, K0s --> " << hfCandCascade.mK0Short() << ", in PDG K0s --> " << RecoDecay::getMassPDG(kK0Short) << ", cut --> " << cuts[pTBin][0]; + if (std::abs(hfCandCascade.mK0Short() - RecoDecay::getMassPDG(kK0Short)) > cuts[ptBin][0]) { + LOG(DEBUG) << "massK0s cut failed: from v0 in cascade, K0s --> " << hfCandCascade.mK0Short() << ", in PDG K0s --> " << RecoDecay::getMassPDG(kK0Short) << ", cut --> " << cuts[ptBin][0]; return false; // mass of the K0s } - if ((std::abs(hfCandCascade.mLambda() - RecoDecay::getMassPDG(kLambda0)) < cuts[pTBin][1]) || (std::abs(hfCandCascade.mAntiLambda() - RecoDecay::getMassPDG(kLambda0)) < cuts[pTBin][1])) { - LOG(DEBUG) << "mass L cut failed: from v0 in cascade, Lambda --> " << hfCandCascade.mLambda() << ", AntiLambda --> " << hfCandCascade.mAntiLambda() << ", in PDG, Lambda --> " << RecoDecay::getMassPDG(kLambda0) << ", cut --> " << cuts[pTBin][1]; + if ((std::abs(hfCandCascade.mLambda() - RecoDecay::getMassPDG(kLambda0)) < cuts[ptBin][1]) || (std::abs(hfCandCascade.mAntiLambda() - RecoDecay::getMassPDG(kLambda0)) < cuts[ptBin][1])) { + LOG(DEBUG) << "mass L cut failed: from v0 in cascade, Lambda --> " << hfCandCascade.mLambda() << ", AntiLambda --> " << hfCandCascade.mAntiLambda() << ", in PDG, Lambda --> " << RecoDecay::getMassPDG(kLambda0) << ", cut --> " << cuts[ptBin][1]; return false; // mass of the Lambda } - if (std::abs(InvMassGamma(hfCandCascade) - RecoDecay::getMassPDG(kGamma)) < cuts[pTBin][2]) { - LOG(DEBUG) << "mass gamma cut failed: from v0 in cascade, gamma --> " << InvMassGamma(hfCandCascade) << ", cut --> " << cuts[pTBin][2]; + if (std::abs(InvMassGamma(hfCandCascade) - RecoDecay::getMassPDG(kGamma)) < cuts[ptBin][2]) { + LOG(DEBUG) << "mass gamma cut failed: from v0 in cascade, gamma --> " << InvMassGamma(hfCandCascade) << ", cut --> " << cuts[ptBin][2]; return false; // mass of the Gamma } - if (hfCandCascade.ptProng0() < cuts[pTBin][3]) { - LOG(DEBUG) << "v0 pt cut failed, from cascade --> " << hfCandCascade.ptProng0() << ", cut --> " << cuts[pTBin][3]; + if (hfCandCascade.ptProng0() < cuts[ptBin][3]) { + LOG(DEBUG) << "v0 pt cut failed, from cascade --> " << hfCandCascade.ptProng0() << ", cut --> " << cuts[ptBin][3]; return false; // pt of the K0 } - if (hfCandCascade.ptProng1() < cuts[pTBin][4]) { - LOG(DEBUG) << "bach pt cut failed, from cascade --> " << hfCandCascade.ptProng1() << " , cut --> " << cuts[pTBin][4]; + if (hfCandCascade.ptProng1() < cuts[ptBin][4]) { + LOG(DEBUG) << "bach pt cut failed, from cascade --> " << hfCandCascade.ptProng1() << " , cut --> " << cuts[ptBin][4]; return false; // pt of the p } - if (hfCandCascade.pt() < cuts[pTBin][5]) { - LOG(DEBUG) << "cand pt cut failed, from cascade --> " << hfCandCascade.pt() << ", cut --> " << cuts[pTBin][5]; + if (hfCandCascade.pt() < cuts[ptBin][5]) { + LOG(DEBUG) << "cand pt cut failed, from cascade --> " << hfCandCascade.pt() << ", cut --> " << cuts[ptBin][5]; return false; // pt of the Lc } - if (std::abs(hfCandCascade.impactParameter1()) > cuts[pTBin][6]) { - LOG(DEBUG) << "d0 bach cut failed, in cascade --> " << hfCandCascade.impactParameter1() << ", cut --> " << cuts[pTBin][6]; + if (std::abs(hfCandCascade.impactParameter1()) > cuts[ptBin][6]) { + LOG(DEBUG) << "d0 bach cut failed, in cascade --> " << hfCandCascade.impactParameter1() << ", cut --> " << cuts[ptBin][6]; return false; // d0 of the bachelor } /* - if ((std::abs(hfCandCascade.dcapostopv()) > cuts[pTBin][7]) || (std::abs(hfCandCascade.dcanegtopv()) > cuts[pTBin][7])) { - LOG(DEBUG) << "v0 daugh cut failed, positive v0 daugh --> " << hfCandCascade.dcapostopv() << ", negative v0 daugh --> " << hfCandCascade.dcanegtopv() << " , cut --> " << cuts[pTBin][7]; + if ((std::abs(hfCandCascade.dcapostopv()) > cuts[ptBin][7]) || (std::abs(hfCandCascade.dcanegtopv()) > cuts[ptBin][7])) { + LOG(DEBUG) << "v0 daugh cut failed, positive v0 daugh --> " << hfCandCascade.dcapostopv() << ", negative v0 daugh --> " << hfCandCascade.dcanegtopv() << " , cut --> " << cuts[ptBin][7]; return false; // d0 of the K0s daughters } */ - if (std::abs(hfCandCascade.impactParameter0()) > cuts[pTBin][6]) { - LOG(DEBUG) << "d0 v0 cut failed, in cascade --> " << hfCandCascade.impactParameter0() << ", cut --> " << cuts[pTBin][7]; + if (std::abs(hfCandCascade.impactParameter0()) > cuts[ptBin][6]) { + LOG(DEBUG) << "d0 v0 cut failed, in cascade --> " << hfCandCascade.impactParameter0() << ", cut --> " << cuts[ptBin][7]; return false; // d0 of the v0 } @@ -165,7 +165,7 @@ struct HFLcK0spCandidateSelector { template bool validTPCPID(const T& track) { - if (TMath::Abs(track.pt()) < d_pidTPCMinpT || TMath::Abs(track.pt()) >= d_pidTPCMaxpT) { + if (TMath::Abs(track.pt()) < d_pidTPCMinPt || TMath::Abs(track.pt()) >= d_pidTPCMaxPt) { return false; } //if (track.TPCNClsFindable() < d_TPCNClsFindablePIDCut) return false; @@ -179,7 +179,7 @@ struct HFLcK0spCandidateSelector { template bool validCombPID(const T& track) { - if (TMath::Abs(track.pt()) > d_pidCombMaxp) { // is the pt sign used for the charge? If it is always positive, we should remove the abs + if (TMath::Abs(track.pt()) > d_pidCombMaxP) { // is the pt sign used for the charge? If it is always positive, we should remove the abs return false; } return true; @@ -196,7 +196,7 @@ struct HFLcK0spCandidateSelector { { double nSigma = 100.0; //arbitarily large value nSigma = track.tpcNSigmaPr(); - return nSigma > nSigmaCut; + return std::abs(nSigma) > nSigmaCut; } /* @@ -304,7 +304,7 @@ struct HFLcK0spCandidateSelector { // daughter track validity selection LOG(DEBUG) << "daughterSelection(bach) = " << daughterSelection(bach); if (!daughterSelection(bach)) { - hfSelLcK0spCandidate(statusLc); + hfSelLcK0sPCandidate(statusLc); continue; } @@ -312,7 +312,7 @@ struct HFLcK0spCandidateSelector { //need to add special cuts (additional cuts on decay length and d0 norm) LOG(DEBUG) << "selectionTopol(hfCandCasc) = " << selectionTopol(hfCandCasc); if (!selectionTopol(hfCandCasc)) { - hfSelLcK0spCandidate(statusLc); + hfSelLcK0sPCandidate(statusLc); continue; } @@ -324,7 +324,7 @@ struct HFLcK0spCandidateSelector { statusLc = 1; } - hfSelLcK0spCandidate(statusLc); + hfSelLcK0sPCandidate(statusLc); } } }; @@ -332,5 +332,5 @@ struct HFLcK0spCandidateSelector { WorkflowSpec defineDataProcessing(ConfigContext const&) { return WorkflowSpec{ - adaptAnalysisTask("hf-lck0sp-candidate-selector")}; + adaptAnalysisTask("hf-lc-tok0sp-candidate-selector")}; } diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index 807dc80089d41..599b21f91df1b 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -26,8 +26,6 @@ #include "AnalysisDataModel/StrangenessTables.h" #include "AnalysisDataModel/TrackSelectionTables.h" #include "ReconstructionDataFormats/V0.h" -#include "Framework/ASoAHelpers.h" -#include "Framework/AnalysisDataModel.h" #include @@ -65,11 +63,12 @@ struct SelectTracks { Configurable> cutsTrack3Prong{"cuts_singletrack_3prong", {hf_cuts_single_track::cutsTrack[0], npTBinsTrack, nCutVarsTrack, pTBinLabelsTrack, cutVarLabelsTrack}, "Single-track selections per pT bin for 3-prong candidates"}; Configurable etamax_3prong{"etamax_3prong", 4., "max. pseudorapidity for 3 prong candidate"}; // bachelor cuts (when using cascades) - Configurable ptmintrack_bach{"ptmintrack_bach", 0.3, "min. track pT for bachelor in cascade candidate"}; // 0.5 for PbPb 2015? - Configurable dcatoprimxy_maxpt_bach{"dcatoprimxy_maxpt_bach", 2., "max pt cut for min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; - Configurable dcatoprimxymin_bach{"dcatoprimxymin_bach", 0., "min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; // for PbPb 2018, the cut should be 0.0025 - Configurable dcatoprimxymax_bach{"dcatoprimxymax_bach", 1.0, "max. DCAXY to prim. vtx. for bachelor in cascade candidate"}; - Configurable etamax_bach{"etamax_bach", 0.8, "max. pseudorapidity for bachelor in cascade candidate"}; + Configurable d_ptMinTrackBach{"d_ptMinTrackBach", 0.3, "min. track pT for bachelor in cascade candidate"}; // 0.5 for PbPb 2015? + Configurable d_dcaToPrimXYMaxPtBach{"d_dcaToPrimXYMaxPtBach", 2., "max pt cut for min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; + Configurable d_dcaToPrimXYMinBach{"d_dcaToPrimXYMinBach", 0., "min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; // for PbPb 2018, the cut should be 0.0025 + Configurable d_dcaToPrimXYMaxBach{"d_dcaToPrimXYMaxBach", 1.0, "max. DCAXY to prim. vtx. for bachelor in cascade candidate"}; + Configurable d_etaMaxBach{"d_etaMaxBach", 0.8, "max. pseudorapidity for bachelor in cascade candidate"}; + HistogramRegistry registry{ "registry", {{"hpt_nocuts", "all tracks;#it{p}_{T}^{track} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, @@ -137,7 +136,7 @@ struct SelectTracks { if (trackPt < ptmintrack_3prong) { status_prong = status_prong & ~(1 << 1); } - if (track.pt() < ptmintrack_bach) { + if (track.pt() < d_ptMinTrackBach) { status_prong = status_prong & ~(1 << 2); } @@ -149,7 +148,7 @@ struct SelectTracks { if ((status_prong & (1 << 1)) && abs(trackEta) > etamax_3prong) { status_prong = status_prong & ~(1 << 1); } - if ((status_prong & (1 << 2)) && abs(track.eta()) > etamax_bach) { + if ((status_prong & (1 << 2)) && abs(track.eta()) > d_etaMaxBach) { status_prong = status_prong & ~(1 << 2); } @@ -166,7 +165,13 @@ struct SelectTracks { // DCA cut array dca; if (status_prong > 0) { +<<<<<<< HEAD double dcatoprimxymin_bach_ptdep = dcatoprimxymin_bach * TMath::Max(0., (1 - TMath::Floor(trackPt / dcatoprimxy_maxpt_bach))); +======= + double dcatoprimxymin_2prong_ptdep = dcatoprimxymin_2prong * TMath::Max(0., (1 - TMath::Floor(trackPt / dcatoprimxy_2prong_maxpt))); + double dcatoprimxymin_3prong_ptdep = dcatoprimxymin_3prong * TMath::Max(0., (1 - TMath::Floor(trackPt / dcatoprimxy_3prong_maxpt))); + double d_dcaToPrimXYMinBach_ptDep = d_dcaToPrimXYMinBach * TMath::Max(0., (1 - TMath::Floor(trackPt / d_dcaToPrimXYMaxPtBach))); +>>>>>>> Comments by Vit auto trackparvar0 = getTrackParCov(track); if (!trackparvar0.propagateParamToDCA(vtxXYZ, d_bz, &dca, 100.)) { // get impact parameters status_prong = 0; @@ -177,7 +182,7 @@ struct SelectTracks { if ((status_prong & (1 << 1)) && !isSelectedTrack(track, dca, Cand3Prong)) { status_prong = status_prong & ~(1 << 1); } - if ((status_prong & (1 << 2)) && (abs(dca[0]) < dcatoprimxymin_bach_ptdep || abs(dca[0]) > dcatoprimxymax_bach)) { + if ((status_prong & (1 << 2)) && (abs(dca[0]) < d_dcaToPrimXYMinBach_ptDep || abs(dca[0]) > d_dcaToPrimXYMaxBach)) { status_prong = status_prong & ~(1 << 2); } } @@ -207,226 +212,6 @@ struct SelectTracks { } }; -//________________________________________________________________________________________________________________________ - -/// Pre-selection of cascade secondary vertices -/// It will produce in any case a HfTrackIndexProng2 object, but mixing a V0 -/// with a track, instead of 2 tracks - -/// to run: o2-analysis-weak-decay-indices --aod-file AO2D.root -b | o2-analysis-lambdakzerobuilder -b | -/// o2-analysis-trackextension -b | o2-analysis-hf-track-index-skims-creator -b - -struct HFTrackIndexSkimsCreatorCascades { - Produces rowTrackIndexCasc; - // Produces rowTrackIndexCasc; - - // whether to do or not validation plots - Configurable b_dovalplots{"b_dovalplots", true, "fill histograms"}; - - // event selection - //Configurable triggerindex{"triggerindex", -1, "trigger index"}; - - // vertexing parameters - Configurable d_bz{"d_bz", 5., "magnetic field"}; - Configurable b_propdca{"b_propdca", true, "create tracks version propagated to PCA"}; - Configurable d_maxr{"d_maxr", 200., "reject PCA's above this radius"}; - Configurable d_maxdzini{"d_maxdzini", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; - Configurable d_minparamchange{"d_minparamchange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; - Configurable d_minrelchi2change{"d_minrelchi2change", 0.9, "stop iterations if chi2/chi2old > this"}; - Configurable d_UseAbsDCA{"d_UseAbsDCA", true, "Use Abs DCAs"}; - - // quality cut - Configurable doCutQuality{"doCutQuality", true, "apply quality cuts"}; - - // track cuts for V0 daughters - Configurable tpcrefit{"tpcrefit", true, "request TPC refit V0 daughters"}; - Configurable mincrossedrows{"mincrossedrows", 50, "min crossed rows V0 daughters"}; - Configurable etamax{"etamax", 1.1, "max. pseudorapidity V0 daughters"}; - Configurable ptmin{"ptmin", 0.05, "min. pT V0 daughters"}; - - // bachelor cuts - // Configurable dcabachtopv{"dcabachtopv", .1, "DCA Bach To PV"}; - // Configurable ptminbach{"ptminbach", -1., "min. track pT bachelor"}; - - // v0 cuts - Configurable cospaV0{"cospaV0", .995, "CosPA V0"}; // as in the task that create the V0s - Configurable dcaXYnegtopv{"dcaXYnegtopv", .1, "DCA_XY Neg To PV"}; // check: in HF Run 2, it was 0 at filtering - Configurable dcaXYpostopv{"dcaXYpostopv", .1, "DCA_XY Pos To PV"}; // check: in HF Run 2, it was 0 at filtering - Configurable cutInvMassV0{"cutInvMassV0", 0.05, "V0 candidate invariant mass difference wrt PDG"}; - - // cascade cuts - Configurable cutCascPtCandMin{"cutCascPtCandMin", -1., "min. pT of the 2-prong candidate"}; // PbPb 2018: use 1 - Configurable cutCascInvMassLc{"cutCascInvMassLc", 1., "Lc candidate invariant mass difference wrt PDG"}; // for PbPb 2018: use 0.2 - //Configurable cutCascDCADaughters{"cutCascDCADaughters", .1, "DCA between V0 and bachelor in cascade"}; - - // histograms - HistogramRegistry registry{ - "registry", - {{"hvtx2_x", "2-prong candidates;#it{x}_{sec. vtx.} (cm);entries", {HistType::kTH1F, {{1000, -2., 2.}}}}, - {"hvtx2_y", "2-prong candidates;#it{y}_{sec. vtx.} (cm);entries", {HistType::kTH1F, {{1000, -2., 2.}}}}, - {"hvtx2_z", "2-prong candidates;#it{z}_{sec. vtx.} (cm);entries", {HistType::kTH1F, {{1000, -20., 20.}}}}, - {"hmass2", "2-prong candidates;inv. mass (K0s p) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}}}; - - // NB: using FullTracks = soa::Join; defined in Framework/Core/include/Framework/AnalysisDataModel.h - using MyTracks = soa::Join; - //Partition selectedTracks = aod::hf_seltrack::isSelProng >= 4; - // using SelectedV0s = soa::Filtered; - double massP = RecoDecay::getMassPDG(kProton); - double massK0s = RecoDecay::getMassPDG(kK0Short); - double massPi = RecoDecay::getMassPDG(kPiPlus); - double massLc = RecoDecay::getMassPDG(4122); - double mass2K0sP{0.}; // WHY HERE? - // Filter filterV0s = aod::v0data::dcapostopv > dcapostopv && - // aod::v0data::dcanegtopv > dcanegtopv; // add here the cuts on the V0s - - using FullTracksExt = soa::Join; - - void process(aod::Collision const& collision, - aod::BCs const& bcs, - //soa::Filtered const& V0s, - aod::V0DataExt const& V0s, - MyTracks const& tracks) // TODO: I am now assuming that the V0s are already filtered with my cuts (David's work to come) - { - - //Define o2 fitter, 2-prong - o2::vertexing::DCAFitterN<2> fitter; - fitter.setBz(d_bz); - fitter.setPropagateToPCA(b_propdca); - fitter.setMaxR(d_maxr); - fitter.setMinParamChange(d_minparamchange); - fitter.setMinRelChi2Change(d_minrelchi2change); - //fitter.setMaxDZIni(1e9); // used in cascadeproducer.cxx, but not for the 2 prongs - //fitter.setMaxChi2(1e9); // used in cascadeproducer.cxx, but not for the 2 prongs - fitter.setUseAbsDCA(d_UseAbsDCA); - - // fist we loop over the bachelor candidate - - //for (const auto& bach : selectedTracks) { - for (const auto& bach : tracks) { - - // selections on the bachelor - // pT cut - if (bach.isSelProng() < 4) { - continue; - } - - if (tpcrefit) { - if (!(bach.trackType() & o2::aod::track::TPCrefit)) - continue; - } - if (bach.tpcNClsCrossedRows() < mincrossedrows) - continue; - - auto bachTrack = getTrackParCov(bach); - - // now we loop over the V0s - for (const auto& v0 : V0s) { - // selections on the V0 daughters - const auto& posTrack = v0.posTrack_as(); - const auto& negTrack = v0.negTrack_as(); - if (tpcrefit) { - if (!(posTrack.trackType() & o2::aod::track::TPCrefit) || - !(negTrack.trackType() & o2::aod::track::TPCrefit)) - continue; - } - if (posTrack.tpcNClsCrossedRows() < mincrossedrows || - negTrack.tpcNClsCrossedRows() < mincrossedrows) { - continue; - } - // - // if (posTrack.dcaXY() < dcapostopv || // to the filters? - // negTrack.dcaXY() < dcanegtopv) { - // continue; - // } - // - if (posTrack.pt() < ptmin || // to the filters? I can't for now, it is not in the tables - negTrack.pt() < ptmin) { - continue; - } - if (abs(posTrack.eta()) > etamax || // to the filters? I can't for now, it is not in the tables - abs(negTrack.eta()) > etamax) { - continue; - } - - // V0 invariant mass selection - if (std::abs(v0.mK0Short() - massK0s) > cutInvMassV0) - continue; // should go to the filter, but since it is a dynamic column, I cannot use it there - - // V0 cosPointingAngle selection - if (v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < cospaV0) - continue; - - auto posTrackParCov = getTrackParCov(posTrack); - posTrackParCov.propagateTo(v0.posX(), d_bz); // propagate the track to the X closest to the V0 vertex - auto negTrackParCov = getTrackParCov(negTrack); - negTrackParCov.propagateTo(v0.negX(), d_bz); // propagate the track to the X closest to the V0 vertex - std::array pvecv0 = {0., 0., 0.}; - std::array pvecbach = {0., 0., 0.}; - - const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; - const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; - - // we build the neutral track to then build the cascade - auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track - - // now we find the DCA between the V0 and the bachelor, for the cascade - int nCand2 = fitter.process(trackV0, bachTrack); - - std::array pVecCandCasc = {0., 0., 0.}; - if (nCand2 != 0) { - fitter.propagateTracksToVertex(); // propagate the bach and V0 to the Lc vertex - fitter.getTrack(0).getPxPyPzGlo(pvecv0); // take the momentum at the Lc vertex - fitter.getTrack(1).getPxPyPzGlo(pvecbach); - - // HF code for the 2 prongs would use: - //auto pVecCandCasc = array{bachTrack.px() + trackV0.px(), - // bachTrack.py() + trackV0.py(), - // bachTrack.pz() + trackV0.pz()}; - // but I think this is equivalent, and I understand it better where it comes from - pVecCandCasc = array{pvecbach[0] + pvecv0[0], - pvecbach[1] + pvecv0[1], - pvecbach[2] + pvecv0[2]}; - - // cascade candidate pT cut - if (RecoDecay::Pt(pVecCandCasc) < cutCascPtCandMin) { - continue; - } - - // invariant mass - // calculate invariant masses - auto arrMom = array{pvecbach, pvecv0}; - mass2K0sP = RecoDecay::M(arrMom, array{massP, massK0s}); - // invariant-mass cut - if (cutCascInvMassLc >= 0.) { - if (std::abs(mass2K0sP - massLc) < cutCascInvMassLc) { - continue; - } - } - std::array posCasc = {0., 0., 0.}; - const auto& cascvtx = fitter.getPCACandidate(); - for (int i = 0; i < 3; i++) { - posCasc[i] = cascvtx[i]; - } - - // fill table row - rowTrackIndexCasc(v0.globalIndex(), - bach.globalIndex(), - 1); // 1 should be the value for the Lc - // fill histograms - if (b_dovalplots) { - registry.get(HIST("hvtx2_x"))->Fill(posCasc[0]); - registry.get(HIST("hvtx2_y"))->Fill(posCasc[1]); - registry.get(HIST("hvtx2_z"))->Fill(posCasc[2]); - registry.get(HIST("hmass2"))->Fill(mass2K0sP); - } - - } // we could build the cascade - } // loop over V0s - - } // loop over tracks - } // process -}; - //____________________________________________________________________________________________________________________________________________ /// Pre-selection of 2-prong and 3-prong secondary vertices @@ -474,7 +259,7 @@ struct HFTrackIndexSkimsCreator { {"hmassDsToPiKK", "D_{s} candidates;inv. mass (K K #pi) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}, {"hmassXicToPKPi", "#Xi_{c} candidates;inv. mass (p K #pi) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}}}; - Filter filterSelectTracks = (aod::hf_seltrack::isSelProng > 0 || aod::hf_seltrack::isSelProng < 4); + Filter filterSelectTracks = (aod::hf_seltrack::isSelProng > 0 && aod::hf_seltrack::isSelProng < 4); using SelectedTracks = soa::Filtered>; // FIXME @@ -1160,6 +945,230 @@ struct HFTrackIndexSkimsCreator { } }; +//________________________________________________________________________________________________________________________ + +/// Pre-selection of cascade secondary vertices +/// It will produce in any case a HfTrackIndexProng2 object, but mixing a V0 +/// with a track, instead of 2 tracks + +/// to run: o2-analysis-weak-decay-indices --aod-file AO2D.root -b | o2-analysis-lambdakzerobuilder -b | +/// o2-analysis-trackextension -b | o2-analysis-hf-track-index-skims-creator -b + +struct HFTrackIndexSkimsCreatorCascades { + Produces rowTrackIndexCasc; + // Produces rowTrackIndexCasc; + + // whether to do or not validation plots + Configurable b_doValPlots{"b_doValPlots", true, "fill histograms"}; + + // event selection + //Configurable triggerindex{"triggerindex", -1, "trigger index"}; + + // vertexing parameters + Configurable d_bZ{"d_bZ", 5., "magnetic field"}; + Configurable b_propDCA{"b_propDCA", true, "create tracks version propagated to PCA"}; + Configurable d_maxR{"d_maxR", 200., "reject PCA's above this radius"}; + Configurable d_maxDZIni{"d_maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; + Configurable d_minParamChange{"d_minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable d_minRelChi2Change{"d_minRelChi2Change", 0.9, "stop iterations if chi2/chi2old > this"}; + Configurable d_UseAbsDCA{"d_UseAbsDCA", true, "Use Abs DCAs"}; + + // quality cut + Configurable doCutQuality{"doCutQuality", true, "apply quality cuts"}; + + // track cuts for V0 daughters + Configurable b_TPCRefit{"b_TPCRefit", true, "request TPC refit V0 daughters"}; + Configurable i_minCrossedRows{"i_minCrossedRows", 50, "min crossed rows V0 daughters"}; + Configurable d_etaMax{"d_etaMax", 1.1, "max. pseudorapidity V0 daughters"}; + Configurable d_ptMin{"d_ptMin", 0.05, "min. pT V0 daughters"}; + + // bachelor cuts + // Configurable dcabachtopv{"dcabachtopv", .1, "DCA Bach To PV"}; + // Configurable ptminbach{"ptminbach", -1., "min. track pT bachelor"}; + + // v0 cuts + Configurable d_cosPAV0{"d_cosPAV0", .995, "CosPA V0"}; // as in the task that create the V0s + Configurable d_dcaXYNegToPV{"d_dcaXYNegToPV", .1, "DCA_XY Neg To PV"}; // check: in HF Run 2, it was 0 at filtering + Configurable d_dcaXYPosToPV{"d_dcaXYPosToPVS", .1, "DCA_XY Pos To PV"}; // check: in HF Run 2, it was 0 at filtering + Configurable d_cutInvMassV0{"d_cutInvMassV0", 0.05, "V0 candidate invariant mass difference wrt PDG"}; + + // cascade cuts + Configurable d_cutCascPtCandMin{"d_cutCascPtCandMin", -1., "min. pT of the 2-prong candidate"}; // PbPb 2018: use 1 + Configurable d_cutCascInvMassLc{"d_cutCascInvMassLc", 1., "Lc candidate invariant mass difference wrt PDG"}; // for PbPb 2018: use 0.2 + //Configurable cutCascDCADaughters{"cutCascDCADaughters", .1, "DCA between V0 and bachelor in cascade"}; + + // histograms + HistogramRegistry registry{ + "registry", + {{"hvtx2_x", "2-prong candidates;#it{x}_{sec. vtx.} (cm);entries", {HistType::kTH1F, {{1000, -2., 2.}}}}, + {"hvtx2_y", "2-prong candidates;#it{y}_{sec. vtx.} (cm);entries", {HistType::kTH1F, {{1000, -2., 2.}}}}, + {"hvtx2_z", "2-prong candidates;#it{z}_{sec. vtx.} (cm);entries", {HistType::kTH1F, {{1000, -20., 20.}}}}, + {"hmass2", "2-prong candidates;inv. mass (K0s p) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}}}; + + // NB: using FullTracks = soa::Join; defined in Framework/Core/include/Framework/AnalysisDataModel.h + using MyTracks = soa::Join; + //Partition selectedTracks = aod::hf_seltrack::isSelProng >= 4; + // using SelectedV0s = soa::Filtered; + + double massP = RecoDecay::getMassPDG(kProton); + double massK0s = RecoDecay::getMassPDG(kK0Short); + double massPi = RecoDecay::getMassPDG(kPiPlus); + double massLc = RecoDecay::getMassPDG(4122); + double mass2K0sP{0.}; // WHY HERE? + + // Filter filterV0s = aod::v0data::dcapostopv > dcapostopv && + // aod::v0data::dcanegtopv > dcanegtopv; // add here the cuts on the V0s + + using FullTracksExt = soa::Join; + + void process(aod::Collision const& collision, + aod::BCs const& bcs, + //soa::Filtered const& V0s, + aod::V0DataExt const& V0s, + MyTracks const& tracks) // TODO: I am now assuming that the V0s are already filtered with my cuts (David's work to come) + { + + //Define o2 fitter, 2-prong + o2::vertexing::DCAFitterN<2> fitter; + fitter.setBz(d_bZ); + fitter.setPropagateToPCA(b_propDCA); + fitter.setMaxR(d_maxR); + fitter.setMinParamChange(d_minParamChange); + fitter.setMinRelChi2Change(d_minRelChi2Change); + //fitter.setMaxDZIni(1e9); // used in cascadeproducer.cxx, but not for the 2 prongs + //fitter.setMaxChi2(1e9); // used in cascadeproducer.cxx, but not for the 2 prongs + fitter.setUseAbsDCA(d_UseAbsDCA); + + // fist we loop over the bachelor candidate + + //for (const auto& bach : selectedTracks) { + for (const auto& bach : tracks) { + + // selections on the bachelor + // pT cut + if (bach.isSelProng() < 4) { + continue; + } + + if (b_TPCRefit) { + if (!(bach.trackType() & o2::aod::track::TPCrefit)) { + continue; + } + } + if (bach.tpcNClsCrossedRows() < i_minCrossedRows) { + continue; + } + + auto bachTrack = getTrackParCov(bach); + + // now we loop over the V0s + for (const auto& v0 : V0s) { + // selections on the V0 daughters + const auto& posTrack = v0.posTrack_as(); + const auto& negTrack = v0.negTrack_as(); + if (b_TPCRefit) { + if (!(posTrack.trackType() & o2::aod::track::TPCrefit) || + !(negTrack.trackType() & o2::aod::track::TPCrefit)) { + continue; + } + } + if (posTrack.tpcNClsCrossedRows() < i_minCrossedRows || + negTrack.tpcNClsCrossedRows() < i_minCrossedRows) { + continue; + } + // + // if (posTrack.dcaXY() < d_dcaXYPosToPV || // to the filters? + // negTrack.dcaXY() < d_dcaXYNegToPV) { + // continue; + // } + // + if (posTrack.pt() < d_ptMin || // to the filters? I can't for now, it is not in the tables + negTrack.pt() < d_ptMin) { + continue; + } + if (abs(posTrack.eta()) > d_etaMax || // to the filters? I can't for now, it is not in the tables + abs(negTrack.eta()) > d_etaMax) { + continue; + } + + // V0 invariant mass selection + if (std::abs(v0.mK0Short() - massK0s) > d_cutInvMassV0) { + continue; // should go to the filter, but since it is a dynamic column, I cannot use it there + } + + // V0 cosPointingAngle selection + if (v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < d_cosPAV0) { + continue; + } + + auto posTrackParCov = getTrackParCov(posTrack); + posTrackParCov.propagateTo(v0.posX(), d_bZ); // propagate the track to the X closest to the V0 vertex + auto negTrackParCov = getTrackParCov(negTrack); + negTrackParCov.propagateTo(v0.negX(), d_bZ); // propagate the track to the X closest to the V0 vertex + std::array pVecV0 = {0., 0., 0.}; + std::array pVecBach = {0., 0., 0.}; + + const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; + const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; + + // we build the neutral track to then build the cascade + auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track + + // now we find the DCA between the V0 and the bachelor, for the cascade + int nCand2 = fitter.process(trackV0, bachTrack); + if (nCand2 == 0) { + continue; + } + + std::array pVecCandCasc = {0., 0., 0.}; + fitter.propagateTracksToVertex(); // propagate the bach and V0 to the Lc vertex + fitter.getTrack(0).getPxPyPzGlo(pVecV0); // take the momentum at the Lc vertex + fitter.getTrack(1).getPxPyPzGlo(pVecBach); + + pVecCandCasc = array{pVecBach[0] + pVecV0[0], + pVecBach[1] + pVecV0[1], + pVecBach[2] + pVecV0[2]}; + + // cascade candidate pT cut + if (RecoDecay::Pt(pVecCandCasc) < d_cutCascPtCandMin) { + continue; + } + + // invariant mass + // calculate invariant masses + auto arrMom = array{pVecBach, pVecV0}; + mass2K0sP = RecoDecay::M(arrMom, array{massP, massK0s}); + // invariant-mass cut + if ((d_cutCascInvMassLc >= 0.) && (std::abs(mass2K0sP - massLc) < d_cutCascInvMassLc)) { + continue; + } + + std::array posCasc = {0., 0., 0.}; + const auto& cascVtx = fitter.getPCACandidate(); + for (int i = 0; i < 3; i++) { + posCasc[i] = cascVtx[i]; + } + + // fill table row + rowTrackIndexCasc(v0.globalIndex(), + bach.globalIndex(), + 1); // 1 should be the value for the Lc + // fill histograms + if (b_doValPlots) { + registry.get(HIST("hvtx2_x"))->Fill(posCasc[0]); + registry.get(HIST("hvtx2_y"))->Fill(posCasc[1]); + registry.get(HIST("hvtx2_z"))->Fill(posCasc[2]); + registry.get(HIST("hmass2"))->Fill(mass2K0sP); + } + + } // loop over V0s + + } // loop over tracks + } // process +}; + +//________________________________________________________________________________________________________________________ + WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ diff --git a/Analysis/Tasks/PWGHF/taskLcK0sp.cxx b/Analysis/Tasks/PWGHF/taskLcK0sP.cxx similarity index 97% rename from Analysis/Tasks/PWGHF/taskLcK0sp.cxx rename to Analysis/Tasks/PWGHF/taskLcK0sP.cxx index 3eda4370021b0..defa602e9f3ca 100644 --- a/Analysis/Tasks/PWGHF/taskLcK0sp.cxx +++ b/Analysis/Tasks/PWGHF/taskLcK0sP.cxx @@ -34,7 +34,7 @@ void customize(std::vector& workflowOptions) #include "Framework/runDataProcessing.h" /// LcK0sp analysis task -struct TaskLcK0sp { +struct TaskLcK0sP { HistogramRegistry registry{ "registry", {{"hmass", "cascade candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}, @@ -51,9 +51,9 @@ struct TaskLcK0sp { Configurable d_selectionFlagLcK0sp{"d_selectionFlagLcK0sp", 1, "Selection Flag for LcK0sp"}; Configurable cutEtaCandMax{"cutEtaCandMax", -1., "max. cand. pseudorapidity"}; - Filter filterSelectCandidates = (aod::hf_selcandidate_lc_k0sp::isSelLcK0sp >= d_selectionFlagLcK0sp); + Filter filterSelectCandidates = (aod::hf_selcandidate_lc_k0sp::isSelLcK0sP >= d_selectionFlagLcK0sp); - void process(soa::Filtered> const& candidates) + void process(soa::Filtered> const& candidates) { //Printf("Candidates: %d", candidates.size()); for (auto& candidate : candidates) { @@ -67,7 +67,7 @@ struct TaskLcK0sp { //Printf("Candidate: eta rejection: %g", candidate.eta()); continue; } - registry.fill(HIST("hmass"), InvMassLc(candidate)); + registry.fill(HIST("hmass"), InvMassLcToK0sP(candidate)); registry.fill(HIST("hptcand"), candidate.pt()); registry.fill(HIST("hptv0"), candidate.ptProng0()); registry.fill(HIST("hptbach"), candidate.ptProng1()); @@ -76,7 +76,7 @@ struct TaskLcK0sp { registry.fill(HIST("hd0v0neg"), candidate.dcanegtopv()); registry.fill(HIST("hv0CPA"), candidate.v0cosPA()); registry.fill(HIST("hEta"), candidate.eta()); - registry.fill(HIST("hselectionstatus"), candidate.isSelLcK0sp()); + registry.fill(HIST("hselectionstatus"), candidate.isSelLcK0sP()); } } }; @@ -146,7 +146,7 @@ struct TaskD0MC { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { WorkflowSpec workflow{ - adaptAnalysisTask("hf-task-lck0sp")}; + adaptAnalysisTask("hf-task-lc-tok0sP")}; const bool doMC = cfgc.options().get("doMC"); /* if (doMC) { From 836af2c70c081fbcabdd4dce32416a5f09bbf65f Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Tue, 23 Feb 2021 16:51:08 +0100 Subject: [PATCH 06/14] Adding pT V0 daugh, and swapping V0 and bach (as in AliPhysics) clang --- .../AnalysisDataModel/HFSecondaryVertex.h | 24 +++++-- .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 65 +++++++++++++------ .../Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx | 21 +++--- .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 4 +- Analysis/Tasks/PWGHF/taskLcK0sP.cxx | 27 ++++---- 5 files changed, 93 insertions(+), 48 deletions(-) diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h index b83318143fd03..ba541881af0db 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h @@ -71,9 +71,9 @@ DECLARE_SOA_TABLE(HfTrackIndexProng2, "AOD", "HFTRACKIDXP2", //! hf_track_index::Index1Id, hf_track_index::HFflag); - DECLARE_SOA_TABLE(HfTrackIndexCasc, "AOD", "HFTRACKIDXCASC", //! - hf_track_index::IndexV0Id, + DECLARE_SOA_TABLE(HfTrackIndexCasc, "AOD", "HFTRACKIDXCASC", //! hf_track_index::Index0Id, + hf_track_index::IndexV0Id, hf_track_index::HFflag); DECLARE_SOA_TABLE(HfCutStatusProng2, "AOD", "HFCUTSTATUSP2", //! @@ -372,7 +372,9 @@ namespace hf_cand_casc DECLARE_SOA_EXPRESSION_COLUMN(Px, px, float, 1.f * aod::hf_cand::pxProng0 + 1.f * aod::hf_cand::pxProng1); DECLARE_SOA_EXPRESSION_COLUMN(Py, py, float, 1.f * aod::hf_cand::pyProng0 + 1.f * aod::hf_cand::pyProng1); DECLARE_SOA_EXPRESSION_COLUMN(Pz, pz, float, 1.f * aod::hf_cand::pzProng0 + 1.f * aod::hf_cand::pzProng1); -DECLARE_SOA_DYNAMIC_COLUMN(M, m, [](float px0, float py0, float pz0, float px1, float py1, float pz1, const array& m) { return RecoDecay::M(array{array{px0, py0, pz0}, array{px1, py1, pz1}}, m); }); +//DECLARE_SOA_DYNAMIC_COLUMN(M, m, [](float px0, float py0, float pz0, float px1, float py1, float pz1, const array& m) { return RecoDecay::M(array{array{px0, py0, pz0}, array{px1, py1, pz1}}, m); }); +DECLARE_SOA_DYNAMIC_COLUMN(PtV0Pos, ptV0Pos, [](float px, float py) { return RecoDecay::Pt(px, py); }); +DECLARE_SOA_DYNAMIC_COLUMN(PtV0Neg, ptV0Neg, [](float px, float py) { return RecoDecay::Pt(px, py); }); template auto InvMassLcToK0sP(const T& candidate) @@ -396,11 +398,12 @@ DECLARE_SOA_TABLE(HfCandCascBase, "AOD", "HFCANDCASCBASE", hf_cand::PxProng1, hf_cand::PyProng1, hf_cand::PzProng1, hf_cand::ImpactParameter0, hf_cand::ImpactParameter1, hf_cand::ErrorImpactParameter0, hf_cand::ErrorImpactParameter1, - hf_track_index::IndexV0Id, // V0 index hf_track_index::Index0Id, + hf_track_index::IndexV0Id, // V0 index hf_track_index::HFflag, // V0 v0data::X, v0data::Y, v0data::Z, + v0data::PosTrackId, v0data::NegTrackId, // indices of V0 tracks in FullTracks table v0data::PxPos, v0data::PyPos, v0data::PzPos, v0data::PxNeg, v0data::PyNeg, v0data::PzNeg, v0data::DCAV0Daughters, v0data::DCAPosToPV, // this is the impact param wrt prim vtx in xy! @@ -428,8 +431,10 @@ DECLARE_SOA_TABLE(HfCandCascBase, "AOD", "HFCANDCASCBASE", hf_cand::E, hf_cand::E2, // dynamic columns from V0 + hf_cand_casc::PtV0Pos, // pT of positive V0 daughter + hf_cand_casc::PtV0Neg, // pT of negative V0 daughter v0data::V0Radius, - v0data::V0CosPA, + v0data::V0CosPA, v0data::MLambda, v0data::MAntiLambda, v0data::MK0Short); @@ -444,6 +449,15 @@ DECLARE_SOA_EXTENDED_TABLE_USER(HfCandCascExt, HfCandCascBase, "HFCANDCASCEXT", using HfCandCascade = HfCandCascExt; +/* +// table with results of reconstruction level MC matching for Cascade +DECLARE_SOA_TABLE(HfCandCascadeMCRec, "AOD", "HFCANDCASCMCREC", + hf_cand_prong2::FlagMCMatchRec); + +// table with results of generator level MC matching +DECLARE_SOA_TABLE(HfCandCascadeMCGen, "AOD", "HFCANDCASCMCGEN", + hf_cand_prong2::FlagMCMatchGen); +*/ // specific 3-prong decay properties namespace hf_cand_prong3 { diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index f7a1031774ba5..49bccea317791 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -120,18 +120,23 @@ struct HFCandidateCreatorCascade { auto errorDecayLength = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, theta) + getRotatedCovMatrixXX(covMatrixPCA, phi, theta)); auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixPCA, phi, 0.)); + LOG(INFO) << "v0.dcapostopv() = " << v0.dcapostopv(); + LOG(INFO) << "v0.dcanegtopv() = " << v0.dcanegtopv(); + LOG(INFO) << "v0.cosPA() = " << v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()); + // fill candidate table rows rowCandidateBase(collision.posX(), collision.posY(), collision.posZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], errorDecayLength, errorDecayLengthXY, chi2PCA, - pVecV0[0], pVecV0[1], pVecV0[2], pVecBach[0], pVecBach[1], pVecBach[2], - impactParameterV0.getY(), impactParameterBach.getY(), - std::sqrt(impactParameterV0.getSigmaY2()), std::sqrt(impactParameterBach.getSigmaY2()), - casc.indexV0Id(), casc.index0Id(), + pVecV0[0], pVecV0[1], pVecV0[2], + impactParameterBach.getY(), impactParameterV0.getY(), + std::sqrt(impactParameterBach.getSigmaY2()), std::sqrt(impactParameterV0.getSigmaY2()), + casc.index0Id(), casc.indexV0Id(), casc.hfflag(), v0.x(), v0.y(), v0.z(), + v0.posTrack(), v0.negTrack(), v0.pxpos(), v0.pypos(), v0.pzpos(), v0.pxneg(), v0.pyneg(), v0.pzneg(), v0.dcaV0daughters(), @@ -141,8 +146,8 @@ struct HFCandidateCreatorCascade { // fill histograms if (b_doValPlots) { // calculate invariant masses - auto arrayMomenta = array{pVecV0, pVecBach}; - mass2K0sP = RecoDecay::M(arrayMomenta, array{massK0s, massP}); + auto arrayMomenta = array{pVecBach, pVecV0}; + mass2K0sP = RecoDecay::M(arrayMomenta, array{massP, massK0s}); hmass2->Fill(mass2K0sP); } } @@ -154,50 +159,70 @@ struct HFCandidateCreatorCascadeExpressions { Spawns rowCandidateCasc; void init(InitContext const&) {} }; + +//___________________________________________________________________________________________ /* /// Performs MC matching. -struct HFCandidateCreator2ProngMC { - Produces rowMCMatchRec; - Produces rowMCMatchGen; +struct HFCandidateCreatorCascadeMC { + Produces rowMCMatchRec; + Produces rowMCMatchGen; - void process(aod::HfCandProng2 const& candidates, + void process(aod::HfCandCascade const& candidates, aod::BigTracksMC const& tracks, aod::McParticles const& particlesMC) { int8_t sign = 0; - int8_t result = N2ProngDecays; + int8_t flag = 0; // Match reconstructed candidates. for (auto& candidate : candidates) { //Printf("New rec. candidate"); - result = N2ProngDecays; - auto arrayDaughters = array{candidate.index0_as(), candidate.index1_as()}; + flag = 0; + auto arrayDaughtersV0 = array{candidate.posTrack_as(), candidate.negTrack_as()}; - // D0(bar) → π± K∓ + // K0S --> pi+pi- //Printf("Checking D0(bar) → π± K∓"); - if (RecoDecay::getMatchedMCRec(particlesMC, std::move(arrayDaughters), 421, array{+kPiPlus, -kKPlus}, true, &sign) > -1) { - result = sign * D0ToPiK; + if (RecoDecay::getMatchedMCRec(particlesMC, arrayDaughters, 421, array{+kPiPlus, -kKPlus}, true, &sign) > -1) { + flag = sign * (1 << D0ToPiK); } - rowMCMatchRec(result); + // J/ψ → e+ e- + if (flag == 0) { + //Printf("Checking J/ψ → e+ e-"); + if (RecoDecay::getMatchedMCRec(particlesMC, std::move(arrayDaughters), 443, array{+kElectron, -kElectron}, true) > -1) { + flag = 1 << JpsiToEE; + } + } + + rowMCMatchRec(flag); } // Match generated particles. for (auto& particle : particlesMC) { //Printf("New gen. candidate"); - result = N2ProngDecays; + flag = 0; // D0(bar) → π± K∓ //Printf("Checking D0(bar) → π± K∓"); if (RecoDecay::isMatchedMCGen(particlesMC, particle, 421, array{+kPiPlus, -kKPlus}, true, &sign)) { - result = sign * D0ToPiK; + flag = sign * (1 << D0ToPiK); } - rowMCMatchGen(result); + // J/ψ → e+ e- + if (flag == 0) { + //Printf("Checking J/ψ → e+ e-"); + if (RecoDecay::isMatchedMCGen(particlesMC, particle, 443, array{+kElectron, -kElectron}, true)) { + flag = 1 << JpsiToEE; + } + } + + rowMCMatchGen(flag); } } }; */ +//____________________________________________________________________ + WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { WorkflowSpec workflow{ diff --git a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx index 4330f063f5134..4f75062dca9bf 100644 --- a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx +++ b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx @@ -124,13 +124,18 @@ struct HFLcK0sPCandidateSelector { } if (hfCandCascade.ptProng0() < cuts[ptBin][3]) { - LOG(DEBUG) << "v0 pt cut failed, from cascade --> " << hfCandCascade.ptProng0() << ", cut --> " << cuts[ptBin][3]; + LOG(DEBUG) << "bach pt cut failed, from cascade --> " << hfCandCascade.ptProng0() << " , cut --> " << cuts[ptBin][3]; + return false; // pt of the p + } + + if (hfCandCascade.ptV0Pos() < cuts[ptBin][4]) { + LOG(DEBUG) << "v0 pos daugh pt cut failed, from cascade --> " << hfCandCascade.ptV0Pos() << ", cut --> " << cuts[ptBin][4]; return false; // pt of the K0 } - if (hfCandCascade.ptProng1() < cuts[ptBin][4]) { - LOG(DEBUG) << "bach pt cut failed, from cascade --> " << hfCandCascade.ptProng1() << " , cut --> " << cuts[ptBin][4]; - return false; // pt of the p + if (hfCandCascade.ptV0Neg() < cuts[ptBin][4]) { + LOG(DEBUG) << "v0 neg daugh pt cut failed, from cascade --> " << hfCandCascade.ptV0Neg() << ", cut --> " << cuts[ptBin][4]; + return false; // pt of the K0 } if (hfCandCascade.pt() < cuts[ptBin][5]) { @@ -138,8 +143,8 @@ struct HFLcK0sPCandidateSelector { return false; // pt of the Lc } - if (std::abs(hfCandCascade.impactParameter1()) > cuts[ptBin][6]) { - LOG(DEBUG) << "d0 bach cut failed, in cascade --> " << hfCandCascade.impactParameter1() << ", cut --> " << cuts[ptBin][6]; + if (std::abs(hfCandCascade.impactParameter0()) > cuts[ptBin][6]) { + LOG(DEBUG) << "d0 bach cut failed, in cascade --> " << hfCandCascade.impactParameter0() << ", cut --> " << cuts[ptBin][6]; return false; // d0 of the bachelor } @@ -150,8 +155,8 @@ struct HFLcK0sPCandidateSelector { } */ - if (std::abs(hfCandCascade.impactParameter0()) > cuts[ptBin][6]) { - LOG(DEBUG) << "d0 v0 cut failed, in cascade --> " << hfCandCascade.impactParameter0() << ", cut --> " << cuts[ptBin][7]; + if (std::abs(hfCandCascade.impactParameter1()) > cuts[ptBin][6]) { + LOG(DEBUG) << "d0 v0 cut failed, in cascade --> " << hfCandCascade.impactParameter1() << ", cut --> " << cuts[ptBin][7]; return false; // d0 of the v0 } diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index 599b21f91df1b..0c019bf042e43 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -1150,8 +1150,8 @@ struct HFTrackIndexSkimsCreatorCascades { } // fill table row - rowTrackIndexCasc(v0.globalIndex(), - bach.globalIndex(), + rowTrackIndexCasc(bach.globalIndex(), + v0.globalIndex(), 1); // 1 should be the value for the Lc // fill histograms if (b_doValPlots) { diff --git a/Analysis/Tasks/PWGHF/taskLcK0sP.cxx b/Analysis/Tasks/PWGHF/taskLcK0sP.cxx index defa602e9f3ca..a10813c169a90 100644 --- a/Analysis/Tasks/PWGHF/taskLcK0sP.cxx +++ b/Analysis/Tasks/PWGHF/taskLcK0sP.cxx @@ -37,16 +37,16 @@ void customize(std::vector& workflowOptions) struct TaskLcK0sP { HistogramRegistry registry{ "registry", - {{"hmass", "cascade candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}, - {"hptcand", "cascade candidates;candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, - {"hptv0", "cascade candidates;v0 #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, - {"hptbach", "cascade candidates;bachelor #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, - {"hd0bach", "cascade candidates;bachelor DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -1., 1.}}}}, - {"hd0v0pos", "cascade candidates;pos daugh v0 DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -1., 1.}}}}, - {"hd0v0neg", "cascade candidates;neg daugh v0 DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -1., 1.}}}}, - {"hv0CPA", "cascade candidates;v0 cosine of pointing angle;entries", {HistType::kTH1F, {{110, 0.998, 1.1}}}}, - {"hEta", "cascade candidates;candidate #it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}, - {"hselectionstatus", "cascade candidates;selection status;entries", {HistType::kTH1F, {{5, -0.5, 4.5}}}}}}; + {{"hmass", "cascade candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0.0f, 5.0f}}}}, + {"hptcand", "cascade candidates;candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}}, + {"hptbach", "cascade candidates;bachelor #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}}, + {"hptv0", "cascade candidates;v0 #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}}, + {"hd0bach", "cascade candidates;bachelor DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -1.0f, 1.0f}}}}, + {"hd0v0pos", "cascade candidates;pos daugh v0 DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -5.0f, 5.0f}}}}, + {"hd0v0neg", "cascade candidates;neg daugh v0 DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -5.0f, 5.0f}}}}, + {"hv0CPA", "cascade candidates;v0 cosine of pointing angle;entries", {HistType::kTH1F, {{110, -0.98f, 1.1f}}}}, + {"hEta", "cascade candidates;candidate #it{#eta};entries", {HistType::kTH1F, {{100, -2.0f, 2.0f}}}}, + {"hselectionstatus", "cascade candidates;selection status;entries", {HistType::kTH1F, {{5, -0.5f, 4.5f}}}}}}; Configurable d_selectionFlagLcK0sp{"d_selectionFlagLcK0sp", 1, "Selection Flag for LcK0sp"}; Configurable cutEtaCandMax{"cutEtaCandMax", -1., "max. cand. pseudorapidity"}; @@ -67,11 +67,12 @@ struct TaskLcK0sP { //Printf("Candidate: eta rejection: %g", candidate.eta()); continue; } + registry.fill(HIST("hmass"), InvMassLcToK0sP(candidate)); registry.fill(HIST("hptcand"), candidate.pt()); - registry.fill(HIST("hptv0"), candidate.ptProng0()); - registry.fill(HIST("hptbach"), candidate.ptProng1()); - registry.fill(HIST("hd0bach"), candidate.impactParameter1()); + registry.fill(HIST("hptbach"), candidate.ptProng0()); + registry.fill(HIST("hptv0"), candidate.ptProng1()); + registry.fill(HIST("hd0bach"), candidate.impactParameter0()); registry.fill(HIST("hd0v0pos"), candidate.dcapostopv()); registry.fill(HIST("hd0v0neg"), candidate.dcanegtopv()); registry.fill(HIST("hv0CPA"), candidate.v0cosPA()); From 36553dafcdd0c1815869e1c036e1fa66d416de2b Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Thu, 25 Feb 2021 01:04:56 +0100 Subject: [PATCH 07/14] First version using MC info. To be investigated: - why no V0 in the V0 table is a K0s that comes from a Lc? - the RecoDecay::isMatchedMCGen might need some adjustments, being checked Fixes Format --- .../AnalysisDataModel/HFSecondaryVertex.h | 9 +-- .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 65 ++++++------------- .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 32 ++++++++- 3 files changed, 56 insertions(+), 50 deletions(-) diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h index ba541881af0db..3cd428ee04ee8 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h @@ -375,6 +375,8 @@ DECLARE_SOA_EXPRESSION_COLUMN(Pz, pz, float, 1.f * aod::hf_cand::pzProng0 + 1.f //DECLARE_SOA_DYNAMIC_COLUMN(M, m, [](float px0, float py0, float pz0, float px1, float py1, float pz1, const array& m) { return RecoDecay::M(array{array{px0, py0, pz0}, array{px1, py1, pz1}}, m); }); DECLARE_SOA_DYNAMIC_COLUMN(PtV0Pos, ptV0Pos, [](float px, float py) { return RecoDecay::Pt(px, py); }); DECLARE_SOA_DYNAMIC_COLUMN(PtV0Neg, ptV0Neg, [](float px, float py) { return RecoDecay::Pt(px, py); }); +DECLARE_SOA_COLUMN(FlagMCMatchRec, flagMCMatchRec, int8_t); // reconstruction level +DECLARE_SOA_COLUMN(FlagMCMatchGen, flagMCMatchGen, int8_t); // generator level template auto InvMassLcToK0sP(const T& candidate) @@ -449,15 +451,14 @@ DECLARE_SOA_EXTENDED_TABLE_USER(HfCandCascExt, HfCandCascBase, "HFCANDCASCEXT", using HfCandCascade = HfCandCascExt; -/* // table with results of reconstruction level MC matching for Cascade DECLARE_SOA_TABLE(HfCandCascadeMCRec, "AOD", "HFCANDCASCMCREC", - hf_cand_prong2::FlagMCMatchRec); + hf_cand_casc::FlagMCMatchRec); // table with results of generator level MC matching DECLARE_SOA_TABLE(HfCandCascadeMCGen, "AOD", "HFCANDCASCMCGEN", - hf_cand_prong2::FlagMCMatchGen); -*/ + hf_cand_casc::FlagMCMatchGen); + // specific 3-prong decay properties namespace hf_cand_prong3 { diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index 49bccea317791..3882e472f892b 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -120,10 +120,6 @@ struct HFCandidateCreatorCascade { auto errorDecayLength = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, theta) + getRotatedCovMatrixXX(covMatrixPCA, phi, theta)); auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixPCA, phi, 0.)); - LOG(INFO) << "v0.dcapostopv() = " << v0.dcapostopv(); - LOG(INFO) << "v0.dcanegtopv() = " << v0.dcanegtopv(); - LOG(INFO) << "v0.cosPA() = " << v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()); - // fill candidate table rows rowCandidateBase(collision.posX(), collision.posY(), collision.posZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], @@ -136,7 +132,8 @@ struct HFCandidateCreatorCascade { casc.index0Id(), casc.indexV0Id(), casc.hfflag(), v0.x(), v0.y(), v0.z(), - v0.posTrack(), v0.negTrack(), + //v0.posTrack(), v0.negTrack(), // why this was not fine? + v0.posTrack_as().globalIndex(), v0.negTrack_as().globalIndex(), v0.pxpos(), v0.pypos(), v0.pzpos(), v0.pxneg(), v0.pyneg(), v0.pzneg(), v0.dcaV0daughters(), @@ -161,7 +158,7 @@ struct HFCandidateCreatorCascadeExpressions { }; //___________________________________________________________________________________________ -/* + /// Performs MC matching. struct HFCandidateCreatorCascadeMC { Produces rowMCMatchRec; @@ -172,55 +169,33 @@ struct HFCandidateCreatorCascadeMC { aod::McParticles const& particlesMC) { int8_t sign = 0; - int8_t flag = 0; // Match reconstructed candidates. for (auto& candidate : candidates) { - //Printf("New rec. candidate"); - flag = 0; auto arrayDaughtersV0 = array{candidate.posTrack_as(), candidate.negTrack_as()}; - - // K0S --> pi+pi- - //Printf("Checking D0(bar) → π± K∓"); - if (RecoDecay::getMatchedMCRec(particlesMC, arrayDaughters, 421, array{+kPiPlus, -kKPlus}, true, &sign) > -1) { - flag = sign * (1 << D0ToPiK); + auto arrayDaughtersLc = array{candidate.index0_as(), candidate.posTrack_as(), candidate.negTrack_as()}; + + // First we check the K0s + LOG(DEBUG) << "Looking for K0s"; + RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, 310, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s + if (sign != 0) { // we have already positively checked the K0s + // then we check the Lc + LOG(DEBUG) << "Looking for Lc"; + RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersLc, 4122, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); // 3-levels Lc --> p + K0 --> p + K0s --> p + pi+ pi- } - // J/ψ → e+ e- - if (flag == 0) { - //Printf("Checking J/ψ → e+ e-"); - if (RecoDecay::getMatchedMCRec(particlesMC, std::move(arrayDaughters), 443, array{+kElectron, -kElectron}, true) > -1) { - flag = 1 << JpsiToEE; - } - } - - rowMCMatchRec(flag); + rowMCMatchRec(sign); } // Match generated particles. + // This is not enough, though, I need to check that the V0 is a K0s! Otherwise also the decay like Lc --> L + pi --> p + pi + pi will be accepted for (auto& particle : particlesMC) { - //Printf("New gen. candidate"); - flag = 0; - - // D0(bar) → π± K∓ - //Printf("Checking D0(bar) → π± K∓"); - if (RecoDecay::isMatchedMCGen(particlesMC, particle, 421, array{+kPiPlus, -kKPlus}, true, &sign)) { - flag = sign * (1 << D0ToPiK); - } - - // J/ψ → e+ e- - if (flag == 0) { - //Printf("Checking J/ψ → e+ e-"); - if (RecoDecay::isMatchedMCGen(particlesMC, particle, 443, array{+kElectron, -kElectron}, true)) { - flag = 1 << JpsiToEE; - } - } - - rowMCMatchGen(flag); + RecoDecay::isMatchedMCGen(particlesMC, particle, 4122, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); + rowMCMatchGen(sign); } } }; -*/ + //____________________________________________________________________ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) @@ -229,8 +204,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) adaptAnalysisTask("hf-cand-creator-cascade"), adaptAnalysisTask("hf-cand-creator-cascade-expressions")}; const bool doMC = cfgc.options().get("doMC"); - //if (doMC) { - // workflow.push_back(adaptAnalysisTask("hf-cand-creator-2prong-mc")); - //} + if (doMC) { + workflow.push_back(adaptAnalysisTask("hf-cand-creator-cascade-mc")); + } return workflow; } diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index 0c019bf042e43..b65b5566392d6 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -15,7 +15,6 @@ /// \author Vít Kučera , CERN /// \author Nima Zardoshti , CERN -#include "Framework/runDataProcessing.h" #include "Framework/AnalysisTask.h" #include "Framework/HistogramRegistry.h" #include "DetectorsVertexing/DCAFitterN.h" @@ -36,6 +35,14 @@ using namespace o2::aod; using namespace o2::analysis; using namespace o2::analysis::hf_cuts_single_track; +void customize(std::vector& workflowOptions) +{ + ConfigParamSpec optionDoMC{"doMC-for-V0", VariantType::Bool, false, {"Perform MC matching for V0s."}}; + workflowOptions.push_back(optionDoMC); +} + +#include "Framework/runDataProcessing.h" + /// Track selection struct SelectTracks { @@ -1167,6 +1174,23 @@ struct HFTrackIndexSkimsCreatorCascades { } // process }; +struct HFTrackIndexTestMCCasc { + void process(aod::BigTracksMC const& tracks, + aod::V0DataExt const& V0s, + aod::McParticles const& particlesMC) + + { + int8_t sign = 0; + for (const auto& v0 : V0s) { + // selections on the V0 daughters + auto arrayDaughtersV0 = array{v0.posTrack_as(), v0.negTrack_as()}; + LOG(INFO) << "Looking for K0s "; + RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, 310, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s + } + return; + } +}; + //________________________________________________________________________________________________________________________ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) @@ -1176,4 +1200,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-creator"}), adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-cascades-creator"})}; + const bool doMCforV0 = cfgc.options().get("doMC-for-V0"); + if (doMCforV0) { + workflow.push_back(adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-creator-MC"})); + } + return workflow; + } From d8454dc4c76addf0df45388f40b744c2b89c2a45 Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Fri, 5 Mar 2021 23:12:58 +0100 Subject: [PATCH 08/14] recent work - to be cleaned-up --- .../Core/include/AnalysisCore/RecoDecay.h | 12 +- .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 166 +++++++++++++++--- .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 148 +++++++++++++++- Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx | 145 ++++++++++++--- 4 files changed, 416 insertions(+), 55 deletions(-) diff --git a/Analysis/Core/include/AnalysisCore/RecoDecay.h b/Analysis/Core/include/AnalysisCore/RecoDecay.h index 740d4ec43247c..e4a6289b6afa3 100644 --- a/Analysis/Core/include/AnalysisCore/RecoDecay.h +++ b/Analysis/Core/include/AnalysisCore/RecoDecay.h @@ -717,7 +717,7 @@ class RecoDecay } // Check that the number of direct daughters is not larger than the number of expected final daughters. if (indexDaughterFirst > -1 && indexDaughterLast > -1 && indexDaughterLast - indexDaughterFirst + 1 > N) { - //Printf("MC Rec: Rejected: too many direct daughters: %d (expected %d final)", indexDaughterLast - indexDaughterFirst + 1, N); + //Printf("MC Rec: Rejected: too many direct daughters: %d (expected %ld final)", indexDaughterLast - indexDaughterFirst + 1, N); return -1; } // Get the list of actual final daughters. @@ -729,7 +729,7 @@ class RecoDecay //printf("\n"); // Check whether the number of actual final daughters is equal to the number of expected final daughters (i.e. the number of provided prongs). if (arrAllDaughtersIndex.size() != N) { - //Printf("MC Rec: Rejected: incorrect number of final daughters: %d (expected %d)", arrAllDaughtersIndex.size(), N); + //Printf("MC Rec: Rejected: incorrect number of final daughters: %ld (expected %ld)", arrAllDaughtersIndex.size(), N); return -1; } } @@ -837,19 +837,19 @@ class RecoDecay } // Check that the number of direct daughters is not larger than the number of expected final daughters. if (indexDaughterFirst > -1 && indexDaughterLast > -1 && indexDaughterLast - indexDaughterFirst + 1 > N) { - //Printf("MC Gen: Rejected: too many direct daughters: %d (expected %d final)", indexDaughterLast - indexDaughterFirst + 1, N); + //Printf("MC Gen: Rejected: too many direct daughters: %d (expected %ld final)", indexDaughterLast - indexDaughterFirst + 1, N); return false; } // Get the list of actual final daughters. getDaughters(particlesMC, candidate, &arrAllDaughtersIndex, arrPDGDaughters, depthMax); - //printf("MC Gen: Mother %d has %d final daughters:", candidate.globalIndex(), arrAllDaughtersIndex.size()); + //printf("MC Gen: Mother %ld has %ld final daughters:", candidate.globalIndex(), arrAllDaughtersIndex.size()); //for (auto i : arrAllDaughtersIndex) { // printf(" %d", i); //} //printf("\n"); // Check whether the number of final daughters is equal to the required number. if (arrAllDaughtersIndex.size() != N) { - //Printf("MC Gen: Rejected: incorrect number of final daughters: %d (expected %d)", arrAllDaughtersIndex.size(), N); + //Printf("MC Gen: Rejected: incorrect number of final daughters: %ld (expected %ld)", arrAllDaughtersIndex.size(), N); return false; } // Check daughters' PDG codes. @@ -874,7 +874,7 @@ class RecoDecay *listIndexDaughters = arrAllDaughtersIndex; } } - //Printf("MC Gen: Accepted: m: %d", candidate.globalIndex()); + //Printf("MC Gen: Accepted: m: %ld", candidate.globalIndex()); if (sign) { *sign = sgn; } diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index 3882e472f892b..6e8a7e6a503db 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -54,10 +54,14 @@ struct HFCandidateCreatorCascade { double massLc = RecoDecay::getMassPDG(4122); double mass2K0sP{0.}; + using MyTracks = aod::BigTracksMC; + //using MyTracks = aod::BigTracks; + void process(aod::Collisions const& collisions, aod::HfTrackIndexCasc const& rowsTrackIndexCasc, - aod::BigTracks const& tracks, - aod::V0DataExt const& V0s) + MyTracks const& tracks, + aod::V0DataExt const& V0s, + aod::McParticles& mcParticles) { // 2-prong vertex fitter o2::vertexing::DCAFitterN<2> df; @@ -71,12 +75,41 @@ struct HFCandidateCreatorCascade { // loop over pairs of track indeces for (const auto& casc : rowsTrackIndexCasc) { - auto trackParCovBach = getTrackParCov(casc.index0()); + const auto& bach = casc.index0_as(); + auto trackParCovBach = getTrackParCov(bach); const auto& v0 = casc.indexV0_as(); - const auto& posTrack = v0.posTrack_as(); - const auto& negTrack = v0.negTrack_as(); - auto posTrackParCov = getTrackParCov(posTrack); // check that BigTracks does not need TracksExtended! - auto negTrackParCov = getTrackParCov(negTrack); // check that BigTracks does not need TracksExtended! + const auto& posTrack = v0.posTrack_as(); + const auto& negTrack = v0.negTrack_as(); + + auto protonLabel = bach.labelId(); + auto labelPos = posTrack.labelId(); + auto labelNeg = negTrack.labelId(); + + bool isLc = (protonLabel == 27378 && labelPos == 27384 && labelNeg == 27385) || (protonLabel == 981514 && labelPos == 981525 && labelNeg == 981526) || (protonLabel == 1079941 && labelPos == 1080007 && labelNeg == 1080008) || + (protonLabel == 1151713 && labelPos == 1151717 && labelNeg == 1151718) || (protonLabel == 1354075 && labelPos == 1354080 && labelNeg == 1354081) || (protonLabel == 46077 && labelPos == 46082 && labelNeg == 46083) || + (protonLabel == 386988 && labelPos == 386994 && labelNeg == 386995) || (protonLabel == 1032251 && labelPos == 1032304 && labelNeg == 1032305) || (protonLabel == 1126614 && labelPos == 1126617 && labelNeg == 1126618) || + (protonLabel == 1178107 && labelPos == 1178152 && labelNeg == 1178153) || (protonLabel == 1386970 && labelPos == 1386973 && labelNeg == 1386974) || (protonLabel == 18733 && labelPos == 18895 && labelNeg == 18896) || + (protonLabel == 319481 && labelPos == 319531 && labelNeg == 319532) || (protonLabel == 433384 && labelPos == 433387 && labelNeg == 433388) || (protonLabel == 914259 && labelPos == 914299 && labelNeg == 914300) || + (protonLabel == 364214 && labelPos == 364270 && labelNeg == 364271) || (protonLabel == 922267 && labelPos == 922284 && labelNeg == 922285) || (protonLabel == 49070 && labelPos == 49092 && labelNeg == 49093) || + (protonLabel == 841303 && labelPos == 841344 && labelNeg == 841345) || (protonLabel == 1167211 && labelPos == 1167214 && labelNeg == 1167215) || (protonLabel == 1257919 && labelPos == 1257925 && labelNeg == 1257926) || + (protonLabel == 367228 && labelPos == 367299 && labelNeg == 367300) || (protonLabel == 439084 && labelPos == 439094 && labelNeg == 439095) || (protonLabel == 812970 && labelPos == 812984 && labelNeg == 812985) || + (protonLabel == 1379678 && labelPos == 1379705 && labelNeg == 1379706) || (protonLabel == 62526 && labelPos == 62529 && labelNeg == 62530) || (protonLabel == 299330 && labelPos == 299343 && labelNeg == 299344) || + (protonLabel == 492671 && labelPos == 492703 && labelNeg == 492704) || (protonLabel == 492678 && labelPos == 492681 && labelNeg == 492682) || (protonLabel == 540812 && labelPos == 540846 && labelNeg == 540847) || + (protonLabel == 727692 && labelPos == 727710 && labelNeg == 727711) || (protonLabel == 900211 && labelPos == 900248 && labelNeg == 900249) || (protonLabel == 653455 && labelPos == 653535 && labelNeg == 653536) || + (protonLabel == 759316 && labelPos == 759443 && labelNeg == 759444) || (protonLabel == 192853 && labelPos == 192861 && labelNeg == 192862) || (protonLabel == 1096808 && labelPos == 1096815 && labelNeg == 1096816) || + (protonLabel == 1373001 && labelPos == 1373004 && labelNeg == 1373005) || (protonLabel == 62875 && labelPos == 62878 && labelNeg == 62879) || (protonLabel == 161859 && labelPos == 161866 && labelNeg == 161867) || + (protonLabel == 534335 && labelPos == 534341 && labelNeg == 534342) || (protonLabel == 806033 && labelPos == 806053 && labelNeg == 806054) || (protonLabel == 1050891 && labelPos == 1050897 && labelNeg == 1050898) || + (protonLabel == 1390046 && labelPos == 1390049 && labelNeg == 1390050) || (protonLabel == 6268 && labelPos == 6288 && labelNeg == 6289) || (protonLabel == 854417 && labelPos == 854422 && labelNeg == 854423) || + (protonLabel == 576587 && labelPos == 576590 && labelNeg == 576591) || (protonLabel == 633385 && labelPos == 633388 && labelNeg == 633389) || (protonLabel == 911527 && labelPos == 911572 && labelNeg == 911573) || + (protonLabel == 995379 && labelPos == 995382 && labelNeg == 995383) || (protonLabel == 119194 && labelPos == 119206 && labelNeg == 119207) || (protonLabel == 724999 && labelPos == 725047 && labelNeg == 725048) || + (protonLabel == 762518 && labelPos == 762521 && labelNeg == 762522); + + if (isLc) { + LOG(INFO) << "Processing the Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg; + } + + auto posTrackParCov = getTrackParCov(posTrack); // check that MyTracks does not need TracksExtended! + auto negTrackParCov = getTrackParCov(negTrack); // check that MyTracks does not need TracksExtended! posTrackParCov.propagateTo(v0.posX(), d_bZ); // propagate the track to the X closest to the V0 vertex negTrackParCov.propagateTo(v0.negX(), d_bZ); // propagate the track to the X closest to the V0 vertex const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; @@ -84,12 +117,20 @@ struct HFCandidateCreatorCascade { // we build the neutral track to then build the cascade auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track (indices for v0 daughters set to 0 for now) - auto collision = casc.index0().collision(); + auto collision = bach.collision(); // reconstruct the cascade secondary vertex if (df.process(trackV0, trackParCovBach) == 0) { + if (isLc) LOG(INFO) << "Vertexing failed for Lc candidate"; + // if (isLc) { + // LOG(INFO) << "Vertexing failed for Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg; + //} continue; } + else { + //LOG(INFO) << "Vertexing succeeded for Lc candidate"; + } + const auto& secondaryVertex = df.getPCACandidate(); auto chi2PCA = df.getChi2AtPCACandidate(); auto covMatrixPCA = df.calcPCACovMatrix().Array(); @@ -121,6 +162,9 @@ struct HFCandidateCreatorCascade { auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixPCA, phi, 0.)); // fill candidate table rows + if (isLc) { + LOG(INFO) << "IT IS A Lc! Filling for Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg; + } rowCandidateBase(collision.posX(), collision.posY(), collision.posZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], errorDecayLength, errorDecayLengthXY, @@ -133,7 +177,7 @@ struct HFCandidateCreatorCascade { casc.hfflag(), v0.x(), v0.y(), v0.z(), //v0.posTrack(), v0.negTrack(), // why this was not fine? - v0.posTrack_as().globalIndex(), v0.negTrack_as().globalIndex(), + v0.posTrack_as().globalIndex(), v0.negTrack_as().globalIndex(), v0.pxpos(), v0.pypos(), v0.pzpos(), v0.pxneg(), v0.pyneg(), v0.pzneg(), v0.dcaV0daughters(), @@ -169,28 +213,110 @@ struct HFCandidateCreatorCascadeMC { aod::McParticles const& particlesMC) { int8_t sign = 0; - + std::vector arrDaughLcIndex; + std::array arrDaughLcPDG; + std::array arrDaughLcPDGRef = {2212, 211, -211}; + // Match reconstructed candidates. for (auto& candidate : candidates) { auto arrayDaughtersV0 = array{candidate.posTrack_as(), candidate.negTrack_as()}; auto arrayDaughtersLc = array{candidate.index0_as(), candidate.posTrack_as(), candidate.negTrack_as()}; // First we check the K0s + printf("\n"); + LOG(INFO) << "Checking MC for candidate!"; LOG(DEBUG) << "Looking for K0s"; - RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, 310, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s - if (sign != 0) { // we have already positively checked the K0s - // then we check the Lc - LOG(DEBUG) << "Looking for Lc"; - RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersLc, 4122, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); // 3-levels Lc --> p + K0 --> p + K0s --> p + pi+ pi- + auto labelPos = candidate.posTrack_as().label().globalIndex(); + auto labelNeg = candidate.negTrack_as().label().globalIndex(); + auto protonLabel = candidate.index0_as().labelId(); + + bool isLc = (protonLabel == 27378 && labelPos == 27384 && labelNeg == 27385) || (protonLabel == 981514 && labelPos == 981525 && labelNeg == 981526) || (protonLabel == 1079941 && labelPos == 1080007 && labelNeg == 1080008) || + (protonLabel == 1151713 && labelPos == 1151717 && labelNeg == 1151718) || (protonLabel == 1354075 && labelPos == 1354080 && labelNeg == 1354081) || (protonLabel == 46077 && labelPos == 46082 && labelNeg == 46083) || + (protonLabel == 386988 && labelPos == 386994 && labelNeg == 386995) || (protonLabel == 1032251 && labelPos == 1032304 && labelNeg == 1032305) || (protonLabel == 1126614 && labelPos == 1126617 && labelNeg == 1126618) || + (protonLabel == 1178107 && labelPos == 1178152 && labelNeg == 1178153) || (protonLabel == 1386970 && labelPos == 1386973 && labelNeg == 1386974) || (protonLabel == 18733 && labelPos == 18895 && labelNeg == 18896) || + (protonLabel == 319481 && labelPos == 319531 && labelNeg == 319532) || (protonLabel == 433384 && labelPos == 433387 && labelNeg == 433388) || (protonLabel == 914259 && labelPos == 914299 && labelNeg == 914300) || + (protonLabel == 364214 && labelPos == 364270 && labelNeg == 364271) || (protonLabel == 922267 && labelPos == 922284 && labelNeg == 922285) || (protonLabel == 49070 && labelPos == 49092 && labelNeg == 49093) || + (protonLabel == 841303 && labelPos == 841344 && labelNeg == 841345) || (protonLabel == 1167211 && labelPos == 1167214 && labelNeg == 1167215) || (protonLabel == 1257919 && labelPos == 1257925 && labelNeg == 1257926) || + (protonLabel == 367228 && labelPos == 367299 && labelNeg == 367300) || (protonLabel == 439084 && labelPos == 439094 && labelNeg == 439095) || (protonLabel == 812970 && labelPos == 812984 && labelNeg == 812985) || + (protonLabel == 1379678 && labelPos == 1379705 && labelNeg == 1379706) || (protonLabel == 62526 && labelPos == 62529 && labelNeg == 62530) || (protonLabel == 299330 && labelPos == 299343 && labelNeg == 299344) || + (protonLabel == 492671 && labelPos == 492703 && labelNeg == 492704) || (protonLabel == 492678 && labelPos == 492681 && labelNeg == 492682) || (protonLabel == 540812 && labelPos == 540846 && labelNeg == 540847) || + (protonLabel == 727692 && labelPos == 727710 && labelNeg == 727711) || (protonLabel == 900211 && labelPos == 900248 && labelNeg == 900249) || (protonLabel == 653455 && labelPos == 653535 && labelNeg == 653536) || + (protonLabel == 759316 && labelPos == 759443 && labelNeg == 759444) || (protonLabel == 192853 && labelPos == 192861 && labelNeg == 192862) || (protonLabel == 1096808 && labelPos == 1096815 && labelNeg == 1096816) || + (protonLabel == 1373001 && labelPos == 1373004 && labelNeg == 1373005) || (protonLabel == 62875 && labelPos == 62878 && labelNeg == 62879) || (protonLabel == 161859 && labelPos == 161866 && labelNeg == 161867) || + (protonLabel == 534335 && labelPos == 534341 && labelNeg == 534342) || (protonLabel == 806033 && labelPos == 806053 && labelNeg == 806054) || (protonLabel == 1050891 && labelPos == 1050897 && labelNeg == 1050898) || + (protonLabel == 1390046 && labelPos == 1390049 && labelNeg == 1390050) || (protonLabel == 6268 && labelPos == 6288 && labelNeg == 6289) || (protonLabel == 854417 && labelPos == 854422 && labelNeg == 854423) || + (protonLabel == 576587 && labelPos == 576590 && labelNeg == 576591) || (protonLabel == 633385 && labelPos == 633388 && labelNeg == 633389) || (protonLabel == 911527 && labelPos == 911572 && labelNeg == 911573) || + (protonLabel == 995379 && labelPos == 995382 && labelNeg == 995383) || (protonLabel == 119194 && labelPos == 119206 && labelNeg == 119207) || (protonLabel == 724999 && labelPos == 725047 && labelNeg == 725048) || + (protonLabel == 762518 && labelPos == 762521 && labelNeg == 762522); + //if (labelPos == 27384 || labelPos == 981525 || labelPos == 1080007 || labelPos == 1151717 || labelPos == 1354080 || labelPos == 46082 || labelPos == 386994 || labelPos == 1032304 || labelPos == 1126617 || labelPos == 1178152 || labelPos == 1386973 || labelPos == 18895 || labelPos == 319531 || labelPos == 433387 || labelPos == 914299 || labelPos == 364270 || labelPos == 922284 || labelPos == 49092 || labelPos == 841344 || labelPos == 1167214 || labelPos == 1257925 || labelPos == 367299 || labelPos == 439094 || labelPos == 812984 || labelPos == 1379705 || labelPos == 62529 || labelPos == 299343 || labelPos == 492703 || labelPos == 492681 || labelPos == 540846 || labelPos == 727710 || labelPos == 900248 || labelPos == 653535 || labelPos == 759443 || labelPos == 192861 || labelPos == 1096815 || labelPos == 1373004 || labelPos == 62878 || labelPos == 161866 || labelPos == 534341 || labelPos == 806053 || labelPos == 1050897 || labelPos == 1390049 || labelPos == 6288 || labelPos == 854422 || labelPos == 576590 || labelPos == 633388 || labelPos == 911572 || labelPos == 995382 || labelPos == 119206 || labelPos == 725047 || labelPos == 762521 || + // labelNeg == 27385 || labelNeg == 981526 || labelNeg == 1080008 || labelNeg == 1151718 || labelNeg == 1354081 || labelNeg == 46083 || labelNeg == 386995 || labelNeg == 1032305 || labelNeg == 1126618 || labelNeg == 1178153 || labelNeg == 1386974 || labelNeg == 18896 || labelNeg == 319532 || labelNeg == 433388 || labelNeg == 914300 || labelNeg == 364271 || labelNeg == 922285 || labelNeg == 49093 || labelNeg == 841345 || labelNeg == 1167215 || labelNeg == 1257926 || labelNeg == 367300 || labelNeg == 439095 || labelNeg == 812985 || labelNeg == 1379706 || labelNeg == 62530 || labelNeg == 299344 || labelNeg == 492704 || labelNeg == 492682 || labelNeg == 540847 || labelNeg == 727711 || labelNeg == 900249 || labelNeg == 653536 || labelNeg == 759444 || labelNeg == 192862 || labelNeg == 1096816 || labelNeg == 1373005 || labelNeg == 62879 || labelNeg == 161867 || labelNeg == 534342 || labelNeg == 806054 || labelNeg == 1050898 || labelNeg == 1390050 || labelNeg == 6289 || labelNeg == 854423 || labelNeg == 576591 || labelNeg == 633389 || labelNeg == 911573 || labelNeg == 995383 || labelNeg == 119207 || labelNeg == 725048 || labelNeg == 762522){ + if ((labelPos == 27384 && labelNeg == 27385) || (labelPos == 981525 && labelNeg == 981526) || (labelPos == 1080007 && labelNeg == 1080008) || (labelPos == 1151717 && labelNeg == 1151718) || + (labelPos == 1354080 && labelNeg == 1354081) || (labelPos == 46082 && labelNeg == 46083) || (labelPos == 386994 && labelNeg == 386995) || (labelPos == 1032304 && labelNeg == 1032305) || + (labelPos == 1126617 && labelNeg == 1126618) || (labelPos == 1178152 && labelNeg == 1178153) || (labelPos == 1386973 && labelNeg == 1386974) || (labelPos == 18895 && labelNeg == 18896) || + (labelPos == 319531 && labelNeg == 319532) || (labelPos == 433387 && labelNeg == 433388) || (labelPos == 914299 && labelNeg == 914300) || (labelPos == 364270 && labelNeg == 364271) || + (labelPos == 922284 && labelNeg == 922285) || (labelPos == 49092 && labelNeg == 49093) || (labelPos == 841344 && labelNeg == 841345) || (labelPos == 1167214 && labelNeg == 1167215) || + (labelPos == 1257925 && labelNeg == 1257926) || (labelPos == 367299 && labelNeg == 367300) || (labelPos == 439094 && labelNeg == 439095) || (labelPos == 812984 && labelNeg == 812985) || + (labelPos == 1379705 && labelNeg == 1379706) || (labelPos == 62529 && labelNeg == 62530) || (labelPos == 299343 && labelNeg == 299344) || (labelPos == 492703 && labelNeg == 492704) || + (labelPos == 492681 && labelNeg == 492682) || (labelPos == 540846 && labelNeg == 540847) || (labelPos == 727710 && labelNeg == 727711) || (labelPos == 900248 && labelNeg == 900249) || + (labelPos == 653535 && labelNeg == 653536) || (labelPos == 759443 && labelNeg == 759444) || (labelPos == 192861 && labelNeg == 192862) || (labelPos == 1096815 && labelNeg == 1096816) || + (labelPos == 1373004 && labelNeg == 1373005) || (labelPos == 62878 && labelNeg == 62879) || (labelPos == 161866 && labelNeg == 161867) || (labelPos == 534341 && labelNeg == 534342) || + (labelPos == 806053 && labelNeg == 806054) || (labelPos == 1050897 && labelNeg == 1050898) || (labelPos == 1390049 && labelNeg == 1390050) || (labelPos == 6288 && labelNeg == 6289) || + (labelPos == 854422 && labelNeg == 854423) || (labelPos == 576590 && labelNeg == 576591) || (labelPos == 633388 && labelNeg == 633389) || (labelPos == 911572 && labelNeg == 911573) || + (labelPos == 995382 && labelNeg == 995383) || (labelPos == 119206 && labelNeg == 119207) || (labelPos == 725047 && labelNeg == 725048) || (labelPos == 762521 && labelNeg == 762522)) { + LOG(INFO) << "correct K0S in the Lc daughters: posTrack --> " << labelPos << ", negTrack --> " << labelNeg; } - rowMCMatchRec(sign); - } - + //if (isLc) { + RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, 310, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s + + if (sign != 0) { // we have already positively checked the K0s + // then we check the Lc + LOG(INFO) << "K0S was correct! now we check the Lc"; + auto labelProton = candidate.index0_as().label().globalIndex(); + LOG(INFO) << "label proton = " << labelProton; + LOG(DEBUG) << "Looking for Lc"; + RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersLc, 4122, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); // 3-levels Lc --> p + K0 --> p + K0s --> p + pi+ pi- + if (sign == 0) { + LOG(INFO) << "No true Lc found"; + } + else { + LOG(INFO) << "Lc found with sign " << sign; + } + printf("\n"); + } + + rowMCMatchRec(sign); + } + //} + // Match generated particles. - // This is not enough, though, I need to check that the V0 is a K0s! Otherwise also the decay like Lc --> L + pi --> p + pi + pi will be accepted for (auto& particle : particlesMC) { - RecoDecay::isMatchedMCGen(particlesMC, particle, 4122, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); + // checking if I have a Lc --> K0S + p + RecoDecay::isMatchedMCGen(particlesMC, particle, 4122, array{+kProton, 310}, true, &sign, 2); + if (sign != 0) { + LOG(INFO) << "Lc in K0S p"; + arrDaughLcIndex.clear(); + // checking that the final daughters (decay depth = 3) are p, pi+, pi- + RecoDecay::getDaughters(particlesMC, particle.globalIndex(), &arrDaughLcIndex, arrDaughLcPDGRef, 3); // best would be to check the K0S daughters + LOG(INFO) << "arrDaughLcIndex.size() = " << arrDaughLcIndex.size(); + if (arrDaughLcIndex.size() == 3) { + for (auto iProng = 0; iProng < arrDaughLcIndex.size(); ++iProng) { + auto daughI = particlesMC.iteratorAt(arrDaughLcIndex[iProng]); + arrDaughLcPDG[iProng] = daughI.pdgCode(); + } + if (!(arrDaughLcPDG[0] == arrDaughLcPDGRef[0] && arrDaughLcPDG[1] == arrDaughLcPDGRef[1] && arrDaughLcPDG[2] == arrDaughLcPDGRef[2])) { // this should be the condition, first bach, then v0 + LOG(INFO) << "Pity, the three final daughters are not p, pi+, pi-, but " << arrDaughLcPDG[0] << ", " << arrDaughLcPDG[1] << ", " << arrDaughLcPDG[2]; + sign = 0; + } + else { + LOG(INFO) << " YU-HUUUUU!"; + } + } + //RecoDecay::isMatchedMCGen(particlesMC, particle, 4122, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); + //if (sign !=0) { + // LOG(INFO) << "Lc in p pi+ pi-"; + //} + } rowMCMatchGen(sign); } } diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index b65b5566392d6..c7ec32e33c3b0 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -124,11 +124,21 @@ struct SelectTracks { } void process(aod::Collision const& collision, - soa::Join const& tracks) + soa::Join const& tracks, + aod::McParticles& mcParticles) { math_utils::Point3D vtxXYZ(collision.posX(), collision.posY(), collision.posZ()); for (auto& track : tracks) { + auto protonLabel = track.labelId(); + // LOG(INFO) << "Checking label " << protonLabel; + bool isProtonFromLc = (protonLabel == 27378) || (protonLabel == 981514) || (protonLabel == 1079941) || (protonLabel == 1151713) || (protonLabel == 1354075) || (protonLabel == 46077) || (protonLabel == 386988) || (protonLabel == 1032251) || (protonLabel == 1126614) || (protonLabel == 1178107) || (protonLabel == 1386970) || (protonLabel == 18733) || (protonLabel == 319481) || (protonLabel == 433384) || (protonLabel == 914259) || (protonLabel == 364214) || (protonLabel == 922267) || (protonLabel == 49070) || (protonLabel == 841303) || (protonLabel == 1167211) || (protonLabel == 1257919) || (protonLabel == 367228) || (protonLabel == 439084) || (protonLabel == 812970) || (protonLabel == 1379678) || (protonLabel == 62526) || (protonLabel == 299330) || (protonLabel == 492671) || (protonLabel == 492678) || (protonLabel == 540812) || (protonLabel == 727692) || (protonLabel == 900211) || (protonLabel == 653455) || (protonLabel == 759316) || (protonLabel == 192853) || (protonLabel == 1096808) || (protonLabel == 1373001) || (protonLabel == 62875) || (protonLabel == 161859) || (protonLabel == 534335) || (protonLabel == 806033) || (protonLabel == 1050891) || (protonLabel == 1390046) || (protonLabel == 6268) || (protonLabel == 854417) || (protonLabel == 576587) || (protonLabel == 633385) || (protonLabel == 911527) || (protonLabel == 995379) || (protonLabel == 119194) || (protonLabel == 724999) || (protonLabel == 762518); + + if (isProtonFromLc) { + LOG(INFO) << "\nWe found the proton " << protonLabel; + } + + int status_prong = 7; // selection flag , 3 bits on auto trackPt = track.pt(); @@ -143,6 +153,9 @@ struct SelectTracks { if (trackPt < ptmintrack_3prong) { status_prong = status_prong & ~(1 << 1); } + if (isProtonFromLc) { + LOG(INFO) << "proton " << protonLabel << " pt = " << track.pt() << " (cut " << d_ptMinTrackBach << ")"; + } if (track.pt() < d_ptMinTrackBach) { status_prong = status_prong & ~(1 << 2); } @@ -155,17 +168,26 @@ struct SelectTracks { if ((status_prong & (1 << 1)) && abs(trackEta) > etamax_3prong) { status_prong = status_prong & ~(1 << 1); } + if (isProtonFromLc) { + LOG(INFO) << "proton " << protonLabel << " eta = " << track.eta() << " (cut " << d_etaMaxBach << ")"; + } if ((status_prong & (1 << 2)) && abs(track.eta()) > d_etaMaxBach) { status_prong = status_prong & ~(1 << 2); } // quality cut + if (isProtonFromLc) { + LOG(INFO) << "proton " << protonLabel << " tpcNClsFound = " << track.tpcNClsFound() << " (cut " << d_tpcnclsfound.value << ")"; + } if (doCutQuality.value && status_prong > 0) { // FIXME to make a more complete selection e.g track.flags() & o2::aod::track::TPCrefit && track.flags() & o2::aod::track::GoldenChi2 && UChar_t clustermap = track.itsClusterMap(); if (!(track.tpcNClsFound() >= d_tpcnclsfound.value && // is this the number of TPC clusters? It should not be used track.flags() & o2::aod::track::ITSrefit && (TESTBIT(clustermap, 0) || TESTBIT(clustermap, 1)))) { status_prong = 0; + if (isProtonFromLc) { + LOG(INFO) << "proton " << protonLabel << " did not pass clusters cut" ; + } } } @@ -190,9 +212,16 @@ struct SelectTracks { status_prong = status_prong & ~(1 << 1); } if ((status_prong & (1 << 2)) && (abs(dca[0]) < d_dcaToPrimXYMinBach_ptDep || abs(dca[0]) > d_dcaToPrimXYMaxBach)) { + if (isProtonFromLc) { + LOG(INFO) << "proton " << protonLabel << " did not pass DCA cut"; + LOG(INFO) << "dca[0] = " << dca[0] << " (lower cut " << d_dcaToPrimXYMinBach_ptDep << ", upper cut " << d_dcaToPrimXYMaxBach << ")"; + } status_prong = status_prong & ~(1 << 2); } } + if (isProtonFromLc) { + LOG(INFO) << "status_prong = " << status_prong; + } // fill histograms if (b_dovalplots) { @@ -207,6 +236,9 @@ struct SelectTracks { registry.get(HIST("heta_cuts_3prong"))->Fill(trackEta); } if (status_prong & (1 << 2)) { + if (isProtonFromLc) { + LOG(INFO) << "Will be kept: Proton from Lc " << protonLabel; + } registry.get(HIST("hpt_cuts_bach"))->Fill(trackPt); registry.get(HIST("hdcatoprimxy_cuts_bach"))->Fill(dca[0]); registry.get(HIST("heta_cuts_bach"))->Fill(trackEta); @@ -1013,7 +1045,8 @@ struct HFTrackIndexSkimsCreatorCascades { {"hmass2", "2-prong candidates;inv. mass (K0s p) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}}}; // NB: using FullTracks = soa::Join; defined in Framework/Core/include/Framework/AnalysisDataModel.h - using MyTracks = soa::Join; + using MyTracks = soa::Join; + //using MyTracks = aod::BigTracksMC; //Partition selectedTracks = aod::hf_seltrack::isSelProng >= 4; // using SelectedV0s = soa::Filtered; @@ -1032,7 +1065,8 @@ struct HFTrackIndexSkimsCreatorCascades { aod::BCs const& bcs, //soa::Filtered const& V0s, aod::V0DataExt const& V0s, - MyTracks const& tracks) // TODO: I am now assuming that the V0s are already filtered with my cuts (David's work to come) + MyTracks const& tracks, + aod::McParticles& mcParticles) // TODO: I am now assuming that the V0s are already filtered with my cuts (David's work to come) { //Define o2 fitter, 2-prong @@ -1051,36 +1085,104 @@ struct HFTrackIndexSkimsCreatorCascades { //for (const auto& bach : selectedTracks) { for (const auto& bach : tracks) { + auto protonLabel = bach.labelId(); + bool isProtonFromLc = (protonLabel == 27378) || (protonLabel == 981514) || (protonLabel == 1079941) || (protonLabel == 1151713) || (protonLabel == 1354075) || (protonLabel == 46077) || (protonLabel == 386988) || (protonLabel == 1032251) || (protonLabel == 1126614) || (protonLabel == 1178107) || (protonLabel == 1386970) || (protonLabel == 18733) || (protonLabel == 319481) || (protonLabel == 433384) || (protonLabel == 914259) || (protonLabel == 364214) || (protonLabel == 922267) || (protonLabel == 49070) || (protonLabel == 841303) || (protonLabel == 1167211) || (protonLabel == 1257919) || (protonLabel == 367228) || (protonLabel == 439084) || (protonLabel == 812970) || (protonLabel == 1379678) || (protonLabel == 62526) || (protonLabel == 299330) || (protonLabel == 492671) || (protonLabel == 492678) || (protonLabel == 540812) || (protonLabel == 727692) || (protonLabel == 900211) || (protonLabel == 653455) || (protonLabel == 759316) || (protonLabel == 192853) || (protonLabel == 1096808) || (protonLabel == 1373001) || (protonLabel == 62875) || (protonLabel == 161859) || (protonLabel == 534335) || (protonLabel == 806033) || (protonLabel == 1050891) || (protonLabel == 1390046) || (protonLabel == 6268) || (protonLabel == 854417) || (protonLabel == 576587) || (protonLabel == 633385) || (protonLabel == 911527) || (protonLabel == 995379) || (protonLabel == 119194) || (protonLabel == 724999) || (protonLabel == 762518); + // selections on the bachelor // pT cut if (bach.isSelProng() < 4) { + if (isProtonFromLc) { + LOG(INFO) << "proton " << protonLabel << ": rejected due to HFsel"; + } continue; } if (b_TPCRefit) { if (!(bach.trackType() & o2::aod::track::TPCrefit)) { + if (isProtonFromLc) { + LOG(INFO) << "proton " << protonLabel << ": rejected due to TPCrefit"; + } continue; } } if (bach.tpcNClsCrossedRows() < i_minCrossedRows) { + if (isProtonFromLc) { + LOG(INFO) << "proton " << protonLabel << ": rejected due to minNUmberOfCrossedRows " << bach.tpcNClsCrossedRows() << " (cut " << i_minCrossedRows << ")"; + } continue; } - + if (isProtonFromLc) { + LOG(INFO) << "KEPT! proton from Lc with daughters " << protonLabel; + } auto bachTrack = getTrackParCov(bach); - // now we loop over the V0s for (const auto& v0 : V0s) { // selections on the V0 daughters const auto& posTrack = v0.posTrack_as(); const auto& negTrack = v0.negTrack_as(); + auto labelPos = posTrack.label().globalIndex(); + auto labelNeg = negTrack.label().globalIndex(); + bool isK0SfromLc = (labelPos == 27384 && labelNeg == 27385) || (labelPos == 981525 && labelNeg == 981526) || (labelPos == 1080007 && labelNeg == 1080008) || (labelPos == 1151717 && labelNeg == 1151718) || + (labelPos == 1354080 && labelNeg == 1354081) || (labelPos == 46082 && labelNeg == 46083) || (labelPos == 386994 && labelNeg == 386995) || (labelPos == 1032304 && labelNeg == 1032305) || + (labelPos == 1126617 && labelNeg == 1126618) || (labelPos == 1178152 && labelNeg == 1178153) || (labelPos == 1386973 && labelNeg == 1386974) || (labelPos == 18895 && labelNeg == 18896) || + (labelPos == 319531 && labelNeg == 319532) || (labelPos == 433387 && labelNeg == 433388) || (labelPos == 914299 && labelNeg == 914300) || (labelPos == 364270 && labelNeg == 364271) || + (labelPos == 922284 && labelNeg == 922285) || (labelPos == 49092 && labelNeg == 49093) || (labelPos == 841344 && labelNeg == 841345) || (labelPos == 1167214 && labelNeg == 1167215) || + (labelPos == 1257925 && labelNeg == 1257926) || (labelPos == 367299 && labelNeg == 367300) || (labelPos == 439094 && labelNeg == 439095) || (labelPos == 812984 && labelNeg == 812985) || + (labelPos == 1379705 && labelNeg == 1379706) || (labelPos == 62529 && labelNeg == 62530) || (labelPos == 299343 && labelNeg == 299344) || (labelPos == 492703 && labelNeg == 492704) || + (labelPos == 492681 && labelNeg == 492682) || (labelPos == 540846 && labelNeg == 540847) || (labelPos == 727710 && labelNeg == 727711) || (labelPos == 900248 && labelNeg == 900249) || + (labelPos == 653535 && labelNeg == 653536) || (labelPos == 759443 && labelNeg == 759444) || (labelPos == 192861 && labelNeg == 192862) || (labelPos == 1096815 && labelNeg == 1096816) || + (labelPos == 1373004 && labelNeg == 1373005) || (labelPos == 62878 && labelNeg == 62879) || (labelPos == 161866 && labelNeg == 161867) || (labelPos == 534341 && labelNeg == 534342) || + (labelPos == 806053 && labelNeg == 806054) || (labelPos == 1050897 && labelNeg == 1050898) || (labelPos == 1390049 && labelNeg == 1390050) || (labelPos == 6288 && labelNeg == 6289) || + (labelPos == 854422 && labelNeg == 854423) || (labelPos == 576590 && labelNeg == 576591) || (labelPos == 633388 && labelNeg == 633389) || (labelPos == 911572 && labelNeg == 911573) || + (labelPos == 995382 && labelNeg == 995383) || (labelPos == 119206 && labelNeg == 119207) || (labelPos == 725047 && labelNeg == 725048) || (labelPos == 762521 && labelNeg == 762522); + + bool isLc = (protonLabel == 27378 && labelPos == 27384 && labelNeg == 27385) || (protonLabel == 981514 && labelPos == 981525 && labelNeg == 981526) || (protonLabel == 1079941 && labelPos == 1080007 && labelNeg == 1080008) || + (protonLabel == 1151713 && labelPos == 1151717 && labelNeg == 1151718) || (protonLabel == 1354075 && labelPos == 1354080 && labelNeg == 1354081) || (protonLabel == 46077 && labelPos == 46082 && labelNeg == 46083) || + (protonLabel == 386988 && labelPos == 386994 && labelNeg == 386995) || (protonLabel == 1032251 && labelPos == 1032304 && labelNeg == 1032305) || (protonLabel == 1126614 && labelPos == 1126617 && labelNeg == 1126618) || + (protonLabel == 1178107 && labelPos == 1178152 && labelNeg == 1178153) || (protonLabel == 1386970 && labelPos == 1386973 && labelNeg == 1386974) || (protonLabel == 18733 && labelPos == 18895 && labelNeg == 18896) || + (protonLabel == 319481 && labelPos == 319531 && labelNeg == 319532) || (protonLabel == 433384 && labelPos == 433387 && labelNeg == 433388) || (protonLabel == 914259 && labelPos == 914299 && labelNeg == 914300) || + (protonLabel == 364214 && labelPos == 364270 && labelNeg == 364271) || (protonLabel == 922267 && labelPos == 922284 && labelNeg == 922285) || (protonLabel == 49070 && labelPos == 49092 && labelNeg == 49093) || + (protonLabel == 841303 && labelPos == 841344 && labelNeg == 841345) || (protonLabel == 1167211 && labelPos == 1167214 && labelNeg == 1167215) || (protonLabel == 1257919 && labelPos == 1257925 && labelNeg == 1257926) || + (protonLabel == 367228 && labelPos == 367299 && labelNeg == 367300) || (protonLabel == 439084 && labelPos == 439094 && labelNeg == 439095) || (protonLabel == 812970 && labelPos == 812984 && labelNeg == 812985) || + (protonLabel == 1379678 && labelPos == 1379705 && labelNeg == 1379706) || (protonLabel == 62526 && labelPos == 62529 && labelNeg == 62530) || (protonLabel == 299330 && labelPos == 299343 && labelNeg == 299344) || + (protonLabel == 492671 && labelPos == 492703 && labelNeg == 492704) || (protonLabel == 492678 && labelPos == 492681 && labelNeg == 492682) || (protonLabel == 540812 && labelPos == 540846 && labelNeg == 540847) || + (protonLabel == 727692 && labelPos == 727710 && labelNeg == 727711) || (protonLabel == 900211 && labelPos == 900248 && labelNeg == 900249) || (protonLabel == 653455 && labelPos == 653535 && labelNeg == 653536) || + (protonLabel == 759316 && labelPos == 759443 && labelNeg == 759444) || (protonLabel == 192853 && labelPos == 192861 && labelNeg == 192862) || (protonLabel == 1096808 && labelPos == 1096815 && labelNeg == 1096816) || + (protonLabel == 1373001 && labelPos == 1373004 && labelNeg == 1373005) || (protonLabel == 62875 && labelPos == 62878 && labelNeg == 62879) || (protonLabel == 161859 && labelPos == 161866 && labelNeg == 161867) || + (protonLabel == 534335 && labelPos == 534341 && labelNeg == 534342) || (protonLabel == 806033 && labelPos == 806053 && labelNeg == 806054) || (protonLabel == 1050891 && labelPos == 1050897 && labelNeg == 1050898) || + (protonLabel == 1390046 && labelPos == 1390049 && labelNeg == 1390050) || (protonLabel == 6268 && labelPos == 6288 && labelNeg == 6289) || (protonLabel == 854417 && labelPos == 854422 && labelNeg == 854423) || + (protonLabel == 576587 && labelPos == 576590 && labelNeg == 576591) || (protonLabel == 633385 && labelPos == 633388 && labelNeg == 633389) || (protonLabel == 911527 && labelPos == 911572 && labelNeg == 911573) || + (protonLabel == 995379 && labelPos == 995382 && labelNeg == 995383) || (protonLabel == 119194 && labelPos == 119206 && labelNeg == 119207) || (protonLabel == 724999 && labelPos == 725047 && labelNeg == 725048) || + (protonLabel == 762518 && labelPos == 762521 && labelNeg == 762522); + + if (isK0SfromLc) { + LOG(INFO) << "K0S from Lc found, posTrack --> " << labelPos << ", negTrack --> " << labelNeg; + } + + if (isK0SfromLc && isProtonFromLc) { + LOG(INFO) << "ACCEPTED!!!"; + LOG(INFO) << "proton belonging to a Lc found: label --> " << protonLabel; + LOG(INFO) << "K0S belonging to a Lc found: posTrack --> " << labelPos << ", negTrack --> " << labelNeg; + } + + if (isLc) { + LOG(INFO) << "Combination of K0S and p which correspond to a Lc found!"; + } + if (b_TPCRefit) { if (!(posTrack.trackType() & o2::aod::track::TPCrefit) || !(negTrack.trackType() & o2::aod::track::TPCrefit)) { - continue; + if (isK0SfromLc) { + LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to TPCrefit"; + } + continue; } } if (posTrack.tpcNClsCrossedRows() < i_minCrossedRows || negTrack.tpcNClsCrossedRows() < i_minCrossedRows) { + if (isK0SfromLc) { + LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to minCrossedRows"; + } continue; } // @@ -1091,23 +1193,37 @@ struct HFTrackIndexSkimsCreatorCascades { // if (posTrack.pt() < d_ptMin || // to the filters? I can't for now, it is not in the tables negTrack.pt() < d_ptMin) { + if (isK0SfromLc) { + LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to minPt --> pos " << posTrack.pt() << ", neg " << negTrack.pt() << " (cut " << d_ptMin << ")"; + } continue; } if (abs(posTrack.eta()) > d_etaMax || // to the filters? I can't for now, it is not in the tables abs(negTrack.eta()) > d_etaMax) { + if (isK0SfromLc) { + LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to eta --> pos " << posTrack.eta() << ", neg " << negTrack.eta() << " (cut " << d_etaMax << ")"; + } continue; } // V0 invariant mass selection if (std::abs(v0.mK0Short() - massK0s) > d_cutInvMassV0) { + if (isK0SfromLc) { + LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to invMass --> " << v0.mK0Short() - massK0s << " (cut " << d_cutInvMassV0 << ")"; + } continue; // should go to the filter, but since it is a dynamic column, I cannot use it there } // V0 cosPointingAngle selection if (v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < d_cosPAV0) { + if (isK0SfromLc) { + LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to cosPA --> " << v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) << " (cut " << d_cosPAV0 << ")"; + } continue; } - + if (isK0SfromLc) { + LOG(INFO) << "KEPT! K0S from Lc with daughters " << labelPos << " and " << labelNeg; + } auto posTrackParCov = getTrackParCov(posTrack); posTrackParCov.propagateTo(v0.posX(), d_bZ); // propagate the track to the X closest to the V0 vertex auto negTrackParCov = getTrackParCov(negTrack); @@ -1123,10 +1239,15 @@ struct HFTrackIndexSkimsCreatorCascades { // now we find the DCA between the V0 and the bachelor, for the cascade int nCand2 = fitter.process(trackV0, bachTrack); + if (isK0SfromLc && isProtonFromLc) { + LOG(INFO) << "Fitter result = " << nCand2 << " proton = " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg; + } + if (isLc) { + LOG(INFO) << "Fitter result for true Lc = " << nCand2; + } if (nCand2 == 0) { continue; } - std::array pVecCandCasc = {0., 0., 0.}; fitter.propagateTracksToVertex(); // propagate the bach and V0 to the Lc vertex fitter.getTrack(0).getPxPyPzGlo(pVecV0); // take the momentum at the Lc vertex @@ -1138,6 +1259,9 @@ struct HFTrackIndexSkimsCreatorCascades { // cascade candidate pT cut if (RecoDecay::Pt(pVecCandCasc) < d_cutCascPtCandMin) { + if (isK0SfromLc && isProtonFromLc) { + LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to pt cut: " << RecoDecay::Pt(pVecCandCasc) << " (cut " << d_cutCascPtCandMin << ")"; + } continue; } @@ -1146,7 +1270,10 @@ struct HFTrackIndexSkimsCreatorCascades { auto arrMom = array{pVecBach, pVecV0}; mass2K0sP = RecoDecay::M(arrMom, array{massP, massK0s}); // invariant-mass cut - if ((d_cutCascInvMassLc >= 0.) && (std::abs(mass2K0sP - massLc) < d_cutCascInvMassLc)) { + if ((d_cutCascInvMassLc >= 0.) && (std::abs(mass2K0sP - massLc) > d_cutCascInvMassLc)) { + if (isK0SfromLc && isProtonFromLc) { + LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to invMass cut: " << mass2K0sP << ", mass Lc " << massLc << " (cut " << d_cutCascInvMassLc << ")"; + } continue; } @@ -1162,6 +1289,9 @@ struct HFTrackIndexSkimsCreatorCascades { 1); // 1 should be the value for the Lc // fill histograms if (b_doValPlots) { + if (isK0SfromLc && isProtonFromLc && isLc) { + LOG(INFO) << "KEPT! True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg; + } registry.get(HIST("hvtx2_x"))->Fill(posCasc[0]); registry.get(HIST("hvtx2_y"))->Fill(posCasc[1]); registry.get(HIST("hvtx2_z"))->Fill(posCasc[2]); diff --git a/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx b/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx index d830b40b9c3c9..d455f333abbde 100644 --- a/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx +++ b/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx @@ -73,6 +73,9 @@ DECLARE_SOA_TABLE(V0GoodIndices, "AOD", "V0GOODINDICES", o2::soa::Index<>, } // namespace o2::aod using FullTracksExt = soa::Join; +//using BigTracks = soa::Join; +using BigTracks = soa::Join; +using BigTracksMC = soa::Join; //This prefilter creates a skimmed list of good V0s to re-reconstruct so that //CPU is saved in case there are specific selections that are to be done @@ -93,36 +96,96 @@ struct lambdakzeroprefilterpairs { Produces v0goodindices; void process(aod::Collision const& collision, aod::V0s const& V0s, - soa::Join const& tracks) + BigTracksMC const& tracks, aod::McParticles const& particlesMC) { for (auto& V0 : V0s) { + + auto labelPos = V0.posTrack_as().label().globalIndex(); + auto labelNeg = V0.negTrack_as().label().globalIndex(); + + bool isK0SfromLc = (labelPos == 27384 && labelNeg == 27385) || (labelPos == 981525 && labelNeg == 981526) || (labelPos == 1080007 && labelNeg == 1080008) || (labelPos == 1151717 && labelNeg == 1151718) || + (labelPos == 1354080 && labelNeg == 1354081) || (labelPos == 46082 && labelNeg == 46083) || (labelPos == 386994 && labelNeg == 386995) || (labelPos == 1032304 && labelNeg == 1032305) || + (labelPos == 1126617 && labelNeg == 1126618) || (labelPos == 1178152 && labelNeg == 1178153) || (labelPos == 1386973 && labelNeg == 1386974) || (labelPos == 18895 && labelNeg == 18896) || + (labelPos == 319531 && labelNeg == 319532) || (labelPos == 433387 && labelNeg == 433388) || (labelPos == 914299 && labelNeg == 914300) || (labelPos == 364270 && labelNeg == 364271) || + (labelPos == 922284 && labelNeg == 922285) || (labelPos == 49092 && labelNeg == 49093) || (labelPos == 841344 && labelNeg == 841345) || (labelPos == 1167214 && labelNeg == 1167215) || + (labelPos == 1257925 && labelNeg == 1257926) || (labelPos == 367299 && labelNeg == 367300) || (labelPos == 439094 && labelNeg == 439095) || (labelPos == 812984 && labelNeg == 812985) || + (labelPos == 1379705 && labelNeg == 1379706) || (labelPos == 62529 && labelNeg == 62530) || (labelPos == 299343 && labelNeg == 299344) || (labelPos == 492703 && labelNeg == 492704) || + (labelPos == 492681 && labelNeg == 492682) || (labelPos == 540846 && labelNeg == 540847) || (labelPos == 727710 && labelNeg == 727711) || (labelPos == 900248 && labelNeg == 900249) || + (labelPos == 653535 && labelNeg == 653536) || (labelPos == 759443 && labelNeg == 759444) || (labelPos == 192861 && labelNeg == 192862) || (labelPos == 1096815 && labelNeg == 1096816) || + (labelPos == 1373004 && labelNeg == 1373005) || (labelPos == 62878 && labelNeg == 62879) || (labelPos == 161866 && labelNeg == 161867) || (labelPos == 534341 && labelNeg == 534342) || + (labelPos == 806053 && labelNeg == 806054) || (labelPos == 1050897 && labelNeg == 1050898) || (labelPos == 1390049 && labelNeg == 1390050) || (labelPos == 6288 && labelNeg == 6289) || + (labelPos == 854422 && labelNeg == 854423) || (labelPos == 576590 && labelNeg == 576591) || (labelPos == 633388 && labelNeg == 633389) || (labelPos == 911572 && labelNeg == 911573) || + (labelPos == 995382 && labelNeg == 995383) || (labelPos == 119206 && labelNeg == 119207) || (labelPos == 725047 && labelNeg == 725048) || (labelPos == 762521 && labelNeg == 762522); + + //LOG(INFO) << "posTrackId = " << V0.posTrackId() << ", negTrackId = " << V0.negTrackId(); + + //Printf("posTrack --> V0.posTrack_as().label().globalIndex() = %ld, negTrack --> V0.negTrack_as().label().globalIndex() = %ld", V0.posTrack_as().label().globalIndex(), V0.negTrack_as().label().globalIndex()); + + if (isK0SfromLc) { + LOG(INFO) << "V0 builder: found K0S from Lc, posTrack --> " << labelPos << ", negTrack --> " << labelNeg; + } + + //LOG(INFO) << "posTrack --> V0.posTrack_as().globalIndex() = " << V0.posTrack_as().globalIndex(); + //LOG(INFO) << "posTrack --> V0.posTrack_as().labelId() = " << V0.posTrack_as().labelId(); + + //int iiiii = V0.posTrack_as().label().globalIndex(); + //int64_t iiiiiii = V0.posTrack_as().label().globalIndex(); + //int32_t iii = V0.posTrack_as().label().globalIndex(); + + // Printf("V0.posTrack_as().label().globalIndex() as int = %d", iiiii); + //Printf("V0.posTrack_as().label().globalIndex() as int64_t = %ld", iiiiiii); + //Printf("V0.posTrack_as().label().globalIndex() as int32_t = %d", iii); + + registry.fill(HIST("hGoodIndices"), 0.5); if (tpcrefit) { - if (!(V0.posTrack_as().trackType() & o2::aod::track::TPCrefit)) { + if (!(V0.posTrack_as().trackType() & o2::aod::track::TPCrefit)) { + if (isK0SfromLc) { + LOG(INFO) << "posTrack " << labelPos << " has no TPC refit"; + } continue; //TPC refit } - if (!(V0.negTrack_as().trackType() & o2::aod::track::TPCrefit)) { + if (!(V0.negTrack_as().trackType() & o2::aod::track::TPCrefit)) { + if (isK0SfromLc) { + LOG(INFO) << "negTrack " << labelNeg << " has no TPC refit"; + } continue; //TPC refit } } registry.fill(HIST("hGoodIndices"), 1.5); - if (V0.posTrack_as().tpcNClsCrossedRows() < mincrossedrows) { + if (V0.posTrack_as().tpcNClsCrossedRows() < mincrossedrows) { + if (isK0SfromLc) { + LOG(INFO) << "posTrack " << labelPos << " has " << V0.posTrack_as().tpcNClsCrossedRows() << " crossed rows, cut at " << mincrossedrows; + } continue; } - if (V0.negTrack_as().tpcNClsCrossedRows() < mincrossedrows) { - continue; + if (V0.negTrack_as().tpcNClsCrossedRows() < mincrossedrows) { + if (isK0SfromLc) { + LOG(INFO) << "negTrack " << labelNeg << " has " << V0.negTrack_as().tpcNClsCrossedRows() << " crossed rows, cut at " << mincrossedrows; + } + continue; } registry.fill(HIST("hGoodIndices"), 2.5); - if (fabs(V0.posTrack_as().dcaXY()) < dcapostopv) { + if (fabs(V0.posTrack_as().dcaXY()) < dcapostopv) { + if (isK0SfromLc) { + LOG(INFO) << "posTrack " << labelPos << " has dcaXY " << V0.posTrack_as().dcaXY() << " , cut at " << dcanegtopv; + } continue; } - if (fabs(V0.negTrack_as().dcaXY()) < dcanegtopv) { + if (fabs(V0.negTrack_as().dcaXY()) < dcanegtopv) { + if (isK0SfromLc) { + LOG(INFO) << "negTrack " << labelNeg << " has dcaXY " << V0.negTrack_as().dcaXY() << " , cut at " << dcanegtopv; continue; + } + } + if (isK0SfromLc) { + LOG(INFO) << "Filling good indices: posTrack --> " << labelPos << ", negTrack --> " << labelNeg; } registry.fill(HIST("hGoodIndices"), 3.5); - v0goodindices(V0.posTrack_as().globalIndex(), - V0.negTrack_as().globalIndex(), - V0.posTrack_as().collisionId()); + v0goodindices(V0.posTrack_as().globalIndex(), + V0.negTrack_as().globalIndex(), + V0.posTrack_as().collisionId()); + } } }; @@ -153,9 +216,13 @@ struct lambdakzerobuilder { double massKa = TDatabasePDG::Instance()->GetParticle(kKPlus)->Mass(); double massPr = TDatabasePDG::Instance()->GetParticle(kProton)->Mass(); + /* using FullTracksExt = soa::Join; - - void process(aod::Collision const& collision, aod::V0GoodIndices const& V0s, soa::Join const& tracks) + using BigTracks = soa::Join; + using BigTracksMC = soa::Join; + */ + //void process(aod::Collision const& collision, aod::V0GoodIndices const& V0s, soa::Join const& tracks, aod::McParticles const& particlesMC) + void process(aod::Collision const& collision, aod::V0GoodIndices const& V0s, BigTracksMC const& tracks, aod::McParticles const& particlesMC) { //Define o2 fitter, 2-prong o2::vertexing::DCAFitterN<2> fitter; @@ -176,11 +243,31 @@ struct lambdakzerobuilder { std::array pvec0 = {0.}; std::array pvec1 = {0.}; + auto labelPos = V0.posTrack_as().label().globalIndex(); + auto labelNeg = V0.negTrack_as().label().globalIndex(); + + bool isK0SfromLc = (labelPos == 27384 && labelNeg == 27385) || (labelPos == 981525 && labelNeg == 981526) || (labelPos == 1080007 && labelNeg == 1080008) || (labelPos == 1151717 && labelNeg == 1151718) || + (labelPos == 1354080 && labelNeg == 1354081) || (labelPos == 46082 && labelNeg == 46083) || (labelPos == 386994 && labelNeg == 386995) || (labelPos == 1032304 && labelNeg == 1032305) || + (labelPos == 1126617 && labelNeg == 1126618) || (labelPos == 1178152 && labelNeg == 1178153) || (labelPos == 1386973 && labelNeg == 1386974) || (labelPos == 18895 && labelNeg == 18896) || + (labelPos == 319531 && labelNeg == 319532) || (labelPos == 433387 && labelNeg == 433388) || (labelPos == 914299 && labelNeg == 914300) || (labelPos == 364270 && labelNeg == 364271) || + (labelPos == 922284 && labelNeg == 922285) || (labelPos == 49092 && labelNeg == 49093) || (labelPos == 841344 && labelNeg == 841345) || (labelPos == 1167214 && labelNeg == 1167215) || + (labelPos == 1257925 && labelNeg == 1257926) || (labelPos == 367299 && labelNeg == 367300) || (labelPos == 439094 && labelNeg == 439095) || (labelPos == 812984 && labelNeg == 812985) || + (labelPos == 1379705 && labelNeg == 1379706) || (labelPos == 62529 && labelNeg == 62530) || (labelPos == 299343 && labelNeg == 299344) || (labelPos == 492703 && labelNeg == 492704) || + (labelPos == 492681 && labelNeg == 492682) || (labelPos == 540846 && labelNeg == 540847) || (labelPos == 727710 && labelNeg == 727711) || (labelPos == 900248 && labelNeg == 900249) || + (labelPos == 653535 && labelNeg == 653536) || (labelPos == 759443 && labelNeg == 759444) || (labelPos == 192861 && labelNeg == 192862) || (labelPos == 1096815 && labelNeg == 1096816) || + (labelPos == 1373004 && labelNeg == 1373005) || (labelPos == 62878 && labelNeg == 62879) || (labelPos == 161866 && labelNeg == 161867) || (labelPos == 534341 && labelNeg == 534342) || + (labelPos == 806053 && labelNeg == 806054) || (labelPos == 1050897 && labelNeg == 1050898) || (labelPos == 1390049 && labelNeg == 1390050) || (labelPos == 6288 && labelNeg == 6289) || + (labelPos == 854422 && labelNeg == 854423) || (labelPos == 576590 && labelNeg == 576591) || (labelPos == 633388 && labelNeg == 633389) || (labelPos == 911572 && labelNeg == 911573) || + (labelPos == 995382 && labelNeg == 995383) || (labelPos == 119206 && labelNeg == 119207) || (labelPos == 725047 && labelNeg == 725048) || (labelPos == 762521 && labelNeg == 762522); + registry.fill(HIST("hV0Candidate"), 0.5); - auto pTrack = getTrackParCov(V0.posTrack_as()); - auto nTrack = getTrackParCov(V0.negTrack_as()); + auto pTrack = getTrackParCov(V0.posTrack_as()); + auto nTrack = getTrackParCov(V0.negTrack_as()); int nCand = fitter.process(pTrack, nTrack); + if (isK0SfromLc) { + LOG(INFO) << "fitter: nCand = " << nCand << " for posTrack --> " << labelPos << ", negTrack --> " << labelNeg; + } if (nCand != 0) { fitter.propagateTracksToVertex(); const auto& vtx = fitter.getPCACandidate(); @@ -193,33 +280,51 @@ struct lambdakzerobuilder { continue; } + if (isK0SfromLc) { + LOG(INFO) << "in builder 0: posTrack --> " << labelPos << ", negTrack --> " << labelNeg; + } + //Apply selections so a skimmed table is created only if (fitter.getChi2AtPCACandidate() > dcav0dau) { + if (isK0SfromLc) { + LOG(INFO) << "posTrack --> " << labelPos << ", negTrack --> " << labelNeg << " will be skipped due to dca cut"; + } continue; } auto V0CosinePA = RecoDecay::CPA(array{collision.posX(), collision.posY(), collision.posZ()}, array{pos[0], pos[1], pos[2]}, array{pvec0[0] + pvec1[0], pvec0[1] + pvec1[1], pvec0[2] + pvec1[2]}); if (V0CosinePA < v0cospa) { + if (isK0SfromLc) { + LOG(INFO) << "posTrack --> " << labelPos << ", negTrack --> " << labelNeg << " will be skipped due to CPA cut"; + } continue; } auto V0radius = RecoDecay::sqrtSumOfSquares(pos[0], pos[1]); //probably find better name to differentiate the cut from the variable + //LOG(INFO) << "V0radius of the candidate = " << V0radius << ", cut = " << v0radius; if (V0radius < v0radius) { + if (isK0SfromLc) { + LOG(INFO) << "posTrack --> " << labelPos << ", negTrack --> " << labelNeg << " will be skipped due to radius cut"; + } continue; } + if (isK0SfromLc) { + LOG(INFO) << "in builder 1, keeping K0S candidate: posTrack --> " << labelPos << ", negTrack --> " << labelNeg; + } + registry.fill(HIST("hV0Candidate"), 1.5); v0data( - V0.posTrack_as().globalIndex(), - V0.negTrack_as().globalIndex(), - V0.negTrack_as().collisionId(), + V0.posTrack_as().globalIndex(), + V0.negTrack_as().globalIndex(), + V0.negTrack_as().collisionId(), fitter.getTrack(0).getX(), fitter.getTrack(1).getX(), pos[0], pos[1], pos[2], pvec0[0], pvec0[1], pvec0[2], pvec1[0], pvec1[1], pvec1[2], fitter.getChi2AtPCACandidate(), - V0.posTrack_as().dcaXY(), - V0.negTrack_as().dcaXY()); + V0.posTrack_as().dcaXY(), + V0.negTrack_as().dcaXY()); } } }; From f890fd3226000ca0635ef834ffccf15b11ffb58a Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Mon, 8 Mar 2021 23:01:12 +0100 Subject: [PATCH 09/14] Update Lc -> K0S+p to do MC checks too. Adding also the possibility to do local debugging with an AO2D file from any production. format Stupid fix --- .../AnalysisDataModel/HFSecondaryVertex.h | 4 +- Analysis/Tasks/CMakeLists.txt | 1 + Analysis/Tasks/PWGHF/CMakeLists.txt | 9 +- .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 203 ++++++--------- .../Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx | 92 +++++-- .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 232 +++++++----------- Analysis/Tasks/PWGHF/taskLcK0sP.cxx | 47 ++-- Analysis/Tasks/PWGLF/CMakeLists.txt | 4 +- Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx | 192 ++++++--------- Analysis/Tasks/Utils/CMakeLists.txt | 13 + .../AnalysisTasksUtils/UtilsDebugLcK0Sp.h | 36 +++ 11 files changed, 389 insertions(+), 444 deletions(-) create mode 100644 Analysis/Tasks/Utils/CMakeLists.txt create mode 100644 Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h index 3cd428ee04ee8..e1b6f4fc825b1 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h @@ -44,7 +44,7 @@ using BigTracksMC = soa::Join; using BigTracksPID = soa::Join; -using V0DataExt = aod::V0DataExt; +using V0Datas = aod::V0Datas; // FIXME: this is a workaround until we get the index columns to work with joins. @@ -54,7 +54,7 @@ DECLARE_SOA_INDEX_COLUMN_FULL(Index0, index0, int, Tracks, "_0"); //! DECLARE_SOA_INDEX_COLUMN_FULL(Index1, index1, int, Tracks, "_1"); //! DECLARE_SOA_INDEX_COLUMN_FULL(Index2, index2, int, Tracks, "_2"); //! DECLARE_SOA_INDEX_COLUMN_FULL(Index3, index3, int, Tracks, "_3"); //! - DECLARE_SOA_INDEX_COLUMN_FULL(IndexV0, indexV0, int, V0DataExt, "_V0"); //! +DECLARE_SOA_INDEX_COLUMN_FULL(IndexV0, indexV0, int, V0Datas, "_V0"); //! DECLARE_SOA_COLUMN(HFflag, hfflag, uint8_t); //! DECLARE_SOA_COLUMN(D0ToKPiFlag, d0ToKPiFlag, uint8_t); //! diff --git a/Analysis/Tasks/CMakeLists.txt b/Analysis/Tasks/CMakeLists.txt index 970e02bdb2dd0..39b3f394b20ef 100644 --- a/Analysis/Tasks/CMakeLists.txt +++ b/Analysis/Tasks/CMakeLists.txt @@ -14,6 +14,7 @@ add_subdirectory(PWGHF) add_subdirectory(PWGJE) add_subdirectory(PWGLF) add_subdirectory(PWGUD) +add_subdirectory(Utils) add_subdirectory(SkimmingTutorials) add_subdirectory(PID) diff --git a/Analysis/Tasks/PWGHF/CMakeLists.txt b/Analysis/Tasks/PWGHF/CMakeLists.txt index 010d55e1a0f76..59be5fc31369a 100644 --- a/Analysis/Tasks/PWGHF/CMakeLists.txt +++ b/Analysis/Tasks/PWGHF/CMakeLists.txt @@ -25,7 +25,7 @@ o2_add_dpl_workflow(qa-simple o2_add_dpl_workflow(hf-track-index-skims-creator SOURCES HFTrackIndexSkimsCreator.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing ROOT::EG + PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing O2::AnalysisTasksUtils ROOT::EG COMPONENT_NAME Analysis) o2_add_dpl_workflow(hf-candidate-creator-2prong @@ -40,7 +40,7 @@ o2_add_dpl_workflow(hf-tree-creator-d0-tokpi o2_add_dpl_workflow(hf-candidate-creator-cascade SOURCES HFCandidateCreatorCascade.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing ROOT::EG + PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing O2::AnalysisTasksUtils ROOT::EG COMPONENT_NAME Analysis) o2_add_dpl_workflow(hf-candidate-creator-3prong @@ -80,7 +80,7 @@ o2_add_dpl_workflow(hf-xic-topkpi-candidate-selector o2_add_dpl_workflow(hf-lc-tok0sp-candidate-selector SOURCES HFLcK0sPCandidateSelector.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing + PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing O2::AnalysisTasksUtils COMPONENT_NAME Analysis) o2_add_dpl_workflow(hf-task-d0 @@ -125,5 +125,6 @@ o2_add_dpl_workflow(hf-mc-validation o2_add_dpl_workflow(hf-task-lc-tok0sp SOURCES taskLcK0sP.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing + PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing O2::AnalysisTasksUtils COMPONENT_NAME Analysis) + diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index 6e8a7e6a503db..ff922ff644c5a 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -18,6 +18,7 @@ #include "AnalysisCore/trackUtilities.h" #include "ReconstructionDataFormats/DCA.h" #include "ReconstructionDataFormats/V0.h" +#include "AnalysisTasksUtils/UtilsDebugLcK0Sp.h" using namespace o2; using namespace o2::framework; @@ -54,14 +55,28 @@ struct HFCandidateCreatorCascade { double massLc = RecoDecay::getMassPDG(4122); double mass2K0sP{0.}; + //#define MY_DEBUG + +#ifdef MY_DEBUG using MyTracks = aod::BigTracksMC; - //using MyTracks = aod::BigTracks; +#define MY_DEBUG_MSG(condition, cmd) \ + if (condition) { \ + cmd; \ + } +#else + using MyTracks = aod::BigTracks; +#define MY_DEBUG_MSG(condition, cmd) +#endif void process(aod::Collisions const& collisions, aod::HfTrackIndexCasc const& rowsTrackIndexCasc, MyTracks const& tracks, - aod::V0DataExt const& V0s, - aod::McParticles& mcParticles) + aod::V0Datas const& V0s +#ifdef MY_DEBUG + , + aod::McParticles& mcParticles +#endif + ) { // 2-prong vertex fitter o2::vertexing::DCAFitterN<2> df; @@ -77,37 +92,19 @@ struct HFCandidateCreatorCascade { for (const auto& casc : rowsTrackIndexCasc) { const auto& bach = casc.index0_as(); auto trackParCovBach = getTrackParCov(bach); - const auto& v0 = casc.indexV0_as(); + const auto& v0 = casc.indexV0_as(); const auto& posTrack = v0.posTrack_as(); const auto& negTrack = v0.negTrack_as(); - auto protonLabel = bach.labelId(); - auto labelPos = posTrack.labelId(); - auto labelNeg = negTrack.labelId(); - - bool isLc = (protonLabel == 27378 && labelPos == 27384 && labelNeg == 27385) || (protonLabel == 981514 && labelPos == 981525 && labelNeg == 981526) || (protonLabel == 1079941 && labelPos == 1080007 && labelNeg == 1080008) || - (protonLabel == 1151713 && labelPos == 1151717 && labelNeg == 1151718) || (protonLabel == 1354075 && labelPos == 1354080 && labelNeg == 1354081) || (protonLabel == 46077 && labelPos == 46082 && labelNeg == 46083) || - (protonLabel == 386988 && labelPos == 386994 && labelNeg == 386995) || (protonLabel == 1032251 && labelPos == 1032304 && labelNeg == 1032305) || (protonLabel == 1126614 && labelPos == 1126617 && labelNeg == 1126618) || - (protonLabel == 1178107 && labelPos == 1178152 && labelNeg == 1178153) || (protonLabel == 1386970 && labelPos == 1386973 && labelNeg == 1386974) || (protonLabel == 18733 && labelPos == 18895 && labelNeg == 18896) || - (protonLabel == 319481 && labelPos == 319531 && labelNeg == 319532) || (protonLabel == 433384 && labelPos == 433387 && labelNeg == 433388) || (protonLabel == 914259 && labelPos == 914299 && labelNeg == 914300) || - (protonLabel == 364214 && labelPos == 364270 && labelNeg == 364271) || (protonLabel == 922267 && labelPos == 922284 && labelNeg == 922285) || (protonLabel == 49070 && labelPos == 49092 && labelNeg == 49093) || - (protonLabel == 841303 && labelPos == 841344 && labelNeg == 841345) || (protonLabel == 1167211 && labelPos == 1167214 && labelNeg == 1167215) || (protonLabel == 1257919 && labelPos == 1257925 && labelNeg == 1257926) || - (protonLabel == 367228 && labelPos == 367299 && labelNeg == 367300) || (protonLabel == 439084 && labelPos == 439094 && labelNeg == 439095) || (protonLabel == 812970 && labelPos == 812984 && labelNeg == 812985) || - (protonLabel == 1379678 && labelPos == 1379705 && labelNeg == 1379706) || (protonLabel == 62526 && labelPos == 62529 && labelNeg == 62530) || (protonLabel == 299330 && labelPos == 299343 && labelNeg == 299344) || - (protonLabel == 492671 && labelPos == 492703 && labelNeg == 492704) || (protonLabel == 492678 && labelPos == 492681 && labelNeg == 492682) || (protonLabel == 540812 && labelPos == 540846 && labelNeg == 540847) || - (protonLabel == 727692 && labelPos == 727710 && labelNeg == 727711) || (protonLabel == 900211 && labelPos == 900248 && labelNeg == 900249) || (protonLabel == 653455 && labelPos == 653535 && labelNeg == 653536) || - (protonLabel == 759316 && labelPos == 759443 && labelNeg == 759444) || (protonLabel == 192853 && labelPos == 192861 && labelNeg == 192862) || (protonLabel == 1096808 && labelPos == 1096815 && labelNeg == 1096816) || - (protonLabel == 1373001 && labelPos == 1373004 && labelNeg == 1373005) || (protonLabel == 62875 && labelPos == 62878 && labelNeg == 62879) || (protonLabel == 161859 && labelPos == 161866 && labelNeg == 161867) || - (protonLabel == 534335 && labelPos == 534341 && labelNeg == 534342) || (protonLabel == 806033 && labelPos == 806053 && labelNeg == 806054) || (protonLabel == 1050891 && labelPos == 1050897 && labelNeg == 1050898) || - (protonLabel == 1390046 && labelPos == 1390049 && labelNeg == 1390050) || (protonLabel == 6268 && labelPos == 6288 && labelNeg == 6289) || (protonLabel == 854417 && labelPos == 854422 && labelNeg == 854423) || - (protonLabel == 576587 && labelPos == 576590 && labelNeg == 576591) || (protonLabel == 633385 && labelPos == 633388 && labelNeg == 633389) || (protonLabel == 911527 && labelPos == 911572 && labelNeg == 911573) || - (protonLabel == 995379 && labelPos == 995382 && labelNeg == 995383) || (protonLabel == 119194 && labelPos == 119206 && labelNeg == 119207) || (protonLabel == 724999 && labelPos == 725047 && labelNeg == 725048) || - (protonLabel == 762518 && labelPos == 762521 && labelNeg == 762522); - - if (isLc) { - LOG(INFO) << "Processing the Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg; - } - +#ifdef MY_DEBUG + auto protonLabel = bach.mcParticleId(); + auto labelPos = posTrack.mcParticleId(); + auto labelNeg = negTrack.mcParticleId(); + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg); +#endif + + MY_DEBUG_MSG(isLc, LOG(INFO) << "Processing the Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg); + auto posTrackParCov = getTrackParCov(posTrack); // check that MyTracks does not need TracksExtended! auto negTrackParCov = getTrackParCov(negTrack); // check that MyTracks does not need TracksExtended! posTrackParCov.propagateTo(v0.posX(), d_bZ); // propagate the track to the X closest to the V0 vertex @@ -121,14 +118,13 @@ struct HFCandidateCreatorCascade { // reconstruct the cascade secondary vertex if (df.process(trackV0, trackParCovBach) == 0) { - if (isLc) LOG(INFO) << "Vertexing failed for Lc candidate"; - // if (isLc) { - // LOG(INFO) << "Vertexing failed for Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg; - //} + MY_DEBUG_MSG(isLc, LOG(INFO) << "Vertexing failed for Lc candidate"); + // if (isLc) { + // LOG(INFO) << "Vertexing failed for Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg; + //} continue; - } - else { - //LOG(INFO) << "Vertexing succeeded for Lc candidate"; + } else { + //LOG(INFO) << "Vertexing succeeded for Lc candidate"; } const auto& secondaryVertex = df.getPCACandidate(); @@ -162,9 +158,7 @@ struct HFCandidateCreatorCascade { auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixPCA, phi, 0.)); // fill candidate table rows - if (isLc) { - LOG(INFO) << "IT IS A Lc! Filling for Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg; - } + MY_DEBUG_MSG(isLc, LOG(INFO) << "IT IS A Lc! Filling for Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg); rowCandidateBase(collision.posX(), collision.posY(), collision.posZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], errorDecayLength, errorDecayLengthXY, @@ -216,7 +210,7 @@ struct HFCandidateCreatorCascadeMC { std::vector arrDaughLcIndex; std::array arrDaughLcPDG; std::array arrDaughLcPDGRef = {2212, 211, -211}; - + // Match reconstructed candidates. for (auto& candidate : candidates) { auto arrayDaughtersV0 = array{candidate.posTrack_as(), candidate.negTrack_as()}; @@ -224,98 +218,53 @@ struct HFCandidateCreatorCascadeMC { // First we check the K0s printf("\n"); - LOG(INFO) << "Checking MC for candidate!"; + LOG(DEBUG) << "Checking MC for candidate!"; LOG(DEBUG) << "Looking for K0s"; - auto labelPos = candidate.posTrack_as().label().globalIndex(); - auto labelNeg = candidate.negTrack_as().label().globalIndex(); - auto protonLabel = candidate.index0_as().labelId(); - - bool isLc = (protonLabel == 27378 && labelPos == 27384 && labelNeg == 27385) || (protonLabel == 981514 && labelPos == 981525 && labelNeg == 981526) || (protonLabel == 1079941 && labelPos == 1080007 && labelNeg == 1080008) || - (protonLabel == 1151713 && labelPos == 1151717 && labelNeg == 1151718) || (protonLabel == 1354075 && labelPos == 1354080 && labelNeg == 1354081) || (protonLabel == 46077 && labelPos == 46082 && labelNeg == 46083) || - (protonLabel == 386988 && labelPos == 386994 && labelNeg == 386995) || (protonLabel == 1032251 && labelPos == 1032304 && labelNeg == 1032305) || (protonLabel == 1126614 && labelPos == 1126617 && labelNeg == 1126618) || - (protonLabel == 1178107 && labelPos == 1178152 && labelNeg == 1178153) || (protonLabel == 1386970 && labelPos == 1386973 && labelNeg == 1386974) || (protonLabel == 18733 && labelPos == 18895 && labelNeg == 18896) || - (protonLabel == 319481 && labelPos == 319531 && labelNeg == 319532) || (protonLabel == 433384 && labelPos == 433387 && labelNeg == 433388) || (protonLabel == 914259 && labelPos == 914299 && labelNeg == 914300) || - (protonLabel == 364214 && labelPos == 364270 && labelNeg == 364271) || (protonLabel == 922267 && labelPos == 922284 && labelNeg == 922285) || (protonLabel == 49070 && labelPos == 49092 && labelNeg == 49093) || - (protonLabel == 841303 && labelPos == 841344 && labelNeg == 841345) || (protonLabel == 1167211 && labelPos == 1167214 && labelNeg == 1167215) || (protonLabel == 1257919 && labelPos == 1257925 && labelNeg == 1257926) || - (protonLabel == 367228 && labelPos == 367299 && labelNeg == 367300) || (protonLabel == 439084 && labelPos == 439094 && labelNeg == 439095) || (protonLabel == 812970 && labelPos == 812984 && labelNeg == 812985) || - (protonLabel == 1379678 && labelPos == 1379705 && labelNeg == 1379706) || (protonLabel == 62526 && labelPos == 62529 && labelNeg == 62530) || (protonLabel == 299330 && labelPos == 299343 && labelNeg == 299344) || - (protonLabel == 492671 && labelPos == 492703 && labelNeg == 492704) || (protonLabel == 492678 && labelPos == 492681 && labelNeg == 492682) || (protonLabel == 540812 && labelPos == 540846 && labelNeg == 540847) || - (protonLabel == 727692 && labelPos == 727710 && labelNeg == 727711) || (protonLabel == 900211 && labelPos == 900248 && labelNeg == 900249) || (protonLabel == 653455 && labelPos == 653535 && labelNeg == 653536) || - (protonLabel == 759316 && labelPos == 759443 && labelNeg == 759444) || (protonLabel == 192853 && labelPos == 192861 && labelNeg == 192862) || (protonLabel == 1096808 && labelPos == 1096815 && labelNeg == 1096816) || - (protonLabel == 1373001 && labelPos == 1373004 && labelNeg == 1373005) || (protonLabel == 62875 && labelPos == 62878 && labelNeg == 62879) || (protonLabel == 161859 && labelPos == 161866 && labelNeg == 161867) || - (protonLabel == 534335 && labelPos == 534341 && labelNeg == 534342) || (protonLabel == 806033 && labelPos == 806053 && labelNeg == 806054) || (protonLabel == 1050891 && labelPos == 1050897 && labelNeg == 1050898) || - (protonLabel == 1390046 && labelPos == 1390049 && labelNeg == 1390050) || (protonLabel == 6268 && labelPos == 6288 && labelNeg == 6289) || (protonLabel == 854417 && labelPos == 854422 && labelNeg == 854423) || - (protonLabel == 576587 && labelPos == 576590 && labelNeg == 576591) || (protonLabel == 633385 && labelPos == 633388 && labelNeg == 633389) || (protonLabel == 911527 && labelPos == 911572 && labelNeg == 911573) || - (protonLabel == 995379 && labelPos == 995382 && labelNeg == 995383) || (protonLabel == 119194 && labelPos == 119206 && labelNeg == 119207) || (protonLabel == 724999 && labelPos == 725047 && labelNeg == 725048) || - (protonLabel == 762518 && labelPos == 762521 && labelNeg == 762522); - //if (labelPos == 27384 || labelPos == 981525 || labelPos == 1080007 || labelPos == 1151717 || labelPos == 1354080 || labelPos == 46082 || labelPos == 386994 || labelPos == 1032304 || labelPos == 1126617 || labelPos == 1178152 || labelPos == 1386973 || labelPos == 18895 || labelPos == 319531 || labelPos == 433387 || labelPos == 914299 || labelPos == 364270 || labelPos == 922284 || labelPos == 49092 || labelPos == 841344 || labelPos == 1167214 || labelPos == 1257925 || labelPos == 367299 || labelPos == 439094 || labelPos == 812984 || labelPos == 1379705 || labelPos == 62529 || labelPos == 299343 || labelPos == 492703 || labelPos == 492681 || labelPos == 540846 || labelPos == 727710 || labelPos == 900248 || labelPos == 653535 || labelPos == 759443 || labelPos == 192861 || labelPos == 1096815 || labelPos == 1373004 || labelPos == 62878 || labelPos == 161866 || labelPos == 534341 || labelPos == 806053 || labelPos == 1050897 || labelPos == 1390049 || labelPos == 6288 || labelPos == 854422 || labelPos == 576590 || labelPos == 633388 || labelPos == 911572 || labelPos == 995382 || labelPos == 119206 || labelPos == 725047 || labelPos == 762521 || - // labelNeg == 27385 || labelNeg == 981526 || labelNeg == 1080008 || labelNeg == 1151718 || labelNeg == 1354081 || labelNeg == 46083 || labelNeg == 386995 || labelNeg == 1032305 || labelNeg == 1126618 || labelNeg == 1178153 || labelNeg == 1386974 || labelNeg == 18896 || labelNeg == 319532 || labelNeg == 433388 || labelNeg == 914300 || labelNeg == 364271 || labelNeg == 922285 || labelNeg == 49093 || labelNeg == 841345 || labelNeg == 1167215 || labelNeg == 1257926 || labelNeg == 367300 || labelNeg == 439095 || labelNeg == 812985 || labelNeg == 1379706 || labelNeg == 62530 || labelNeg == 299344 || labelNeg == 492704 || labelNeg == 492682 || labelNeg == 540847 || labelNeg == 727711 || labelNeg == 900249 || labelNeg == 653536 || labelNeg == 759444 || labelNeg == 192862 || labelNeg == 1096816 || labelNeg == 1373005 || labelNeg == 62879 || labelNeg == 161867 || labelNeg == 534342 || labelNeg == 806054 || labelNeg == 1050898 || labelNeg == 1390050 || labelNeg == 6289 || labelNeg == 854423 || labelNeg == 576591 || labelNeg == 633389 || labelNeg == 911573 || labelNeg == 995383 || labelNeg == 119207 || labelNeg == 725048 || labelNeg == 762522){ - if ((labelPos == 27384 && labelNeg == 27385) || (labelPos == 981525 && labelNeg == 981526) || (labelPos == 1080007 && labelNeg == 1080008) || (labelPos == 1151717 && labelNeg == 1151718) || - (labelPos == 1354080 && labelNeg == 1354081) || (labelPos == 46082 && labelNeg == 46083) || (labelPos == 386994 && labelNeg == 386995) || (labelPos == 1032304 && labelNeg == 1032305) || - (labelPos == 1126617 && labelNeg == 1126618) || (labelPos == 1178152 && labelNeg == 1178153) || (labelPos == 1386973 && labelNeg == 1386974) || (labelPos == 18895 && labelNeg == 18896) || - (labelPos == 319531 && labelNeg == 319532) || (labelPos == 433387 && labelNeg == 433388) || (labelPos == 914299 && labelNeg == 914300) || (labelPos == 364270 && labelNeg == 364271) || - (labelPos == 922284 && labelNeg == 922285) || (labelPos == 49092 && labelNeg == 49093) || (labelPos == 841344 && labelNeg == 841345) || (labelPos == 1167214 && labelNeg == 1167215) || - (labelPos == 1257925 && labelNeg == 1257926) || (labelPos == 367299 && labelNeg == 367300) || (labelPos == 439094 && labelNeg == 439095) || (labelPos == 812984 && labelNeg == 812985) || - (labelPos == 1379705 && labelNeg == 1379706) || (labelPos == 62529 && labelNeg == 62530) || (labelPos == 299343 && labelNeg == 299344) || (labelPos == 492703 && labelNeg == 492704) || - (labelPos == 492681 && labelNeg == 492682) || (labelPos == 540846 && labelNeg == 540847) || (labelPos == 727710 && labelNeg == 727711) || (labelPos == 900248 && labelNeg == 900249) || - (labelPos == 653535 && labelNeg == 653536) || (labelPos == 759443 && labelNeg == 759444) || (labelPos == 192861 && labelNeg == 192862) || (labelPos == 1096815 && labelNeg == 1096816) || - (labelPos == 1373004 && labelNeg == 1373005) || (labelPos == 62878 && labelNeg == 62879) || (labelPos == 161866 && labelNeg == 161867) || (labelPos == 534341 && labelNeg == 534342) || - (labelPos == 806053 && labelNeg == 806054) || (labelPos == 1050897 && labelNeg == 1050898) || (labelPos == 1390049 && labelNeg == 1390050) || (labelPos == 6288 && labelNeg == 6289) || - (labelPos == 854422 && labelNeg == 854423) || (labelPos == 576590 && labelNeg == 576591) || (labelPos == 633388 && labelNeg == 633389) || (labelPos == 911572 && labelNeg == 911573) || - (labelPos == 995382 && labelNeg == 995383) || (labelPos == 119206 && labelNeg == 119207) || (labelPos == 725047 && labelNeg == 725048) || (labelPos == 762521 && labelNeg == 762522)) { - LOG(INFO) << "correct K0S in the Lc daughters: posTrack --> " << labelPos << ", negTrack --> " << labelNeg; - } + auto labelPos = candidate.posTrack_as().mcParticleId(); + auto labelNeg = candidate.negTrack_as().mcParticleId(); + auto protonLabel = candidate.index0_as().mcParticleId(); + + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg); + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "correct K0S in the Lc daughters: posTrack --> " << labelPos << ", negTrack --> " << labelNeg); //if (isLc) { - RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, 310, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s - - if (sign != 0) { // we have already positively checked the K0s - // then we check the Lc - LOG(INFO) << "K0S was correct! now we check the Lc"; - auto labelProton = candidate.index0_as().label().globalIndex(); - LOG(INFO) << "label proton = " << labelProton; - LOG(DEBUG) << "Looking for Lc"; - RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersLc, 4122, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); // 3-levels Lc --> p + K0 --> p + K0s --> p + pi+ pi- - if (sign == 0) { - LOG(INFO) << "No true Lc found"; - } - else { - LOG(INFO) << "Lc found with sign " << sign; - } - printf("\n"); - } - - rowMCMatchRec(sign); + RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, 310, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s + + if (sign != 0) { // we have already positively checked the K0s + // then we check the Lc + MY_DEBUG_MSG(sign, LOG(INFO) << "K0S was correct! now we check the Lc"); + auto labelProton = candidate.index0_as().mcParticleId(); + MY_DEBUG_MSG(sign, LOG(INFO) << "label proton = " << labelProton); + RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersLc, 4122, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); // 3-levels Lc --> p + K0 --> p + K0s --> p + pi+ pi- + MY_DEBUG_MSG(sign, LOG(INFO) << "Lc found with sign " << sign; printf("\n")); } + + rowMCMatchRec(sign); + } //} - + // Match generated particles. for (auto& particle : particlesMC) { // checking if I have a Lc --> K0S + p RecoDecay::isMatchedMCGen(particlesMC, particle, 4122, array{+kProton, 310}, true, &sign, 2); if (sign != 0) { - LOG(INFO) << "Lc in K0S p"; - arrDaughLcIndex.clear(); - // checking that the final daughters (decay depth = 3) are p, pi+, pi- - RecoDecay::getDaughters(particlesMC, particle.globalIndex(), &arrDaughLcIndex, arrDaughLcPDGRef, 3); // best would be to check the K0S daughters - LOG(INFO) << "arrDaughLcIndex.size() = " << arrDaughLcIndex.size(); - if (arrDaughLcIndex.size() == 3) { - for (auto iProng = 0; iProng < arrDaughLcIndex.size(); ++iProng) { - auto daughI = particlesMC.iteratorAt(arrDaughLcIndex[iProng]); - arrDaughLcPDG[iProng] = daughI.pdgCode(); - } - if (!(arrDaughLcPDG[0] == arrDaughLcPDGRef[0] && arrDaughLcPDG[1] == arrDaughLcPDGRef[1] && arrDaughLcPDG[2] == arrDaughLcPDGRef[2])) { // this should be the condition, first bach, then v0 - LOG(INFO) << "Pity, the three final daughters are not p, pi+, pi-, but " << arrDaughLcPDG[0] << ", " << arrDaughLcPDG[1] << ", " << arrDaughLcPDG[2]; - sign = 0; - } - else { - LOG(INFO) << " YU-HUUUUU!"; - } - } - //RecoDecay::isMatchedMCGen(particlesMC, particle, 4122, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); - //if (sign !=0) { - // LOG(INFO) << "Lc in p pi+ pi-"; - //} + MY_DEBUG_MSG(sign, LOG(INFO) << "Lc in K0S p"); + arrDaughLcIndex.clear(); + // checking that the final daughters (decay depth = 3) are p, pi+, pi- + RecoDecay::getDaughters(particlesMC, particle.globalIndex(), &arrDaughLcIndex, arrDaughLcPDGRef, 3); // best would be to check the K0S daughters + if (arrDaughLcIndex.size() == 3) { + for (auto iProng = 0; iProng < arrDaughLcIndex.size(); ++iProng) { + auto daughI = particlesMC.iteratorAt(arrDaughLcIndex[iProng]); + arrDaughLcPDG[iProng] = daughI.pdgCode(); + } + if (!(arrDaughLcPDG[0] == arrDaughLcPDGRef[0] && arrDaughLcPDG[1] == arrDaughLcPDGRef[1] && arrDaughLcPDG[2] == arrDaughLcPDGRef[2])) { // this should be the condition, first bach, then v0 + sign = 0; + } else { + LOG(INFO) << "Lc --> K0S+p found in MC table"; + } + MY_DEBUG_MSG(sign == 0, LOG(INFO) << "Pity, the three final daughters are not p, pi+, pi-, but " << arrDaughLcPDG[0] << ", " << arrDaughLcPDG[1] << ", " << arrDaughLcPDG[2]); + } } rowMCMatchGen(sign); } @@ -327,11 +276,11 @@ struct HFCandidateCreatorCascadeMC { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { WorkflowSpec workflow{ - adaptAnalysisTask("hf-cand-creator-cascade"), - adaptAnalysisTask("hf-cand-creator-cascade-expressions")}; + adaptAnalysisTask(cfgc, "hf-cand-creator-cascade"), + adaptAnalysisTask(cfgc, "hf-cand-creator-cascade-expressions")}; const bool doMC = cfgc.options().get("doMC"); if (doMC) { - workflow.push_back(adaptAnalysisTask("hf-cand-creator-cascade-mc")); + workflow.push_back(adaptAnalysisTask(cfgc, "hf-cand-creator-cascade-mc")); } return workflow; } diff --git a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx index 4f75062dca9bf..3651ded968d81 100644 --- a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx +++ b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx @@ -19,6 +19,7 @@ #include "Framework/AnalysisTask.h" #include "AnalysisDataModel/HFSecondaryVertex.h" #include "AnalysisDataModel/HFCandidateSelectionTables.h" +#include "AnalysisTasksUtils/UtilsDebugLcK0Sp.h" using namespace o2; using namespace o2::framework; @@ -28,16 +29,29 @@ static const int nPtBins = 8; static const int nCutVars = 8; //temporary until 2D array in configurable is solved - then move to json //mK0s(GeV) mLambdas(GeV) mGammas(GeV) ptp ptK0sdau pTLc d0p d0K0 -constexpr double cuts[nPtBins][nCutVars] = {{0.008, 0.005, 0.1, 0.5, 0.3, 0.6, 0.05, 999999}, // 1 < pt < 2 - {0.008, 0.005, 0.1, 0.5, 0.4, 1.3, 0.05, 999999}, // 2 < pt < 3 - {0.009, 0.005, 0.1, 0.6, 0.4, 1.3, 0.05, 999999}, // 3 < pt < 4 - {0.011, 0.005, 0.1, 0.6, 0.4, 1.4, 0.05, 999999}, // 4 < pt < 5 - {0.013, 0.005, 0.1, 0.6, 0.4, 1.4, 0.06, 999999}, // 5 < pt < 6 - {0.013, 0.005, 0.1, 0.9, 0.4, 1.6, 0.09, 999999}, // 6 < pt < 8 - {0.016, 0.005, 0.1, 0.9, 0.4, 1.7, 0.10, 999999}, // 8 < pt < 12 - {0.019, 0.005, 0.1, 1.0, 0.4, 1.9, 0.20, 999999}}; // 12 < pt < 24 +constexpr double cuts[nPtBins][nCutVars] = {{0.008, 0.005, 0.1, 0.5, 0.3, 0.6, 0.05, 999999.}, // 1 < pt < 2 + {0.008, 0.005, 0.1, 0.5, 0.4, 1.3, 0.05, 999999.}, // 2 < pt < 3 + {0.009, 0.005, 0.1, 0.6, 0.4, 1.3, 0.05, 999999.}, // 3 < pt < 4 + {0.011, 0.005, 0.1, 0.6, 0.4, 1.4, 0.05, 999999.}, // 4 < pt < 5 + {0.013, 0.005, 0.1, 0.6, 0.4, 1.4, 0.06, 999999.}, // 5 < pt < 6 + {0.013, 0.005, 0.1, 0.9, 0.4, 1.6, 0.09, 999999.}, // 6 < pt < 8 + {0.016, 0.005, 0.1, 0.9, 0.4, 1.7, 0.10, 999999.}, // 8 < pt < 12 + {0.019, 0.005, 0.1, 1.0, 0.4, 1.9, 0.20, 999999.}}; // 12 < pt < 24 /// Struct for applying D0 selection cuts +//#define MY_DEBUG + +#ifdef MY_DEBUG +#define MY_DEBUG_MSG(condition, cmd) \ + if (condition) { \ + cmd; \ + } +using MyBigTracks = soa::Join; +#else +#define MY_DEBUG_MSG(condition, cmd) +using MyBigTracks = aod::BigTracksPID; +#endif + struct HFLcK0sPCandidateSelector { Produces hfSelLcK0sPCandidate; @@ -46,6 +60,7 @@ struct HFLcK0sPCandidateSelector { Configurable d_pTCandMax{"d_pTCandMax", 50., "Upper bound of candidate pT"}; // PID + Configurable d_applyPidTPCMinPt{"d_applyPidTPCMinPt", 4., "Lower bound of track pT to apply TPC PID"}; Configurable d_pidTPCMinPt{"d_pidTPCMinPt", 0., "Lower bound of track pT for TPC PID"}; Configurable d_pidTPCMaxPt{"d_pidTPCMaxPt", 100., "Upper bound of track pT for TPC PID"}; Configurable d_pidCombMaxP{"d_pidCombMaxP", 4., "Upper bound of track p to use TOF + TPC Bayes PID"}; @@ -82,7 +97,7 @@ struct HFLcK0sPCandidateSelector { template bool daughterSelection(const T& track) // aren't these checks already in the indexskimscreator? { - if (track.charge() == 0) { + if (track.sign() == 0) { return false; } if (b_requireTPC.value && track.tpcNClsFound() == 0) { @@ -155,7 +170,7 @@ struct HFLcK0sPCandidateSelector { } */ - if (std::abs(hfCandCascade.impactParameter1()) > cuts[ptBin][6]) { + if (std::abs(hfCandCascade.impactParameter1()) > cuts[ptBin][7]) { LOG(DEBUG) << "d0 v0 cut failed, in cascade --> " << hfCandCascade.impactParameter1() << ", cut --> " << cuts[ptBin][7]; return false; // d0 of the v0 } @@ -171,9 +186,24 @@ struct HFLcK0sPCandidateSelector { bool validTPCPID(const T& track) { if (TMath::Abs(track.pt()) < d_pidTPCMinPt || TMath::Abs(track.pt()) >= d_pidTPCMaxPt) { + LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we trust TPC PID in [" << d_pidTPCMinPt << ", " << d_pidTPCMaxPt << "]"; + return false; + } + return true; + } + + /// Check if we will use TPC PID + /// \param track is the track + /// \note function to be expanded + /// \return true if track is ok for TPC PID + template + bool applyTPCPID(const T& track) + { + if (TMath::Abs(track.pt()) < d_applyPidTPCMinPt) { + LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we apply TPC PID from " << d_applyPidTPCMinPt; return false; } - //if (track.TPCNClsFindable() < d_TPCNClsFindablePIDCut) return false; + LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we apply TPC PID from " << d_applyPidTPCMinPt; return true; } @@ -201,7 +231,8 @@ struct HFLcK0sPCandidateSelector { { double nSigma = 100.0; //arbitarily large value nSigma = track.tpcNSigmaPr(); - return std::abs(nSigma) > nSigmaCut; + LOG(DEBUG) << "nSigma for bachelor = " << nSigma << ", cut at " << nSigmaCut; + return std::abs(nSigma) < nSigmaCut; } /* @@ -238,7 +269,13 @@ struct HFLcK0sPCandidateSelector { int statusTPC = -1; // int statusTOF = -1; + if (!applyTPCPID(track)) { + // we do not apply TPC PID in this range + return 1; + } + if (validTPCPID(track)) { + LOG(DEBUG) << "We check the TPC PID now"; if (!selectionPIDTPC(track, d_nSigmaTPC)) { statusTPC = 0; /* @@ -284,24 +321,34 @@ struct HFLcK0sPCandidateSelector { */ } - void process(aod::HfCandCascade const& hfCandCascades, aod::BigTracksPID const& tracks) + void process(aod::HfCandCascade const& candidates, MyBigTracks const& tracks) { int statusLc = 0; // final selection flag : 0-rejected 1-accepted bool topolLc = 0; int pidProton = -1; int pidLc = -1; - for (auto& hfCandCasc : hfCandCascades) { //looping over 2 prong candidates + for (auto& candidate : candidates) { //looping over cascade candidates + +#ifdef MY_DEBUG + auto labelPos = candidate.posTrack_as().mcParticleId(); + auto labelNeg = candidate.negTrack_as().mcParticleId(); + auto protonLabel = candidate.index0_as().mcParticleId(); + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg); +#endif + MY_DEBUG_MSG(isLc, printf("\n"); LOG(INFO) << "In selector: correct Lc found: proton --> " << protonLabel << ", posTrack --> " << labelPos << ", negTrack --> " << labelNeg); + //MY_DEBUG_MSG(isLc != 1, printf("\n"); LOG(INFO) << "In selector: wrong Lc found: proton --> " << protonLabel << ", posTrack --> " << labelPos << ", negTrack --> " << labelNeg); statusLc = 0; /* // not needed for the Lc - if (!(hfCandCasc.hfflag() & 1 << D0ToPiK)) { + if (!(candidate.hfflag() & 1 << D0ToPiK)) { hfSelD0Candidate(statusLc); continue; } */ - const auto& bach = hfCandCasc.index0_as(); //bachelor track + const auto& bach = candidate.index0_as(); //bachelor track topolLc = true; pidProton = -1; @@ -309,14 +356,16 @@ struct HFLcK0sPCandidateSelector { // daughter track validity selection LOG(DEBUG) << "daughterSelection(bach) = " << daughterSelection(bach); if (!daughterSelection(bach)) { + MY_DEBUG_MSG(isLc, LOG(INFO) << "In selector: Lc rejected due to selections on bachelor"); hfSelLcK0sPCandidate(statusLc); continue; } //implement filter bit 4 cut - should be done before this task at the track selection level //need to add special cuts (additional cuts on decay length and d0 norm) - LOG(DEBUG) << "selectionTopol(hfCandCasc) = " << selectionTopol(hfCandCasc); - if (!selectionTopol(hfCandCasc)) { + LOG(DEBUG) << "selectionTopol(candidate) = " << selectionTopol(candidate); + if (!selectionTopol(candidate)) { + MY_DEBUG_MSG(isLc, LOG(INFO) << "In selector: Lc rejected due to topological selections"); hfSelLcK0sPCandidate(statusLc); continue; } @@ -329,13 +378,16 @@ struct HFLcK0sPCandidateSelector { statusLc = 1; } + MY_DEBUG_MSG(isLc && pidProton != 1, LOG(INFO) << "In selector: Lc rejected due to PID selections on bachelor"); + MY_DEBUG_MSG(isLc && pidProton == 1, LOG(INFO) << "In selector: Lc ACCEPTED"); + hfSelLcK0sPCandidate(statusLc); } } }; -WorkflowSpec defineDataProcessing(ConfigContext const&) +WorkflowSpec defineDataProcessing(ConfigContext const& cfcg) { return WorkflowSpec{ - adaptAnalysisTask("hf-lc-tok0sp-candidate-selector")}; + adaptAnalysisTask(cfcg, "hf-lc-tok0sp-candidate-selector")}; } diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index c7ec32e33c3b0..415d8765481b2 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -25,6 +25,7 @@ #include "AnalysisDataModel/StrangenessTables.h" #include "AnalysisDataModel/TrackSelectionTables.h" #include "ReconstructionDataFormats/V0.h" +#include "AnalysisTasksUtils/UtilsDebugLcK0Sp.h" #include @@ -43,6 +44,21 @@ void customize(std::vector& workflowOptions) #include "Framework/runDataProcessing.h" +//#define MY_DEBUG + +#ifdef MY_DEBUG +using MY_TYPE1 = soa::Join; +using MyTracks = soa::Join; +#define MY_DEBUG_MSG(condition, cmd) \ + if (condition) { \ + cmd; \ + } +#else +using MY_TYPE1 = soa::Join; +using MyTracks = soa::Join; +#define MY_DEBUG_MSG(condition, cmd) +#endif + /// Track selection struct SelectTracks { @@ -124,20 +140,24 @@ struct SelectTracks { } void process(aod::Collision const& collision, - soa::Join const& tracks, - aod::McParticles& mcParticles) + MY_TYPE1 const& tracks +#ifdef MY_DEBUG + , + aod::McParticles& mcParticles +#endif + ) { math_utils::Point3D vtxXYZ(collision.posX(), collision.posY(), collision.posZ()); for (auto& track : tracks) { - auto protonLabel = track.labelId(); +#ifdef MY_DEBUG + auto protonLabel = track.mcParticleId(); // LOG(INFO) << "Checking label " << protonLabel; - bool isProtonFromLc = (protonLabel == 27378) || (protonLabel == 981514) || (protonLabel == 1079941) || (protonLabel == 1151713) || (protonLabel == 1354075) || (protonLabel == 46077) || (protonLabel == 386988) || (protonLabel == 1032251) || (protonLabel == 1126614) || (protonLabel == 1178107) || (protonLabel == 1386970) || (protonLabel == 18733) || (protonLabel == 319481) || (protonLabel == 433384) || (protonLabel == 914259) || (protonLabel == 364214) || (protonLabel == 922267) || (protonLabel == 49070) || (protonLabel == 841303) || (protonLabel == 1167211) || (protonLabel == 1257919) || (protonLabel == 367228) || (protonLabel == 439084) || (protonLabel == 812970) || (protonLabel == 1379678) || (protonLabel == 62526) || (protonLabel == 299330) || (protonLabel == 492671) || (protonLabel == 492678) || (protonLabel == 540812) || (protonLabel == 727692) || (protonLabel == 900211) || (protonLabel == 653455) || (protonLabel == 759316) || (protonLabel == 192853) || (protonLabel == 1096808) || (protonLabel == 1373001) || (protonLabel == 62875) || (protonLabel == 161859) || (protonLabel == 534335) || (protonLabel == 806033) || (protonLabel == 1050891) || (protonLabel == 1390046) || (protonLabel == 6268) || (protonLabel == 854417) || (protonLabel == 576587) || (protonLabel == 633385) || (protonLabel == 911527) || (protonLabel == 995379) || (protonLabel == 119194) || (protonLabel == 724999) || (protonLabel == 762518); + bool isProtonFromLc = isProtonFromLcFunc(protonLabel); - if (isProtonFromLc) { - LOG(INFO) << "\nWe found the proton " << protonLabel; - } - +#endif + + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "\nWe found the proton " << protonLabel); int status_prong = 7; // selection flag , 3 bits on @@ -153,9 +173,8 @@ struct SelectTracks { if (trackPt < ptmintrack_3prong) { status_prong = status_prong & ~(1 << 1); } - if (isProtonFromLc) { - LOG(INFO) << "proton " << protonLabel << " pt = " << track.pt() << " (cut " << d_ptMinTrackBach << ")"; - } + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " pt = " << track.pt() << " (cut " << d_ptMinTrackBach << ")"); + if (track.pt() < d_ptMinTrackBach) { status_prong = status_prong & ~(1 << 2); } @@ -168,26 +187,22 @@ struct SelectTracks { if ((status_prong & (1 << 1)) && abs(trackEta) > etamax_3prong) { status_prong = status_prong & ~(1 << 1); } - if (isProtonFromLc) { - LOG(INFO) << "proton " << protonLabel << " eta = " << track.eta() << " (cut " << d_etaMaxBach << ")"; - } + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " eta = " << track.eta() << " (cut " << d_etaMaxBach << ")"); + if ((status_prong & (1 << 2)) && abs(track.eta()) > d_etaMaxBach) { status_prong = status_prong & ~(1 << 2); } // quality cut - if (isProtonFromLc) { - LOG(INFO) << "proton " << protonLabel << " tpcNClsFound = " << track.tpcNClsFound() << " (cut " << d_tpcnclsfound.value << ")"; - } + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " tpcNClsFound = " << track.tpcNClsFound() << " (cut " << d_tpcnclsfound.value << ")"); + if (doCutQuality.value && status_prong > 0) { // FIXME to make a more complete selection e.g track.flags() & o2::aod::track::TPCrefit && track.flags() & o2::aod::track::GoldenChi2 && UChar_t clustermap = track.itsClusterMap(); if (!(track.tpcNClsFound() >= d_tpcnclsfound.value && // is this the number of TPC clusters? It should not be used track.flags() & o2::aod::track::ITSrefit && (TESTBIT(clustermap, 0) || TESTBIT(clustermap, 1)))) { status_prong = 0; - if (isProtonFromLc) { - LOG(INFO) << "proton " << protonLabel << " did not pass clusters cut" ; - } + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " did not pass clusters cut"); } } @@ -212,16 +227,13 @@ struct SelectTracks { status_prong = status_prong & ~(1 << 1); } if ((status_prong & (1 << 2)) && (abs(dca[0]) < d_dcaToPrimXYMinBach_ptDep || abs(dca[0]) > d_dcaToPrimXYMaxBach)) { - if (isProtonFromLc) { - LOG(INFO) << "proton " << protonLabel << " did not pass DCA cut"; - LOG(INFO) << "dca[0] = " << dca[0] << " (lower cut " << d_dcaToPrimXYMinBach_ptDep << ", upper cut " << d_dcaToPrimXYMaxBach << ")"; - } + MY_DEBUG_MSG(isProtonFromLc, + LOG(INFO) << "proton " << protonLabel << " did not pass DCA cut"; + LOG(INFO) << "dca[0] = " << dca[0] << " (lower cut " << d_dcaToPrimXYMinBach_ptDep << ", upper cut " << d_dcaToPrimXYMaxBach << ")";); status_prong = status_prong & ~(1 << 2); } } - if (isProtonFromLc) { - LOG(INFO) << "status_prong = " << status_prong; - } + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "status_prong = " << status_prong; printf("\n")); // fill histograms if (b_dovalplots) { @@ -236,9 +248,7 @@ struct SelectTracks { registry.get(HIST("heta_cuts_3prong"))->Fill(trackEta); } if (status_prong & (1 << 2)) { - if (isProtonFromLc) { - LOG(INFO) << "Will be kept: Proton from Lc " << protonLabel; - } + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "Will be kept: Proton from Lc " << protonLabel); registry.get(HIST("hpt_cuts_bach"))->Fill(trackPt); registry.get(HIST("hdcatoprimxy_cuts_bach"))->Fill(dca[0]); registry.get(HIST("heta_cuts_bach"))->Fill(trackEta); @@ -1045,10 +1055,9 @@ struct HFTrackIndexSkimsCreatorCascades { {"hmass2", "2-prong candidates;inv. mass (K0s p) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0., 5.}}}}}}; // NB: using FullTracks = soa::Join; defined in Framework/Core/include/Framework/AnalysisDataModel.h - using MyTracks = soa::Join; //using MyTracks = aod::BigTracksMC; //Partition selectedTracks = aod::hf_seltrack::isSelProng >= 4; - // using SelectedV0s = soa::Filtered; + // using SelectedV0s = soa::Filtered; double massP = RecoDecay::getMassPDG(kProton); double massK0s = RecoDecay::getMassPDG(kK0Short); @@ -1056,17 +1065,18 @@ struct HFTrackIndexSkimsCreatorCascades { double massLc = RecoDecay::getMassPDG(4122); double mass2K0sP{0.}; // WHY HERE? - // Filter filterV0s = aod::v0data::dcapostopv > dcapostopv && - // aod::v0data::dcanegtopv > dcanegtopv; // add here the cuts on the V0s - using FullTracksExt = soa::Join; void process(aod::Collision const& collision, aod::BCs const& bcs, - //soa::Filtered const& V0s, - aod::V0DataExt const& V0s, - MyTracks const& tracks, - aod::McParticles& mcParticles) // TODO: I am now assuming that the V0s are already filtered with my cuts (David's work to come) + //soa::Filtered const& V0s, + aod::V0Datas const& V0s, + MyTracks const& tracks +#ifdef MY_DEBUG + , + aod::McParticles& mcParticles +#endif + ) // TODO: I am now assuming that the V0s are already filtered with my cuts (David's work to come) { //Define o2 fitter, 2-prong @@ -1085,104 +1095,63 @@ struct HFTrackIndexSkimsCreatorCascades { //for (const auto& bach : selectedTracks) { for (const auto& bach : tracks) { - auto protonLabel = bach.labelId(); - bool isProtonFromLc = (protonLabel == 27378) || (protonLabel == 981514) || (protonLabel == 1079941) || (protonLabel == 1151713) || (protonLabel == 1354075) || (protonLabel == 46077) || (protonLabel == 386988) || (protonLabel == 1032251) || (protonLabel == 1126614) || (protonLabel == 1178107) || (protonLabel == 1386970) || (protonLabel == 18733) || (protonLabel == 319481) || (protonLabel == 433384) || (protonLabel == 914259) || (protonLabel == 364214) || (protonLabel == 922267) || (protonLabel == 49070) || (protonLabel == 841303) || (protonLabel == 1167211) || (protonLabel == 1257919) || (protonLabel == 367228) || (protonLabel == 439084) || (protonLabel == 812970) || (protonLabel == 1379678) || (protonLabel == 62526) || (protonLabel == 299330) || (protonLabel == 492671) || (protonLabel == 492678) || (protonLabel == 540812) || (protonLabel == 727692) || (protonLabel == 900211) || (protonLabel == 653455) || (protonLabel == 759316) || (protonLabel == 192853) || (protonLabel == 1096808) || (protonLabel == 1373001) || (protonLabel == 62875) || (protonLabel == 161859) || (protonLabel == 534335) || (protonLabel == 806033) || (protonLabel == 1050891) || (protonLabel == 1390046) || (protonLabel == 6268) || (protonLabel == 854417) || (protonLabel == 576587) || (protonLabel == 633385) || (protonLabel == 911527) || (protonLabel == 995379) || (protonLabel == 119194) || (protonLabel == 724999) || (protonLabel == 762518); - + MY_DEBUG_MSG(1, printf("\n"); LOG(INFO) << "Bachelor loop"); +#ifdef MY_DEBUG + auto protonLabel = bach.mcParticleId(); + bool isProtonFromLc = isProtonFromLcFunc(protonLabel); +#endif // selections on the bachelor // pT cut if (bach.isSelProng() < 4) { - if (isProtonFromLc) { - LOG(INFO) << "proton " << protonLabel << ": rejected due to HFsel"; - } + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << ": rejected due to HFsel"); continue; } if (b_TPCRefit) { if (!(bach.trackType() & o2::aod::track::TPCrefit)) { - if (isProtonFromLc) { - LOG(INFO) << "proton " << protonLabel << ": rejected due to TPCrefit"; - } + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << ": rejected due to TPCrefit"); continue; } } if (bach.tpcNClsCrossedRows() < i_minCrossedRows) { - if (isProtonFromLc) { - LOG(INFO) << "proton " << protonLabel << ": rejected due to minNUmberOfCrossedRows " << bach.tpcNClsCrossedRows() << " (cut " << i_minCrossedRows << ")"; - } + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << ": rejected due to minNUmberOfCrossedRows " << bach.tpcNClsCrossedRows() << " (cut " << i_minCrossedRows << ")"); continue; } - if (isProtonFromLc) { - LOG(INFO) << "KEPT! proton from Lc with daughters " << protonLabel; - } + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "KEPT! proton from Lc with daughters " << protonLabel); + auto bachTrack = getTrackParCov(bach); // now we loop over the V0s for (const auto& v0 : V0s) { + MY_DEBUG_MSG(1, LOG(INFO) << "*** Checking next K0S"); // selections on the V0 daughters const auto& posTrack = v0.posTrack_as(); const auto& negTrack = v0.negTrack_as(); - auto labelPos = posTrack.label().globalIndex(); - auto labelNeg = negTrack.label().globalIndex(); - bool isK0SfromLc = (labelPos == 27384 && labelNeg == 27385) || (labelPos == 981525 && labelNeg == 981526) || (labelPos == 1080007 && labelNeg == 1080008) || (labelPos == 1151717 && labelNeg == 1151718) || - (labelPos == 1354080 && labelNeg == 1354081) || (labelPos == 46082 && labelNeg == 46083) || (labelPos == 386994 && labelNeg == 386995) || (labelPos == 1032304 && labelNeg == 1032305) || - (labelPos == 1126617 && labelNeg == 1126618) || (labelPos == 1178152 && labelNeg == 1178153) || (labelPos == 1386973 && labelNeg == 1386974) || (labelPos == 18895 && labelNeg == 18896) || - (labelPos == 319531 && labelNeg == 319532) || (labelPos == 433387 && labelNeg == 433388) || (labelPos == 914299 && labelNeg == 914300) || (labelPos == 364270 && labelNeg == 364271) || - (labelPos == 922284 && labelNeg == 922285) || (labelPos == 49092 && labelNeg == 49093) || (labelPos == 841344 && labelNeg == 841345) || (labelPos == 1167214 && labelNeg == 1167215) || - (labelPos == 1257925 && labelNeg == 1257926) || (labelPos == 367299 && labelNeg == 367300) || (labelPos == 439094 && labelNeg == 439095) || (labelPos == 812984 && labelNeg == 812985) || - (labelPos == 1379705 && labelNeg == 1379706) || (labelPos == 62529 && labelNeg == 62530) || (labelPos == 299343 && labelNeg == 299344) || (labelPos == 492703 && labelNeg == 492704) || - (labelPos == 492681 && labelNeg == 492682) || (labelPos == 540846 && labelNeg == 540847) || (labelPos == 727710 && labelNeg == 727711) || (labelPos == 900248 && labelNeg == 900249) || - (labelPos == 653535 && labelNeg == 653536) || (labelPos == 759443 && labelNeg == 759444) || (labelPos == 192861 && labelNeg == 192862) || (labelPos == 1096815 && labelNeg == 1096816) || - (labelPos == 1373004 && labelNeg == 1373005) || (labelPos == 62878 && labelNeg == 62879) || (labelPos == 161866 && labelNeg == 161867) || (labelPos == 534341 && labelNeg == 534342) || - (labelPos == 806053 && labelNeg == 806054) || (labelPos == 1050897 && labelNeg == 1050898) || (labelPos == 1390049 && labelNeg == 1390050) || (labelPos == 6288 && labelNeg == 6289) || - (labelPos == 854422 && labelNeg == 854423) || (labelPos == 576590 && labelNeg == 576591) || (labelPos == 633388 && labelNeg == 633389) || (labelPos == 911572 && labelNeg == 911573) || - (labelPos == 995382 && labelNeg == 995383) || (labelPos == 119206 && labelNeg == 119207) || (labelPos == 725047 && labelNeg == 725048) || (labelPos == 762521 && labelNeg == 762522); - - bool isLc = (protonLabel == 27378 && labelPos == 27384 && labelNeg == 27385) || (protonLabel == 981514 && labelPos == 981525 && labelNeg == 981526) || (protonLabel == 1079941 && labelPos == 1080007 && labelNeg == 1080008) || - (protonLabel == 1151713 && labelPos == 1151717 && labelNeg == 1151718) || (protonLabel == 1354075 && labelPos == 1354080 && labelNeg == 1354081) || (protonLabel == 46077 && labelPos == 46082 && labelNeg == 46083) || - (protonLabel == 386988 && labelPos == 386994 && labelNeg == 386995) || (protonLabel == 1032251 && labelPos == 1032304 && labelNeg == 1032305) || (protonLabel == 1126614 && labelPos == 1126617 && labelNeg == 1126618) || - (protonLabel == 1178107 && labelPos == 1178152 && labelNeg == 1178153) || (protonLabel == 1386970 && labelPos == 1386973 && labelNeg == 1386974) || (protonLabel == 18733 && labelPos == 18895 && labelNeg == 18896) || - (protonLabel == 319481 && labelPos == 319531 && labelNeg == 319532) || (protonLabel == 433384 && labelPos == 433387 && labelNeg == 433388) || (protonLabel == 914259 && labelPos == 914299 && labelNeg == 914300) || - (protonLabel == 364214 && labelPos == 364270 && labelNeg == 364271) || (protonLabel == 922267 && labelPos == 922284 && labelNeg == 922285) || (protonLabel == 49070 && labelPos == 49092 && labelNeg == 49093) || - (protonLabel == 841303 && labelPos == 841344 && labelNeg == 841345) || (protonLabel == 1167211 && labelPos == 1167214 && labelNeg == 1167215) || (protonLabel == 1257919 && labelPos == 1257925 && labelNeg == 1257926) || - (protonLabel == 367228 && labelPos == 367299 && labelNeg == 367300) || (protonLabel == 439084 && labelPos == 439094 && labelNeg == 439095) || (protonLabel == 812970 && labelPos == 812984 && labelNeg == 812985) || - (protonLabel == 1379678 && labelPos == 1379705 && labelNeg == 1379706) || (protonLabel == 62526 && labelPos == 62529 && labelNeg == 62530) || (protonLabel == 299330 && labelPos == 299343 && labelNeg == 299344) || - (protonLabel == 492671 && labelPos == 492703 && labelNeg == 492704) || (protonLabel == 492678 && labelPos == 492681 && labelNeg == 492682) || (protonLabel == 540812 && labelPos == 540846 && labelNeg == 540847) || - (protonLabel == 727692 && labelPos == 727710 && labelNeg == 727711) || (protonLabel == 900211 && labelPos == 900248 && labelNeg == 900249) || (protonLabel == 653455 && labelPos == 653535 && labelNeg == 653536) || - (protonLabel == 759316 && labelPos == 759443 && labelNeg == 759444) || (protonLabel == 192853 && labelPos == 192861 && labelNeg == 192862) || (protonLabel == 1096808 && labelPos == 1096815 && labelNeg == 1096816) || - (protonLabel == 1373001 && labelPos == 1373004 && labelNeg == 1373005) || (protonLabel == 62875 && labelPos == 62878 && labelNeg == 62879) || (protonLabel == 161859 && labelPos == 161866 && labelNeg == 161867) || - (protonLabel == 534335 && labelPos == 534341 && labelNeg == 534342) || (protonLabel == 806033 && labelPos == 806053 && labelNeg == 806054) || (protonLabel == 1050891 && labelPos == 1050897 && labelNeg == 1050898) || - (protonLabel == 1390046 && labelPos == 1390049 && labelNeg == 1390050) || (protonLabel == 6268 && labelPos == 6288 && labelNeg == 6289) || (protonLabel == 854417 && labelPos == 854422 && labelNeg == 854423) || - (protonLabel == 576587 && labelPos == 576590 && labelNeg == 576591) || (protonLabel == 633385 && labelPos == 633388 && labelNeg == 633389) || (protonLabel == 911527 && labelPos == 911572 && labelNeg == 911573) || - (protonLabel == 995379 && labelPos == 995382 && labelNeg == 995383) || (protonLabel == 119194 && labelPos == 119206 && labelNeg == 119207) || (protonLabel == 724999 && labelPos == 725047 && labelNeg == 725048) || - (protonLabel == 762518 && labelPos == 762521 && labelNeg == 762522); - - if (isK0SfromLc) { - LOG(INFO) << "K0S from Lc found, posTrack --> " << labelPos << ", negTrack --> " << labelNeg; - } - - if (isK0SfromLc && isProtonFromLc) { - LOG(INFO) << "ACCEPTED!!!"; - LOG(INFO) << "proton belonging to a Lc found: label --> " << protonLabel; - LOG(INFO) << "K0S belonging to a Lc found: posTrack --> " << labelPos << ", negTrack --> " << labelNeg; - } - - if (isLc) { - LOG(INFO) << "Combination of K0S and p which correspond to a Lc found!"; - } - +#ifdef MY_DEBUG + auto labelPos = posTrack.mcParticleId(); + auto labelNeg = negTrack.mcParticleId(); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg); + + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg); +#endif + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S from Lc found, posTrack --> " << labelPos << ", negTrack --> " << labelNeg); + + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, + LOG(INFO) << "ACCEPTED!!!"; + LOG(INFO) << "proton belonging to a Lc found: label --> " << protonLabel; + LOG(INFO) << "K0S belonging to a Lc found: posTrack --> " << labelPos << ", negTrack --> " << labelNeg); + + MY_DEBUG_MSG(isLc, LOG(INFO) << "Combination of K0S and p which correspond to a Lc found!"); + if (b_TPCRefit) { if (!(posTrack.trackType() & o2::aod::track::TPCrefit) || !(negTrack.trackType() & o2::aod::track::TPCrefit)) { - if (isK0SfromLc) { - LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to TPCrefit"; - } - continue; + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to TPCrefit"); + continue; } } if (posTrack.tpcNClsCrossedRows() < i_minCrossedRows || negTrack.tpcNClsCrossedRows() < i_minCrossedRows) { - if (isK0SfromLc) { - LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to minCrossedRows"; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to minCrossedRows"); continue; } // @@ -1193,37 +1162,28 @@ struct HFTrackIndexSkimsCreatorCascades { // if (posTrack.pt() < d_ptMin || // to the filters? I can't for now, it is not in the tables negTrack.pt() < d_ptMin) { - if (isK0SfromLc) { - LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to minPt --> pos " << posTrack.pt() << ", neg " << negTrack.pt() << " (cut " << d_ptMin << ")"; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to minPt --> pos " << posTrack.pt() << ", neg " << negTrack.pt() << " (cut " << d_ptMin << ")"); continue; } if (abs(posTrack.eta()) > d_etaMax || // to the filters? I can't for now, it is not in the tables abs(negTrack.eta()) > d_etaMax) { - if (isK0SfromLc) { - LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to eta --> pos " << posTrack.eta() << ", neg " << negTrack.eta() << " (cut " << d_etaMax << ")"; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to eta --> pos " << posTrack.eta() << ", neg " << negTrack.eta() << " (cut " << d_etaMax << ")"); continue; } // V0 invariant mass selection if (std::abs(v0.mK0Short() - massK0s) > d_cutInvMassV0) { - if (isK0SfromLc) { - LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to invMass --> " << v0.mK0Short() - massK0s << " (cut " << d_cutInvMassV0 << ")"; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to invMass --> " << v0.mK0Short() - massK0s << " (cut " << d_cutInvMassV0 << ")"); continue; // should go to the filter, but since it is a dynamic column, I cannot use it there } // V0 cosPointingAngle selection if (v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < d_cosPAV0) { - if (isK0SfromLc) { - LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to cosPA --> " << v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) << " (cut " << d_cosPAV0 << ")"; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to cosPA --> " << v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) << " (cut " << d_cosPAV0 << ")"); continue; } - if (isK0SfromLc) { - LOG(INFO) << "KEPT! K0S from Lc with daughters " << labelPos << " and " << labelNeg; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "KEPT! K0S from Lc with daughters " << labelPos << " and " << labelNeg); + auto posTrackParCov = getTrackParCov(posTrack); posTrackParCov.propagateTo(v0.posX(), d_bZ); // propagate the track to the X closest to the V0 vertex auto negTrackParCov = getTrackParCov(negTrack); @@ -1239,12 +1199,8 @@ struct HFTrackIndexSkimsCreatorCascades { // now we find the DCA between the V0 and the bachelor, for the cascade int nCand2 = fitter.process(trackV0, bachTrack); - if (isK0SfromLc && isProtonFromLc) { - LOG(INFO) << "Fitter result = " << nCand2 << " proton = " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg; - } - if (isLc) { - LOG(INFO) << "Fitter result for true Lc = " << nCand2; - } + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "Fitter result = " << nCand2 << " proton = " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg); + MY_DEBUG_MSG(isLc, LOG(INFO) << "Fitter result for true Lc = " << nCand2); if (nCand2 == 0) { continue; } @@ -1259,9 +1215,7 @@ struct HFTrackIndexSkimsCreatorCascades { // cascade candidate pT cut if (RecoDecay::Pt(pVecCandCasc) < d_cutCascPtCandMin) { - if (isK0SfromLc && isProtonFromLc) { - LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to pt cut: " << RecoDecay::Pt(pVecCandCasc) << " (cut " << d_cutCascPtCandMin << ")"; - } + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to pt cut: " << RecoDecay::Pt(pVecCandCasc) << " (cut " << d_cutCascPtCandMin << ")"); continue; } @@ -1271,9 +1225,7 @@ struct HFTrackIndexSkimsCreatorCascades { mass2K0sP = RecoDecay::M(arrMom, array{massP, massK0s}); // invariant-mass cut if ((d_cutCascInvMassLc >= 0.) && (std::abs(mass2K0sP - massLc) > d_cutCascInvMassLc)) { - if (isK0SfromLc && isProtonFromLc) { - LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to invMass cut: " << mass2K0sP << ", mass Lc " << massLc << " (cut " << d_cutCascInvMassLc << ")"; - } + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to invMass cut: " << mass2K0sP << ", mass Lc " << massLc << " (cut " << d_cutCascInvMassLc << ")"); continue; } @@ -1289,9 +1241,7 @@ struct HFTrackIndexSkimsCreatorCascades { 1); // 1 should be the value for the Lc // fill histograms if (b_doValPlots) { - if (isK0SfromLc && isProtonFromLc && isLc) { - LOG(INFO) << "KEPT! True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg; - } + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc && isLc, LOG(INFO) << "KEPT! True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg); registry.get(HIST("hvtx2_x"))->Fill(posCasc[0]); registry.get(HIST("hvtx2_y"))->Fill(posCasc[1]); registry.get(HIST("hvtx2_z"))->Fill(posCasc[2]); @@ -1306,7 +1256,7 @@ struct HFTrackIndexSkimsCreatorCascades { struct HFTrackIndexTestMCCasc { void process(aod::BigTracksMC const& tracks, - aod::V0DataExt const& V0s, + aod::V0Datas const& V0s, aod::McParticles const& particlesMC) { diff --git a/Analysis/Tasks/PWGHF/taskLcK0sP.cxx b/Analysis/Tasks/PWGHF/taskLcK0sP.cxx index a10813c169a90..8148d303d675f 100644 --- a/Analysis/Tasks/PWGHF/taskLcK0sP.cxx +++ b/Analysis/Tasks/PWGHF/taskLcK0sP.cxx @@ -81,43 +81,40 @@ struct TaskLcK0sP { } } }; -/* + /// Fills MC histograms. -struct TaskD0MC { +struct TaskLcK0SpMC { HistogramRegistry registry{ "registry", - {{"hPtRecSig", "2-prong candidates (matched);#it{p}_{T}^{rec.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, - {"hPtRecBg", "2-prong candidates (unmatched);#it{p}_{T}^{rec.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, - {"hPtGen", "MC particles (matched);#it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, - {"hPtGenSig", "2-prong candidates (matched);#it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, - {"hCPARecSig", "2-prong candidates (matched);cosine of pointing angle;entries", {HistType::kTH1F, {{110, -1.1, 1.1}}}}, - {"hCPARecBg", "2-prong candidates (unmatched);cosine of pointing angle;entries", {HistType::kTH1F, {{110, -1.1, 1.1}}}}, - {"hEtaRecSig", "2-prong candidates (matched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}, - {"hEtaRecBg", "2-prong candidates (unmatched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}, + {{"hPtRecSig", "cascade candidates (matched);#it{p}_{T}^{rec.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hPtRecBg", "cascade candidates (unmatched);#it{p}_{T}^{rec.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hPtGen", "cascade (matched);#it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hPtGenSig", "cascade candidates (matched);#it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hCPARecSig", "cascade candidates (matched);cosine of pointing angle;entries", {HistType::kTH1F, {{110, -1.1, 1.1}}}}, + {"hCPARecBg", "cascade candidates (unmatched);cosine of pointing angle;entries", {HistType::kTH1F, {{110, -1.1, 1.1}}}}, + {"hEtaRecSig", "cascade candidates (matched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}, + {"hEtaRecBg", "cascade candidates (unmatched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}, {"hEtaGen", "MC particles (matched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}}}; - Configurable d_selectionFlagD0{"d_selectionFlagD0", 1, "Selection Flag for D0"}; - Configurable d_selectionFlagD0bar{"d_selectionFlagD0bar", 1, "Selection Flag for D0bar"}; + Configurable d_selectionFlagLc{"d_selectionFlagLc", 1, "Selection Flag for Lc"}; + Configurable d_selectionFlagLcbar{"d_selectionFlagLcbar", 1, "Selection Flag for Lcbar"}; Configurable cutEtaCandMax{"cutEtaCandMax", -1., "max. cand. pseudorapidity"}; - Filter filterSelectCandidates = (aod::hf_selcandidate_d0::isSelD0 >= d_selectionFlagD0 || aod::hf_selcandidate_d0::isSelD0bar >= d_selectionFlagD0bar); + Filter filterSelectCandidates = (aod::hf_selcandidate_lc_k0sp::isSelLcK0sP >= d_selectionFlagLc || aod::hf_selcandidate_lc_k0sp::isSelLcK0sP >= d_selectionFlagLcbar); - void process(soa::Filtered> const& candidates, - soa::Join const& particlesMC, aod::BigTracksMC const& tracks) + void process(soa::Filtered> const& candidates, + soa::Join const& particlesMC, aod::BigTracksMC const& tracks) { // MC rec. //Printf("MC Candidates: %d", candidates.size()); for (auto& candidate : candidates) { - if (!(candidate.hfflag() & 1 << D0ToPiK)) { - continue; - } if (cutEtaCandMax >= 0. && std::abs(candidate.eta()) > cutEtaCandMax) { //Printf("MC Rec.: eta rejection: %g", candidate.eta()); continue; } - if (std::abs(candidate.flagMCMatchRec()) == 1 << D0ToPiK) { + if (std::abs(candidate.flagMCMatchRec()) == 1) { // Get the corresponding MC particle. - auto indexMother = RecoDecay::getMother(particlesMC, candidate.index0_as().label_as>(), 421, true); + auto indexMother = RecoDecay::getMother(particlesMC, candidate.index0_as().mcParticle_as>(), 4122, true); auto particleMother = particlesMC.iteratorAt(indexMother); registry.fill(HIST("hPtGenSig"), particleMother.pt()); // gen. level pT registry.fill(HIST("hPtRecSig"), candidate.pt()); // rec. level pT @@ -136,23 +133,21 @@ struct TaskD0MC { //Printf("MC Gen.: eta rejection: %g", particle.eta()); continue; } - if (std::abs(particle.flagMCMatchGen()) == 1 << D0ToPiK) { + if (std::abs(particle.flagMCMatchGen()) == 1) { registry.fill(HIST("hPtGen"), particle.pt()); registry.fill(HIST("hEtaGen"), particle.eta()); } } } }; -*/ + WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { WorkflowSpec workflow{ - adaptAnalysisTask("hf-task-lc-tok0sP")}; + adaptAnalysisTask(cfgc, "hf-task-lc-tok0sP")}; const bool doMC = cfgc.options().get("doMC"); - /* if (doMC) { - workflow.push_back(adaptAnalysisTask("hf-task-d0-mc")); + workflow.push_back(adaptAnalysisTask(cfgc, "hf-task-lc-tok0sP-mc")); } - */ return workflow; } diff --git a/Analysis/Tasks/PWGLF/CMakeLists.txt b/Analysis/Tasks/PWGLF/CMakeLists.txt index 3103556034c03..250b7cec35962 100644 --- a/Analysis/Tasks/PWGLF/CMakeLists.txt +++ b/Analysis/Tasks/PWGLF/CMakeLists.txt @@ -59,8 +59,8 @@ o2_add_dpl_workflow(nuclei-spectra COMPONENT_NAME Analysis) o2_add_dpl_workflow(lambdakzerobuilder - SOURCES lambdakzerobuilder.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing + SOURCES lambdakzerobuilder + PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing O2::AnalysisTasksUtils COMPONENT_NAME Analysis) o2_add_dpl_workflow(lambdakzeroanalysis diff --git a/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx b/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx index d455f333abbde..39c284cee74a0 100644 --- a/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx +++ b/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx @@ -53,6 +53,7 @@ #include #include #include "Framework/ASoAHelpers.h" +#include "AnalysisTasksUtils/UtilsDebugLcK0Sp.h" using namespace o2; using namespace o2::framework; @@ -73,9 +74,19 @@ DECLARE_SOA_TABLE(V0GoodIndices, "AOD", "V0GOODINDICES", o2::soa::Index<>, } // namespace o2::aod using FullTracksExt = soa::Join; -//using BigTracks = soa::Join; -using BigTracks = soa::Join; -using BigTracksMC = soa::Join; +using FullTracksExtMC = soa::Join; + +//#define MY_DEBUG +#ifdef MY_DEBUG +using MyTracks = FullTracksExtMC; +#define MY_DEBUG_MSG(condition, cmd) \ + if (condition) { \ + cmd; \ + } +#else +using MyTracks = FullTracksExt; +#define MY_DEBUG_MSG(condition, cmd) +#endif //This prefilter creates a skimmed list of good V0s to re-reconstruct so that //CPU is saved in case there are specific selections that are to be done @@ -96,96 +107,56 @@ struct lambdakzeroprefilterpairs { Produces v0goodindices; void process(aod::Collision const& collision, aod::V0s const& V0s, - BigTracksMC const& tracks, aod::McParticles const& particlesMC) + MyTracks const& tracks +#ifdef MY_DEBUG + , + aod::McParticles const& particlesMC +#endif + ) { for (auto& V0 : V0s) { - auto labelPos = V0.posTrack_as().label().globalIndex(); - auto labelNeg = V0.negTrack_as().label().globalIndex(); - - bool isK0SfromLc = (labelPos == 27384 && labelNeg == 27385) || (labelPos == 981525 && labelNeg == 981526) || (labelPos == 1080007 && labelNeg == 1080008) || (labelPos == 1151717 && labelNeg == 1151718) || - (labelPos == 1354080 && labelNeg == 1354081) || (labelPos == 46082 && labelNeg == 46083) || (labelPos == 386994 && labelNeg == 386995) || (labelPos == 1032304 && labelNeg == 1032305) || - (labelPos == 1126617 && labelNeg == 1126618) || (labelPos == 1178152 && labelNeg == 1178153) || (labelPos == 1386973 && labelNeg == 1386974) || (labelPos == 18895 && labelNeg == 18896) || - (labelPos == 319531 && labelNeg == 319532) || (labelPos == 433387 && labelNeg == 433388) || (labelPos == 914299 && labelNeg == 914300) || (labelPos == 364270 && labelNeg == 364271) || - (labelPos == 922284 && labelNeg == 922285) || (labelPos == 49092 && labelNeg == 49093) || (labelPos == 841344 && labelNeg == 841345) || (labelPos == 1167214 && labelNeg == 1167215) || - (labelPos == 1257925 && labelNeg == 1257926) || (labelPos == 367299 && labelNeg == 367300) || (labelPos == 439094 && labelNeg == 439095) || (labelPos == 812984 && labelNeg == 812985) || - (labelPos == 1379705 && labelNeg == 1379706) || (labelPos == 62529 && labelNeg == 62530) || (labelPos == 299343 && labelNeg == 299344) || (labelPos == 492703 && labelNeg == 492704) || - (labelPos == 492681 && labelNeg == 492682) || (labelPos == 540846 && labelNeg == 540847) || (labelPos == 727710 && labelNeg == 727711) || (labelPos == 900248 && labelNeg == 900249) || - (labelPos == 653535 && labelNeg == 653536) || (labelPos == 759443 && labelNeg == 759444) || (labelPos == 192861 && labelNeg == 192862) || (labelPos == 1096815 && labelNeg == 1096816) || - (labelPos == 1373004 && labelNeg == 1373005) || (labelPos == 62878 && labelNeg == 62879) || (labelPos == 161866 && labelNeg == 161867) || (labelPos == 534341 && labelNeg == 534342) || - (labelPos == 806053 && labelNeg == 806054) || (labelPos == 1050897 && labelNeg == 1050898) || (labelPos == 1390049 && labelNeg == 1390050) || (labelPos == 6288 && labelNeg == 6289) || - (labelPos == 854422 && labelNeg == 854423) || (labelPos == 576590 && labelNeg == 576591) || (labelPos == 633388 && labelNeg == 633389) || (labelPos == 911572 && labelNeg == 911573) || - (labelPos == 995382 && labelNeg == 995383) || (labelPos == 119206 && labelNeg == 119207) || (labelPos == 725047 && labelNeg == 725048) || (labelPos == 762521 && labelNeg == 762522); - - //LOG(INFO) << "posTrackId = " << V0.posTrackId() << ", negTrackId = " << V0.negTrackId(); - - //Printf("posTrack --> V0.posTrack_as().label().globalIndex() = %ld, negTrack --> V0.negTrack_as().label().globalIndex() = %ld", V0.posTrack_as().label().globalIndex(), V0.negTrack_as().label().globalIndex()); - - if (isK0SfromLc) { - LOG(INFO) << "V0 builder: found K0S from Lc, posTrack --> " << labelPos << ", negTrack --> " << labelNeg; - } - - //LOG(INFO) << "posTrack --> V0.posTrack_as().globalIndex() = " << V0.posTrack_as().globalIndex(); - //LOG(INFO) << "posTrack --> V0.posTrack_as().labelId() = " << V0.posTrack_as().labelId(); - - //int iiiii = V0.posTrack_as().label().globalIndex(); - //int64_t iiiiiii = V0.posTrack_as().label().globalIndex(); - //int32_t iii = V0.posTrack_as().label().globalIndex(); +#ifdef MY_DEBUG + auto labelPos = V0.posTrack_as().mcParticleId(); + auto labelNeg = V0.negTrack_as().mcParticleId(); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg); +#endif + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "V0 builder: found K0S from Lc, posTrack --> " << labelPos << ", negTrack --> " << labelNeg); - // Printf("V0.posTrack_as().label().globalIndex() as int = %d", iiiii); - //Printf("V0.posTrack_as().label().globalIndex() as int64_t = %ld", iiiiiii); - //Printf("V0.posTrack_as().label().globalIndex() as int32_t = %d", iii); - - registry.fill(HIST("hGoodIndices"), 0.5); if (tpcrefit) { - if (!(V0.posTrack_as().trackType() & o2::aod::track::TPCrefit)) { - if (isK0SfromLc) { - LOG(INFO) << "posTrack " << labelPos << " has no TPC refit"; - } + if (!(V0.posTrack_as().trackType() & o2::aod::track::TPCrefit)) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "posTrack " << labelPos << " has no TPC refit"); continue; //TPC refit } - if (!(V0.negTrack_as().trackType() & o2::aod::track::TPCrefit)) { - if (isK0SfromLc) { - LOG(INFO) << "negTrack " << labelNeg << " has no TPC refit"; - } + if (!(V0.negTrack_as().trackType() & o2::aod::track::TPCrefit)) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "negTrack " << labelNeg << " has no TPC refit"); continue; //TPC refit } } registry.fill(HIST("hGoodIndices"), 1.5); - if (V0.posTrack_as().tpcNClsCrossedRows() < mincrossedrows) { - if (isK0SfromLc) { - LOG(INFO) << "posTrack " << labelPos << " has " << V0.posTrack_as().tpcNClsCrossedRows() << " crossed rows, cut at " << mincrossedrows; - } + if (V0.posTrack_as().tpcNClsCrossedRows() < mincrossedrows) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "posTrack " << labelPos << " has " << V0.posTrack_as().tpcNClsCrossedRows() << " crossed rows, cut at " << mincrossedrows); continue; } - if (V0.negTrack_as().tpcNClsCrossedRows() < mincrossedrows) { - if (isK0SfromLc) { - LOG(INFO) << "negTrack " << labelNeg << " has " << V0.negTrack_as().tpcNClsCrossedRows() << " crossed rows, cut at " << mincrossedrows; - } - continue; + if (V0.negTrack_as().tpcNClsCrossedRows() < mincrossedrows) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "negTrack " << labelNeg << " has " << V0.negTrack_as().tpcNClsCrossedRows() << " crossed rows, cut at " << mincrossedrows); + continue; } registry.fill(HIST("hGoodIndices"), 2.5); - if (fabs(V0.posTrack_as().dcaXY()) < dcapostopv) { - if (isK0SfromLc) { - LOG(INFO) << "posTrack " << labelPos << " has dcaXY " << V0.posTrack_as().dcaXY() << " , cut at " << dcanegtopv; - } + if (fabs(V0.posTrack_as().dcaXY()) < dcapostopv) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "posTrack " << labelPos << " has dcaXY " << V0.posTrack_as().dcaXY() << " , cut at " << dcanegtopv); continue; } - if (fabs(V0.negTrack_as().dcaXY()) < dcanegtopv) { - if (isK0SfromLc) { - LOG(INFO) << "negTrack " << labelNeg << " has dcaXY " << V0.negTrack_as().dcaXY() << " , cut at " << dcanegtopv; + if (fabs(V0.negTrack_as().dcaXY()) < dcanegtopv) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "negTrack " << labelNeg << " has dcaXY " << V0.negTrack_as().dcaXY() << " , cut at " << dcanegtopv); continue; - } - } - if (isK0SfromLc) { - LOG(INFO) << "Filling good indices: posTrack --> " << labelPos << ", negTrack --> " << labelNeg; } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "Filling good indices: posTrack --> " << labelPos << ", negTrack --> " << labelNeg); registry.fill(HIST("hGoodIndices"), 3.5); - v0goodindices(V0.posTrack_as().globalIndex(), - V0.negTrack_as().globalIndex(), - V0.posTrack_as().collisionId()); - + v0goodindices(V0.posTrack_as().globalIndex(), + V0.negTrack_as().globalIndex(), + V0.posTrack_as().collisionId()); } } }; @@ -216,13 +187,12 @@ struct lambdakzerobuilder { double massKa = TDatabasePDG::Instance()->GetParticle(kKPlus)->Mass(); double massPr = TDatabasePDG::Instance()->GetParticle(kProton)->Mass(); - /* - using FullTracksExt = soa::Join; - using BigTracks = soa::Join; - using BigTracksMC = soa::Join; - */ - //void process(aod::Collision const& collision, aod::V0GoodIndices const& V0s, soa::Join const& tracks, aod::McParticles const& particlesMC) - void process(aod::Collision const& collision, aod::V0GoodIndices const& V0s, BigTracksMC const& tracks, aod::McParticles const& particlesMC) + void process(aod::Collision const& collision, aod::V0GoodIndices const& V0s, MyTracks const& tracks +#ifdef MY_DEBUG + , + aod::McParticles const& particlesMC +#endif + ) { //Define o2 fitter, 2-prong o2::vertexing::DCAFitterN<2> fitter; @@ -243,31 +213,20 @@ struct lambdakzerobuilder { std::array pvec0 = {0.}; std::array pvec1 = {0.}; - auto labelPos = V0.posTrack_as().label().globalIndex(); - auto labelNeg = V0.negTrack_as().label().globalIndex(); - - bool isK0SfromLc = (labelPos == 27384 && labelNeg == 27385) || (labelPos == 981525 && labelNeg == 981526) || (labelPos == 1080007 && labelNeg == 1080008) || (labelPos == 1151717 && labelNeg == 1151718) || - (labelPos == 1354080 && labelNeg == 1354081) || (labelPos == 46082 && labelNeg == 46083) || (labelPos == 386994 && labelNeg == 386995) || (labelPos == 1032304 && labelNeg == 1032305) || - (labelPos == 1126617 && labelNeg == 1126618) || (labelPos == 1178152 && labelNeg == 1178153) || (labelPos == 1386973 && labelNeg == 1386974) || (labelPos == 18895 && labelNeg == 18896) || - (labelPos == 319531 && labelNeg == 319532) || (labelPos == 433387 && labelNeg == 433388) || (labelPos == 914299 && labelNeg == 914300) || (labelPos == 364270 && labelNeg == 364271) || - (labelPos == 922284 && labelNeg == 922285) || (labelPos == 49092 && labelNeg == 49093) || (labelPos == 841344 && labelNeg == 841345) || (labelPos == 1167214 && labelNeg == 1167215) || - (labelPos == 1257925 && labelNeg == 1257926) || (labelPos == 367299 && labelNeg == 367300) || (labelPos == 439094 && labelNeg == 439095) || (labelPos == 812984 && labelNeg == 812985) || - (labelPos == 1379705 && labelNeg == 1379706) || (labelPos == 62529 && labelNeg == 62530) || (labelPos == 299343 && labelNeg == 299344) || (labelPos == 492703 && labelNeg == 492704) || - (labelPos == 492681 && labelNeg == 492682) || (labelPos == 540846 && labelNeg == 540847) || (labelPos == 727710 && labelNeg == 727711) || (labelPos == 900248 && labelNeg == 900249) || - (labelPos == 653535 && labelNeg == 653536) || (labelPos == 759443 && labelNeg == 759444) || (labelPos == 192861 && labelNeg == 192862) || (labelPos == 1096815 && labelNeg == 1096816) || - (labelPos == 1373004 && labelNeg == 1373005) || (labelPos == 62878 && labelNeg == 62879) || (labelPos == 161866 && labelNeg == 161867) || (labelPos == 534341 && labelNeg == 534342) || - (labelPos == 806053 && labelNeg == 806054) || (labelPos == 1050897 && labelNeg == 1050898) || (labelPos == 1390049 && labelNeg == 1390050) || (labelPos == 6288 && labelNeg == 6289) || - (labelPos == 854422 && labelNeg == 854423) || (labelPos == 576590 && labelNeg == 576591) || (labelPos == 633388 && labelNeg == 633389) || (labelPos == 911572 && labelNeg == 911573) || - (labelPos == 995382 && labelNeg == 995383) || (labelPos == 119206 && labelNeg == 119207) || (labelPos == 725047 && labelNeg == 725048) || (labelPos == 762521 && labelNeg == 762522); +#ifdef MY_DEBUG + auto labelPos = V0.posTrack_as().mcParticleId(); + auto labelNeg = V0.negTrack_as().mcParticleId(); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg); +#endif + + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "labelPos = " << labelPos << ", labelNeg = " << labelNeg); registry.fill(HIST("hV0Candidate"), 0.5); - auto pTrack = getTrackParCov(V0.posTrack_as()); - auto nTrack = getTrackParCov(V0.negTrack_as()); + auto pTrack = getTrackParCov(V0.posTrack_as()); + auto nTrack = getTrackParCov(V0.negTrack_as()); int nCand = fitter.process(pTrack, nTrack); - if (isK0SfromLc) { - LOG(INFO) << "fitter: nCand = " << nCand << " for posTrack --> " << labelPos << ", negTrack --> " << labelNeg; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "fitter: nCand = " << nCand << " for posTrack --> " << labelPos << ", negTrack --> " << labelNeg); if (nCand != 0) { fitter.propagateTracksToVertex(); const auto& vtx = fitter.getPCACandidate(); @@ -280,51 +239,40 @@ struct lambdakzerobuilder { continue; } - if (isK0SfromLc) { - LOG(INFO) << "in builder 0: posTrack --> " << labelPos << ", negTrack --> " << labelNeg; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "in builder 0: posTrack --> " << labelPos << ", negTrack --> " << labelNeg); //Apply selections so a skimmed table is created only if (fitter.getChi2AtPCACandidate() > dcav0dau) { - if (isK0SfromLc) { - LOG(INFO) << "posTrack --> " << labelPos << ", negTrack --> " << labelNeg << " will be skipped due to dca cut"; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "posTrack --> " << labelPos << ", negTrack --> " << labelNeg << " will be skipped due to dca cut"); continue; } auto V0CosinePA = RecoDecay::CPA(array{collision.posX(), collision.posY(), collision.posZ()}, array{pos[0], pos[1], pos[2]}, array{pvec0[0] + pvec1[0], pvec0[1] + pvec1[1], pvec0[2] + pvec1[2]}); if (V0CosinePA < v0cospa) { - if (isK0SfromLc) { - LOG(INFO) << "posTrack --> " << labelPos << ", negTrack --> " << labelNeg << " will be skipped due to CPA cut"; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "posTrack --> " << labelPos << ", negTrack --> " << labelNeg << " will be skipped due to CPA cut"); continue; } auto V0radius = RecoDecay::sqrtSumOfSquares(pos[0], pos[1]); //probably find better name to differentiate the cut from the variable - //LOG(INFO) << "V0radius of the candidate = " << V0radius << ", cut = " << v0radius; if (V0radius < v0radius) { - if (isK0SfromLc) { - LOG(INFO) << "posTrack --> " << labelPos << ", negTrack --> " << labelNeg << " will be skipped due to radius cut"; - } + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "posTrack --> " << labelPos << ", negTrack --> " << labelNeg << " will be skipped due to radius cut"); continue; } - if (isK0SfromLc) { - LOG(INFO) << "in builder 1, keeping K0S candidate: posTrack --> " << labelPos << ", negTrack --> " << labelNeg; - } - + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "in builder 1, keeping K0S candidate: posTrack --> " << labelPos << ", negTrack --> " << labelNeg); + registry.fill(HIST("hV0Candidate"), 1.5); v0data( - V0.posTrack_as().globalIndex(), - V0.negTrack_as().globalIndex(), - V0.negTrack_as().collisionId(), + V0.posTrack_as().globalIndex(), + V0.negTrack_as().globalIndex(), + V0.negTrack_as().collisionId(), fitter.getTrack(0).getX(), fitter.getTrack(1).getX(), pos[0], pos[1], pos[2], pvec0[0], pvec0[1], pvec0[2], pvec1[0], pvec1[1], pvec1[2], fitter.getChi2AtPCACandidate(), - V0.posTrack_as().dcaXY(), - V0.negTrack_as().dcaXY()); + V0.posTrack_as().dcaXY(), + V0.negTrack_as().dcaXY()); } } }; diff --git a/Analysis/Tasks/Utils/CMakeLists.txt b/Analysis/Tasks/Utils/CMakeLists.txt new file mode 100644 index 0000000000000..c8e0adfb43e32 --- /dev/null +++ b/Analysis/Tasks/Utils/CMakeLists.txt @@ -0,0 +1,13 @@ +# Copyright CERN and copyright holders of ALICE O2. This software is distributed +# under the terms of the GNU General Public License v3 (GPL Version 3), copied +# verbatim in the file "COPYING". +# +# See http://alice-o2.web.cern.ch/license for full licensing information. +# +# In applying this license CERN does not waive the privileges and immunities +# granted to it by virtue of its status as an Intergovernmental Organization or +# submit itself to any jurisdiction. + +o2_add_header_only_library(AnalysisTasksUtils) + + diff --git a/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h b/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h new file mode 100644 index 0000000000000..b24719ee48553 --- /dev/null +++ b/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h @@ -0,0 +1,36 @@ +// Copyright CERN and copyright holders of ALICE O2. This software is +// distributed under the terms of the GNU General Public License v3 (GPL +// Version 3), copied verbatim in the file "COPYING". +// +// See http://alice-o2.web.cern.ch/license for full licensing information. +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file UtilsDebugLcK0Sp +/// \brief Some utilities to do debugging for the LcK0Sp task +/// this MC info apply to: /alice/sim/2020/LHC20l3a/286350/PWGZZ/Run3_Conversion/156_20210308-1000/0001/AO2D.root +/// + +inline bool isK0SfromLcFunc(int labelK0SPos, int labelK0SNeg) +{ + + return (labelK0SPos == 729 && labelK0SNeg == 730) || (labelK0SPos == 2866 && labelK0SNeg == 2867) || (labelK0SPos == 4754 && labelK0SNeg == 4755) || (labelK0SPos == 5457 && labelK0SNeg == 5458) || (labelK0SPos == 6891 && labelK0SNeg == 6892) || (labelK0SPos == 7824 && labelK0SNeg == 7825) || (labelK0SPos == 9243 && labelK0SNeg == 9244) || (labelK0SPos == 9810 && labelK0SNeg == 9811) || (labelK0SPos == 10388 && labelK0SNeg == 10389) || (labelK0SPos == 12665 && labelK0SNeg == 12666) || (labelK0SPos == 13830 && labelK0SNeg == 13831) || (labelK0SPos == 17460 && labelK0SNeg == 17461) || (labelK0SPos == 19955 && labelK0SNeg == 19956) || (labelK0SPos == 21786 && labelK0SNeg == 21787) || (labelK0SPos == 23319 && labelK0SNeg == 23320) || (labelK0SPos == 24010 && labelK0SNeg == 24011) || (labelK0SPos == 26234 && labelK0SNeg == 26235) || (labelK0SPos == 28713 && labelK0SNeg == 28714) || (labelK0SPos == 30699 && labelK0SNeg == 30700) || (labelK0SPos == 32056 && labelK0SNeg == 32057) || (labelK0SPos == 34866 && labelK0SNeg == 34867) || (labelK0SPos == 37075 && labelK0SNeg == 37076) || (labelK0SPos == 39314 && labelK0SNeg == 39315) || (labelK0SPos == 40287 && labelK0SNeg == 40288) || (labelK0SPos == 41617 && labelK0SNeg == 41618) || (labelK0SPos == 43790 && labelK0SNeg == 43791) || (labelK0SPos == 44868 && labelK0SNeg == 44869) || (labelK0SPos == 45252 && labelK0SNeg == 45253) || (labelK0SPos == 46587 && labelK0SNeg == 46588) || (labelK0SPos == 47866 && labelK0SNeg == 47867) || (labelK0SPos == 48992 && labelK0SNeg == 48993) || (labelK0SPos == 53534 && labelK0SNeg == 53535) || (labelK0SPos == 57211 && labelK0SNeg == 57212) || (labelK0SPos == 58160 && labelK0SNeg == 58161) || (labelK0SPos == 59355 && labelK0SNeg == 59356) || (labelK0SPos == 61019 && labelK0SNeg == 61020) || (labelK0SPos == 62003 && labelK0SNeg == 62004) || (labelK0SPos == 63580 && labelK0SNeg == 63581) || (labelK0SPos == 65691 && labelK0SNeg == 65692) || (labelK0SPos == 68164 && labelK0SNeg == 68165) || (labelK0SPos == 69721 && labelK0SNeg == 69722) || (labelK0SPos == 70852 && labelK0SNeg == 70853) || (labelK0SPos == 73167 && labelK0SNeg == 73168) || (labelK0SPos == 75331 && labelK0SNeg == 75332) || (labelK0SPos == 76641 && labelK0SNeg == 76642) || (labelK0SPos == 78188 && labelK0SNeg == 78189) || (labelK0SPos == 79595 && labelK0SNeg == 79596) || (labelK0SPos == 80678 && labelK0SNeg == 80679) || (labelK0SPos == 81613 && labelK0SNeg == 81614) || (labelK0SPos == 84311 && labelK0SNeg == 84312) || (labelK0SPos == 86376 && labelK0SNeg == 86377) || (labelK0SPos == 86840 && labelK0SNeg == 86841) || (labelK0SPos == 87374 && labelK0SNeg == 87375) || (labelK0SPos == 89998 && labelK0SNeg == 89999) || (labelK0SPos == 95078 && labelK0SNeg == 95079) || (labelK0SPos == 96094 && labelK0SNeg == 96095) || (labelK0SPos == 97425 && labelK0SNeg == 97426) || (labelK0SPos == 100157 && labelK0SNeg == 100158) || (labelK0SPos == 101788 && labelK0SNeg == 101789) || (labelK0SPos == 103468 && labelK0SNeg == 103469) || (labelK0SPos == 104646 && labelK0SNeg == 104647) || (labelK0SPos == 106155 && labelK0SNeg == 106156) || (labelK0SPos == 108696 && labelK0SNeg == 108697) || (labelK0SPos == 110388 && labelK0SNeg == 110389) || (labelK0SPos == 111355 && labelK0SNeg == 111356) || (labelK0SPos == 111348 && labelK0SNeg == 111349) || (labelK0SPos == 112712 && labelK0SNeg == 112713) || (labelK0SPos == 113578 && labelK0SNeg == 113579) || (labelK0SPos == 114556 && labelK0SNeg == 114557) || (labelK0SPos == 114550 && labelK0SNeg == 114551) || (labelK0SPos == 116432 && labelK0SNeg == 116433) || (labelK0SPos == 117766 && labelK0SNeg == 117767) || (labelK0SPos == 118796 && labelK0SNeg == 118797) || (labelK0SPos == 118790 && labelK0SNeg == 118791) || (labelK0SPos == 119766 && labelK0SNeg == 119767) || (labelK0SPos == 120728 && labelK0SNeg == 120729) || (labelK0SPos == 121872 && labelK0SNeg == 121873) || (labelK0SPos == 124027 && labelK0SNeg == 124028) || (labelK0SPos == 125407 && labelK0SNeg == 125408) || (labelK0SPos == 127284 && labelK0SNeg == 127285) || (labelK0SPos == 129068 && labelK0SNeg == 129069) || (labelK0SPos == 129924 && labelK0SNeg == 129925) || (labelK0SPos == 131453 && labelK0SNeg == 131454) || (labelK0SPos == 132456 && labelK0SNeg == 132457) || (labelK0SPos == 132436 && labelK0SNeg == 132437) || (labelK0SPos == 133266 && labelK0SNeg == 133267) || (labelK0SPos == 134084 && labelK0SNeg == 134085) || (labelK0SPos == 135470 && labelK0SNeg == 135471) || (labelK0SPos == 136207 && labelK0SNeg == 136208) || (labelK0SPos == 137446 && labelK0SNeg == 137447) || (labelK0SPos == 138616 && labelK0SNeg == 138617) || (labelK0SPos == 139217 && labelK0SNeg == 139218) || (labelK0SPos == 141832 && labelK0SNeg == 141833) || (labelK0SPos == 143513 && labelK0SNeg == 143514) || (labelK0SPos == 144416 && labelK0SNeg == 144417) || (labelK0SPos == 145018 && labelK0SNeg == 145019) || (labelK0SPos == 145702 && labelK0SNeg == 145703) || (labelK0SPos == 147139 && labelK0SNeg == 147140) || (labelK0SPos == 148508 && labelK0SNeg == 148509) || (labelK0SPos == 149290 && labelK0SNeg == 149291) || (labelK0SPos == 149737 && labelK0SNeg == 149738) || (labelK0SPos == 153271 && labelK0SNeg == 153272) || (labelK0SPos == 154515 && labelK0SNeg == 154516) || (labelK0SPos == 155206 && labelK0SNeg == 155207) || (labelK0SPos == 158200 && labelK0SNeg == 158201) || (labelK0SPos == 159059 && labelK0SNeg == 159060) || (labelK0SPos == 160082 && labelK0SNeg == 160083) || (labelK0SPos == 161140 && labelK0SNeg == 161141) || (labelK0SPos == 162208 && labelK0SNeg == 162209) || (labelK0SPos == 163777 && labelK0SNeg == 163778) || (labelK0SPos == 165874 && labelK0SNeg == 165875) || (labelK0SPos == 167001 && labelK0SNeg == 167002) || (labelK0SPos == 168852 && labelK0SNeg == 168853) || (labelK0SPos == 174033 && labelK0SNeg == 174034) || (labelK0SPos == 174027 && labelK0SNeg == 174028) || (labelK0SPos == 175501 && labelK0SNeg == 175502) || (labelK0SPos == 177396 && labelK0SNeg == 177397) || (labelK0SPos == 177265 && labelK0SNeg == 177266) || (labelK0SPos == 178383 && labelK0SNeg == 178384) || (labelK0SPos == 179595 && labelK0SNeg == 179596) || (labelK0SPos == 179580 && labelK0SNeg == 179581) || (labelK0SPos == 181168 && labelK0SNeg == 181169) || (labelK0SPos == 187326 && labelK0SNeg == 187327) || (labelK0SPos == 188608 && labelK0SNeg == 188609) || (labelK0SPos == 189128 && labelK0SNeg == 189129) || (labelK0SPos == 191591 && labelK0SNeg == 191592) || (labelK0SPos == 193025 && labelK0SNeg == 193026) || (labelK0SPos == 194170 && labelK0SNeg == 194171) || (labelK0SPos == 195824 && labelK0SNeg == 195825) || (labelK0SPos == 197472 && labelK0SNeg == 197473) || (labelK0SPos == 201905 && labelK0SNeg == 201906) || (labelK0SPos == 202664 && labelK0SNeg == 202665) || (labelK0SPos == 203163 && labelK0SNeg == 203164) || (labelK0SPos == 203835 && labelK0SNeg == 203836) || (labelK0SPos == 205556 && labelK0SNeg == 205557) || (labelK0SPos == 207838 && labelK0SNeg == 207839) || (labelK0SPos == 208866 && labelK0SNeg == 208867) || (labelK0SPos == 211654 && labelK0SNeg == 211655) || (labelK0SPos == 216312 && labelK0SNeg == 216313) || (labelK0SPos == 217132 && labelK0SNeg == 217133) || (labelK0SPos == 217554 && labelK0SNeg == 217555) || (labelK0SPos == 218616 && labelK0SNeg == 218617) || (labelK0SPos == 219503 && labelK0SNeg == 219504) || (labelK0SPos == 219996 && labelK0SNeg == 219997) || (labelK0SPos == 223354 && labelK0SNeg == 223355) || (labelK0SPos == 224713 && labelK0SNeg == 224714) || (labelK0SPos == 224707 && labelK0SNeg == 224708) || (labelK0SPos == 225482 && labelK0SNeg == 225483) || (labelK0SPos == 227207 && labelK0SNeg == 227208) || (labelK0SPos == 230562 && labelK0SNeg == 230563) || (labelK0SPos == 231324 && labelK0SNeg == 231325) || (labelK0SPos == 232083 && labelK0SNeg == 232084) || (labelK0SPos == 232809 && labelK0SNeg == 232810) || (labelK0SPos == 234774 && labelK0SNeg == 234775) || (labelK0SPos == 235892 && labelK0SNeg == 235893) || (labelK0SPos == 236900 && labelK0SNeg == 236901) || (labelK0SPos == 238038 && labelK0SNeg == 238039) || (labelK0SPos == 239629 && labelK0SNeg == 239630) || (labelK0SPos == 241517 && labelK0SNeg == 241518) || (labelK0SPos == 243460 && labelK0SNeg == 243461) || (labelK0SPos == 244881 && labelK0SNeg == 244882) || (labelK0SPos == 245553 && labelK0SNeg == 245554) || (labelK0SPos == 246721 && labelK0SNeg == 246722) || (labelK0SPos == 249672 && labelK0SNeg == 249673) || (labelK0SPos == 250589 && labelK0SNeg == 250590) || (labelK0SPos == 251882 && labelK0SNeg == 251883) || (labelK0SPos == 253034 && labelK0SNeg == 253035) || (labelK0SPos == 254543 && labelK0SNeg == 254544) || (labelK0SPos == 254539 && labelK0SNeg == 254540) || (labelK0SPos == 255941 && labelK0SNeg == 255942) || (labelK0SPos == 256808 && labelK0SNeg == 256809) || (labelK0SPos == 258807 && labelK0SNeg == 258808) || (labelK0SPos == 261612 && labelK0SNeg == 261613) || (labelK0SPos == 262887 && labelK0SNeg == 262888) || (labelK0SPos == 264473 && labelK0SNeg == 264474) || (labelK0SPos == 264471 && labelK0SNeg == 264472) || (labelK0SPos == 268912 && labelK0SNeg == 268913) || (labelK0SPos == 270023 && labelK0SNeg == 270024) || (labelK0SPos == 271998 && labelK0SNeg == 271999) || (labelK0SPos == 274081 && labelK0SNeg == 274082) || (labelK0SPos == 276125 && labelK0SNeg == 276126) || (labelK0SPos == 276952 && labelK0SNeg == 276953) || (labelK0SPos == 278530 && labelK0SNeg == 278531) || (labelK0SPos == 279613 && labelK0SNeg == 279614) || (labelK0SPos == 280446 && labelK0SNeg == 280447) || (labelK0SPos == 282152 && labelK0SNeg == 282153) || (labelK0SPos == 282034 && labelK0SNeg == 282035) || (labelK0SPos == 283408 && labelK0SNeg == 283409) || (labelK0SPos == 284753 && labelK0SNeg == 284754) || (labelK0SPos == 286615 && labelK0SNeg == 286616) || (labelK0SPos == 288037 && labelK0SNeg == 288038) || (labelK0SPos == 289736 && labelK0SNeg == 289737) || (labelK0SPos == 291009 && labelK0SNeg == 291010) || (labelK0SPos == 292336 && labelK0SNeg == 292337) || (labelK0SPos == 293565 && labelK0SNeg == 293566) || (labelK0SPos == 296529 && labelK0SNeg == 296530) || (labelK0SPos == 300564 && labelK0SNeg == 300565); +} + +//------------------------------- + +inline bool isProtonFromLcFunc(int labelProton) +{ + + return (labelProton == 717) || (labelProton == 2810) || (labelProton == 4393) || (labelProton == 5442) || (labelProton == 6769) || (labelProton == 7793) || (labelProton == 9002) || (labelProton == 9789) || (labelProton == 10385) || (labelProton == 12601) || (labelProton == 13819) || (labelProton == 17443) || (labelProton == 19936) || (labelProton == 21715) || (labelProton == 23285) || (labelProton == 23999) || (labelProton == 25676) || (labelProton == 28660) || (labelProton == 30684) || (labelProton == 32049) || (labelProton == 34846) || (labelProton == 37042) || (labelProton == 39278) || (labelProton == 40278) || (labelProton == 41567) || (labelProton == 43696) || (labelProton == 44819) || (labelProton == 45232) || (labelProton == 46578) || (labelProton == 47831) || (labelProton == 48981) || (labelProton == 53527) || (labelProton == 57152) || (labelProton == 58155) || (labelProton == 59296) || (labelProton == 61010) || (labelProton == 61932) || (labelProton == 63577) || (labelProton == 65683) || (labelProton == 68047) || (labelProton == 69657) || (labelProton == 70721) || (labelProton == 73141) || (labelProton == 75320) || (labelProton == 76581) || (labelProton == 78165) || (labelProton == 79504) || (labelProton == 80662) || (labelProton == 81552) || (labelProton == 84208) || (labelProton == 86342) || (labelProton == 86829) || (labelProton == 87347) || (labelProton == 89922) || (labelProton == 95032) || (labelProton == 96087) || (labelProton == 97410) || (labelProton == 100154) || (labelProton == 101743) || (labelProton == 103368) || (labelProton == 104635) || (labelProton == 106089) || (labelProton == 108676) || (labelProton == 110308) || (labelProton == 111335) || (labelProton == 111342) || (labelProton == 112606) || (labelProton == 113469) || (labelProton == 114529) || (labelProton == 114533) || (labelProton == 116388) || (labelProton == 117754) || (labelProton == 118765) || (labelProton == 118784) || (labelProton == 119733) || (labelProton == 120691) || (labelProton == 121773) || (labelProton == 123970) || (labelProton == 125316) || (labelProton == 127253) || (labelProton == 129008) || (labelProton == 129883) || (labelProton == 131408) || (labelProton == 132349) || (labelProton == 132395) || (labelProton == 133263) || (labelProton == 134063) || (labelProton == 135417) || (labelProton == 136194) || (labelProton == 137441) || (labelProton == 138569) || (labelProton == 139167) || (labelProton == 141741) || (labelProton == 143422) || (labelProton == 144322) || (labelProton == 145013) || (labelProton == 145695) || (labelProton == 147134) || (labelProton == 148503) || (labelProton == 149283) || (labelProton == 149728) || (labelProton == 153214) || (labelProton == 154481) || (labelProton == 155193) || (labelProton == 158187) || (labelProton == 159039) || (labelProton == 160009) || (labelProton == 161126) || (labelProton == 162191) || (labelProton == 163774) || (labelProton == 165792) || (labelProton == 166934) || (labelProton == 168768) || (labelProton == 174013) || (labelProton == 174017) || (labelProton == 175467) || (labelProton == 177005) || (labelProton == 177258) || (labelProton == 178380) || (labelProton == 179566) || (labelProton == 179577) || (labelProton == 181145) || (labelProton == 187316) || (labelProton == 188512) || (labelProton == 189094) || (labelProton == 191582) || (labelProton == 193018) || (labelProton == 194159) || (labelProton == 195821) || (labelProton == 197459) || (labelProton == 201840) || (labelProton == 202646) || (labelProton == 203119) || (labelProton == 203763) || (labelProton == 205553) || (labelProton == 207745) || (labelProton == 208851) || (labelProton == 211636) || (labelProton == 216231) || (labelProton == 217125) || (labelProton == 217516) || (labelProton == 218522) || (labelProton == 219477) || (labelProton == 219960) || (labelProton == 223246) || (labelProton == 224677) || (labelProton == 224702) || (labelProton == 225438) || (labelProton == 227194) || (labelProton == 230507) || (labelProton == 231304) || (labelProton == 232070) || (labelProton == 232772) || (labelProton == 234765) || (labelProton == 235877) || (labelProton == 236893) || (labelProton == 237989) || (labelProton == 239575) || (labelProton == 241469) || (labelProton == 243404) || (labelProton == 244872) || (labelProton == 245511) || (labelProton == 246688) || (labelProton == 249625) || (labelProton == 250580) || (labelProton == 251879) || (labelProton == 253031) || (labelProton == 254465) || (labelProton == 254511) || (labelProton == 255917) || (labelProton == 256782) || (labelProton == 258734) || (labelProton == 261436) || (labelProton == 262878) || (labelProton == 264465) || (labelProton == 264467) || (labelProton == 268907) || (labelProton == 269974) || (labelProton == 271856) || (labelProton == 274044) || (labelProton == 276071) || (labelProton == 276915) || (labelProton == 278461) || (labelProton == 279559) || (labelProton == 280441) || (labelProton == 281783) || (labelProton == 281976) || (labelProton == 283405) || (labelProton == 284722) || (labelProton == 286324) || (labelProton == 287929) || (labelProton == 289681) || (labelProton == 291005) || (labelProton == 292324) || (labelProton == 293478) || (labelProton == 296484) || (labelProton == 300536); +} + +//--------------------------------- + +inline bool isLcK0SpFunc(int labelProton, int labelK0SPos, int labelK0SNeg) +{ + + return (labelProton == 717 && labelK0SPos == 729 && labelK0SNeg == 730) || (labelProton == 2810 && labelK0SPos == 2866 && labelK0SNeg == 2867) || (labelProton == 4393 && labelK0SPos == 4754 && labelK0SNeg == 4755) || (labelProton == 5442 && labelK0SPos == 5457 && labelK0SNeg == 5458) || (labelProton == 6769 && labelK0SPos == 6891 && labelK0SNeg == 6892) || (labelProton == 7793 && labelK0SPos == 7824 && labelK0SNeg == 7825) || (labelProton == 9002 && labelK0SPos == 9243 && labelK0SNeg == 9244) || (labelProton == 9789 && labelK0SPos == 9810 && labelK0SNeg == 9811) || (labelProton == 10385 && labelK0SPos == 10388 && labelK0SNeg == 10389) || (labelProton == 12601 && labelK0SPos == 12665 && labelK0SNeg == 12666) || (labelProton == 13819 && labelK0SPos == 13830 && labelK0SNeg == 13831) || (labelProton == 17443 && labelK0SPos == 17460 && labelK0SNeg == 17461) || (labelProton == 19936 && labelK0SPos == 19955 && labelK0SNeg == 19956) || (labelProton == 21715 && labelK0SPos == 21786 && labelK0SNeg == 21787) || (labelProton == 23285 && labelK0SPos == 23319 && labelK0SNeg == 23320) || (labelProton == 23999 && labelK0SPos == 24010 && labelK0SNeg == 24011) || (labelProton == 25676 && labelK0SPos == 26234 && labelK0SNeg == 26235) || (labelProton == 28660 && labelK0SPos == 28713 && labelK0SNeg == 28714) || (labelProton == 30684 && labelK0SPos == 30699 && labelK0SNeg == 30700) || (labelProton == 32049 && labelK0SPos == 32056 && labelK0SNeg == 32057) || (labelProton == 34846 && labelK0SPos == 34866 && labelK0SNeg == 34867) || (labelProton == 37042 && labelK0SPos == 37075 && labelK0SNeg == 37076) || (labelProton == 39278 && labelK0SPos == 39314 && labelK0SNeg == 39315) || (labelProton == 40278 && labelK0SPos == 40287 && labelK0SNeg == 40288) || (labelProton == 41567 && labelK0SPos == 41617 && labelK0SNeg == 41618) || (labelProton == 43696 && labelK0SPos == 43790 && labelK0SNeg == 43791) || (labelProton == 44819 && labelK0SPos == 44868 && labelK0SNeg == 44869) || (labelProton == 45232 && labelK0SPos == 45252 && labelK0SNeg == 45253) || (labelProton == 46578 && labelK0SPos == 46587 && labelK0SNeg == 46588) || (labelProton == 47831 && labelK0SPos == 47866 && labelK0SNeg == 47867) || (labelProton == 48981 && labelK0SPos == 48992 && labelK0SNeg == 48993) || (labelProton == 53527 && labelK0SPos == 53534 && labelK0SNeg == 53535) || (labelProton == 57152 && labelK0SPos == 57211 && labelK0SNeg == 57212) || (labelProton == 58155 && labelK0SPos == 58160 && labelK0SNeg == 58161) || (labelProton == 59296 && labelK0SPos == 59355 && labelK0SNeg == 59356) || (labelProton == 61010 && labelK0SPos == 61019 && labelK0SNeg == 61020) || (labelProton == 61932 && labelK0SPos == 62003 && labelK0SNeg == 62004) || (labelProton == 63577 && labelK0SPos == 63580 && labelK0SNeg == 63581) || (labelProton == 65683 && labelK0SPos == 65691 && labelK0SNeg == 65692) || (labelProton == 68047 && labelK0SPos == 68164 && labelK0SNeg == 68165) || (labelProton == 69657 && labelK0SPos == 69721 && labelK0SNeg == 69722) || (labelProton == 70721 && labelK0SPos == 70852 && labelK0SNeg == 70853) || (labelProton == 73141 && labelK0SPos == 73167 && labelK0SNeg == 73168) || (labelProton == 75320 && labelK0SPos == 75331 && labelK0SNeg == 75332) || (labelProton == 76581 && labelK0SPos == 76641 && labelK0SNeg == 76642) || (labelProton == 78165 && labelK0SPos == 78188 && labelK0SNeg == 78189) || (labelProton == 79504 && labelK0SPos == 79595 && labelK0SNeg == 79596) || (labelProton == 80662 && labelK0SPos == 80678 && labelK0SNeg == 80679) || (labelProton == 81552 && labelK0SPos == 81613 && labelK0SNeg == 81614) || (labelProton == 84208 && labelK0SPos == 84311 && labelK0SNeg == 84312) || (labelProton == 86342 && labelK0SPos == 86376 && labelK0SNeg == 86377) || (labelProton == 86829 && labelK0SPos == 86840 && labelK0SNeg == 86841) || (labelProton == 87347 && labelK0SPos == 87374 && labelK0SNeg == 87375) || (labelProton == 89922 && labelK0SPos == 89998 && labelK0SNeg == 89999) || (labelProton == 95032 && labelK0SPos == 95078 && labelK0SNeg == 95079) || (labelProton == 96087 && labelK0SPos == 96094 && labelK0SNeg == 96095) || (labelProton == 97410 && labelK0SPos == 97425 && labelK0SNeg == 97426) || (labelProton == 100154 && labelK0SPos == 100157 && labelK0SNeg == 100158) || (labelProton == 101743 && labelK0SPos == 101788 && labelK0SNeg == 101789) || (labelProton == 103368 && labelK0SPos == 103468 && labelK0SNeg == 103469) || (labelProton == 104635 && labelK0SPos == 104646 && labelK0SNeg == 104647) || (labelProton == 106089 && labelK0SPos == 106155 && labelK0SNeg == 106156) || (labelProton == 108676 && labelK0SPos == 108696 && labelK0SNeg == 108697) || (labelProton == 110308 && labelK0SPos == 110388 && labelK0SNeg == 110389) || (labelProton == 111335 && labelK0SPos == 111355 && labelK0SNeg == 111356) || (labelProton == 111342 && labelK0SPos == 111348 && labelK0SNeg == 111349) || (labelProton == 112606 && labelK0SPos == 112712 && labelK0SNeg == 112713) || (labelProton == 113469 && labelK0SPos == 113578 && labelK0SNeg == 113579) || (labelProton == 114529 && labelK0SPos == 114556 && labelK0SNeg == 114557) || (labelProton == 114533 && labelK0SPos == 114550 && labelK0SNeg == 114551) || (labelProton == 116388 && labelK0SPos == 116432 && labelK0SNeg == 116433) || (labelProton == 117754 && labelK0SPos == 117766 && labelK0SNeg == 117767) || (labelProton == 118765 && labelK0SPos == 118796 && labelK0SNeg == 118797) || (labelProton == 118784 && labelK0SPos == 118790 && labelK0SNeg == 118791) || (labelProton == 119733 && labelK0SPos == 119766 && labelK0SNeg == 119767) || (labelProton == 120691 && labelK0SPos == 120728 && labelK0SNeg == 120729) || (labelProton == 121773 && labelK0SPos == 121872 && labelK0SNeg == 121873) || (labelProton == 123970 && labelK0SPos == 124027 && labelK0SNeg == 124028) || (labelProton == 125316 && labelK0SPos == 125407 && labelK0SNeg == 125408) || (labelProton == 127253 && labelK0SPos == 127284 && labelK0SNeg == 127285) || (labelProton == 129008 && labelK0SPos == 129068 && labelK0SNeg == 129069) || (labelProton == 129883 && labelK0SPos == 129924 && labelK0SNeg == 129925) || (labelProton == 131408 && labelK0SPos == 131453 && labelK0SNeg == 131454) || (labelProton == 132349 && labelK0SPos == 132456 && labelK0SNeg == 132457) || (labelProton == 132395 && labelK0SPos == 132436 && labelK0SNeg == 132437) || (labelProton == 133263 && labelK0SPos == 133266 && labelK0SNeg == 133267) || (labelProton == 134063 && labelK0SPos == 134084 && labelK0SNeg == 134085) || (labelProton == 135417 && labelK0SPos == 135470 && labelK0SNeg == 135471) || (labelProton == 136194 && labelK0SPos == 136207 && labelK0SNeg == 136208) || (labelProton == 137441 && labelK0SPos == 137446 && labelK0SNeg == 137447) || (labelProton == 138569 && labelK0SPos == 138616 && labelK0SNeg == 138617) || (labelProton == 139167 && labelK0SPos == 139217 && labelK0SNeg == 139218) || (labelProton == 141741 && labelK0SPos == 141832 && labelK0SNeg == 141833) || (labelProton == 143422 && labelK0SPos == 143513 && labelK0SNeg == 143514) || (labelProton == 144322 && labelK0SPos == 144416 && labelK0SNeg == 144417) || (labelProton == 145013 && labelK0SPos == 145018 && labelK0SNeg == 145019) || (labelProton == 145695 && labelK0SPos == 145702 && labelK0SNeg == 145703) || (labelProton == 147134 && labelK0SPos == 147139 && labelK0SNeg == 147140) || (labelProton == 148503 && labelK0SPos == 148508 && labelK0SNeg == 148509) || (labelProton == 149283 && labelK0SPos == 149290 && labelK0SNeg == 149291) || (labelProton == 149728 && labelK0SPos == 149737 && labelK0SNeg == 149738) || (labelProton == 153214 && labelK0SPos == 153271 && labelK0SNeg == 153272) || (labelProton == 154481 && labelK0SPos == 154515 && labelK0SNeg == 154516) || (labelProton == 155193 && labelK0SPos == 155206 && labelK0SNeg == 155207) || (labelProton == 158187 && labelK0SPos == 158200 && labelK0SNeg == 158201) || (labelProton == 159039 && labelK0SPos == 159059 && labelK0SNeg == 159060) || (labelProton == 160009 && labelK0SPos == 160082 && labelK0SNeg == 160083) || (labelProton == 161126 && labelK0SPos == 161140 && labelK0SNeg == 161141) || (labelProton == 162191 && labelK0SPos == 162208 && labelK0SNeg == 162209) || (labelProton == 163774 && labelK0SPos == 163777 && labelK0SNeg == 163778) || (labelProton == 165792 && labelK0SPos == 165874 && labelK0SNeg == 165875) || (labelProton == 166934 && labelK0SPos == 167001 && labelK0SNeg == 167002) || (labelProton == 168768 && labelK0SPos == 168852 && labelK0SNeg == 168853) || (labelProton == 174013 && labelK0SPos == 174033 && labelK0SNeg == 174034) || (labelProton == 174017 && labelK0SPos == 174027 && labelK0SNeg == 174028) || (labelProton == 175467 && labelK0SPos == 175501 && labelK0SNeg == 175502) || (labelProton == 177005 && labelK0SPos == 177396 && labelK0SNeg == 177397) || (labelProton == 177258 && labelK0SPos == 177265 && labelK0SNeg == 177266) || (labelProton == 178380 && labelK0SPos == 178383 && labelK0SNeg == 178384) || (labelProton == 179566 && labelK0SPos == 179595 && labelK0SNeg == 179596) || (labelProton == 179577 && labelK0SPos == 179580 && labelK0SNeg == 179581) || (labelProton == 181145 && labelK0SPos == 181168 && labelK0SNeg == 181169) || (labelProton == 187316 && labelK0SPos == 187326 && labelK0SNeg == 187327) || (labelProton == 188512 && labelK0SPos == 188608 && labelK0SNeg == 188609) || (labelProton == 189094 && labelK0SPos == 189128 && labelK0SNeg == 189129) || (labelProton == 191582 && labelK0SPos == 191591 && labelK0SNeg == 191592) || (labelProton == 193018 && labelK0SPos == 193025 && labelK0SNeg == 193026) || (labelProton == 194159 && labelK0SPos == 194170 && labelK0SNeg == 194171) || (labelProton == 195821 && labelK0SPos == 195824 && labelK0SNeg == 195825) || (labelProton == 197459 && labelK0SPos == 197472 && labelK0SNeg == 197473) || (labelProton == 201840 && labelK0SPos == 201905 && labelK0SNeg == 201906) || (labelProton == 202646 && labelK0SPos == 202664 && labelK0SNeg == 202665) || (labelProton == 203119 && labelK0SPos == 203163 && labelK0SNeg == 203164) || (labelProton == 203763 && labelK0SPos == 203835 && labelK0SNeg == 203836) || (labelProton == 205553 && labelK0SPos == 205556 && labelK0SNeg == 205557) || (labelProton == 207745 && labelK0SPos == 207838 && labelK0SNeg == 207839) || (labelProton == 208851 && labelK0SPos == 208866 && labelK0SNeg == 208867) || (labelProton == 211636 && labelK0SPos == 211654 && labelK0SNeg == 211655) || (labelProton == 216231 && labelK0SPos == 216312 && labelK0SNeg == 216313) || (labelProton == 217125 && labelK0SPos == 217132 && labelK0SNeg == 217133) || (labelProton == 217516 && labelK0SPos == 217554 && labelK0SNeg == 217555) || (labelProton == 218522 && labelK0SPos == 218616 && labelK0SNeg == 218617) || (labelProton == 219477 && labelK0SPos == 219503 && labelK0SNeg == 219504) || (labelProton == 219960 && labelK0SPos == 219996 && labelK0SNeg == 219997) || (labelProton == 223246 && labelK0SPos == 223354 && labelK0SNeg == 223355) || (labelProton == 224677 && labelK0SPos == 224713 && labelK0SNeg == 224714) || (labelProton == 224702 && labelK0SPos == 224707 && labelK0SNeg == 224708) || (labelProton == 225438 && labelK0SPos == 225482 && labelK0SNeg == 225483) || (labelProton == 227194 && labelK0SPos == 227207 && labelK0SNeg == 227208) || (labelProton == 230507 && labelK0SPos == 230562 && labelK0SNeg == 230563) || (labelProton == 231304 && labelK0SPos == 231324 && labelK0SNeg == 231325) || (labelProton == 232070 && labelK0SPos == 232083 && labelK0SNeg == 232084) || (labelProton == 232772 && labelK0SPos == 232809 && labelK0SNeg == 232810) || (labelProton == 234765 && labelK0SPos == 234774 && labelK0SNeg == 234775) || (labelProton == 235877 && labelK0SPos == 235892 && labelK0SNeg == 235893) || (labelProton == 236893 && labelK0SPos == 236900 && labelK0SNeg == 236901) || (labelProton == 237989 && labelK0SPos == 238038 && labelK0SNeg == 238039) || (labelProton == 239575 && labelK0SPos == 239629 && labelK0SNeg == 239630) || (labelProton == 241469 && labelK0SPos == 241517 && labelK0SNeg == 241518) || (labelProton == 243404 && labelK0SPos == 243460 && labelK0SNeg == 243461) || (labelProton == 244872 && labelK0SPos == 244881 && labelK0SNeg == 244882) || (labelProton == 245511 && labelK0SPos == 245553 && labelK0SNeg == 245554) || (labelProton == 246688 && labelK0SPos == 246721 && labelK0SNeg == 246722) || (labelProton == 249625 && labelK0SPos == 249672 && labelK0SNeg == 249673) || (labelProton == 250580 && labelK0SPos == 250589 && labelK0SNeg == 250590) || (labelProton == 251879 && labelK0SPos == 251882 && labelK0SNeg == 251883) || (labelProton == 253031 && labelK0SPos == 253034 && labelK0SNeg == 253035) || (labelProton == 254465 && labelK0SPos == 254543 && labelK0SNeg == 254544) || (labelProton == 254511 && labelK0SPos == 254539 && labelK0SNeg == 254540) || (labelProton == 255917 && labelK0SPos == 255941 && labelK0SNeg == 255942) || (labelProton == 256782 && labelK0SPos == 256808 && labelK0SNeg == 256809) || (labelProton == 258734 && labelK0SPos == 258807 && labelK0SNeg == 258808) || (labelProton == 261436 && labelK0SPos == 261612 && labelK0SNeg == 261613) || (labelProton == 262878 && labelK0SPos == 262887 && labelK0SNeg == 262888) || (labelProton == 264465 && labelK0SPos == 264473 && labelK0SNeg == 264474) || (labelProton == 264467 && labelK0SPos == 264471 && labelK0SNeg == 264472) || (labelProton == 268907 && labelK0SPos == 268912 && labelK0SNeg == 268913) || (labelProton == 269974 && labelK0SPos == 270023 && labelK0SNeg == 270024) || (labelProton == 271856 && labelK0SPos == 271998 && labelK0SNeg == 271999) || (labelProton == 274044 && labelK0SPos == 274081 && labelK0SNeg == 274082) || (labelProton == 276071 && labelK0SPos == 276125 && labelK0SNeg == 276126) || (labelProton == 276915 && labelK0SPos == 276952 && labelK0SNeg == 276953) || (labelProton == 278461 && labelK0SPos == 278530 && labelK0SNeg == 278531) || (labelProton == 279559 && labelK0SPos == 279613 && labelK0SNeg == 279614) || (labelProton == 280441 && labelK0SPos == 280446 && labelK0SNeg == 280447) || (labelProton == 281783 && labelK0SPos == 282152 && labelK0SNeg == 282153) || (labelProton == 281976 && labelK0SPos == 282034 && labelK0SNeg == 282035) || (labelProton == 283405 && labelK0SPos == 283408 && labelK0SNeg == 283409) || (labelProton == 284722 && labelK0SPos == 284753 && labelK0SNeg == 284754) || (labelProton == 286324 && labelK0SPos == 286615 && labelK0SNeg == 286616) || (labelProton == 287929 && labelK0SPos == 288037 && labelK0SNeg == 288038) || (labelProton == 289681 && labelK0SPos == 289736 && labelK0SNeg == 289737) || (labelProton == 291005 && labelK0SPos == 291009 && labelK0SNeg == 291010) || (labelProton == 292324 && labelK0SPos == 292336 && labelK0SNeg == 292337) || (labelProton == 293478 && labelK0SPos == 293565 && labelK0SNeg == 293566) || (labelProton == 296484 && labelK0SPos == 296529 && labelK0SNeg == 296530) || (labelProton == 300536 && labelK0SPos == 300564 && labelK0SNeg == 300565); +} From 8351e9ccc2ea312b8fbf6f0168452c6b926c1f91 Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Thu, 8 Apr 2021 00:58:25 +0200 Subject: [PATCH 10/14] Revisiting debugging --- .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 21 ++++++++-- .../Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx | 11 ++++- .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 22 +++++++--- Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx | 18 ++++++-- .../AnalysisTasksUtils/UtilsDebugLcK0Sp.h | 41 +++++++++++++++---- 5 files changed, 92 insertions(+), 21 deletions(-) diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index ff922ff644c5a..e05b5a73cf7f6 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -44,7 +44,12 @@ struct HFCandidateCreatorCascade { Configurable d_minParamChange{"d_minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; Configurable d_minRelChi2Change{"d_minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; Configurable b_doValPlots{"b_doValPlots", true, "do validation plots"}; - +#ifdef MY_DEBUG + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelProton{"v_labelProton", {729, 2810, 4393}, "labels of K0S positive daughters, for debug"}; +#endif + OutputObj hmass2{TH1F("hmass2", "2-prong candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", 500, 0., 5.)}; OutputObj hCovPVXX{TH1F("hCovPVXX", "2-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; OutputObj hCovSVXX{TH1F("hCovSVXX", "2-prong candidates;XX element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; @@ -100,7 +105,7 @@ struct HFCandidateCreatorCascade { auto protonLabel = bach.mcParticleId(); auto labelPos = posTrack.mcParticleId(); auto labelNeg = negTrack.mcParticleId(); - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg); + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, v_labelProton, v_labelK0Spos, v_labelK0Sneg); #endif MY_DEBUG_MSG(isLc, LOG(INFO) << "Processing the Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg); @@ -202,6 +207,12 @@ struct HFCandidateCreatorCascadeMC { Produces rowMCMatchRec; Produces rowMCMatchGen; +#ifdef MY_DEBUG + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelProton{"v_labelProton", {729, 2810, 4393}, "labels of K0S positive daughters, for debug"}; +#endif + void process(aod::HfCandCascade const& candidates, aod::BigTracksMC const& tracks, aod::McParticles const& particlesMC) @@ -224,8 +235,10 @@ struct HFCandidateCreatorCascadeMC { auto labelNeg = candidate.negTrack_as().mcParticleId(); auto protonLabel = candidate.index0_as().mcParticleId(); - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg); +#ifdef MY_DEBUG + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, v_labelProton, v_labelK0Spos, v_labelK0Sneg); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, v_labelK0Spos, v_labelK0Sneg); +#endif MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "correct K0S in the Lc daughters: posTrack --> " << labelPos << ", negTrack --> " << labelNeg); //if (isLc) { diff --git a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx index 3651ded968d81..191f407eb88d2 100644 --- a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx +++ b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx @@ -70,6 +70,13 @@ struct HFLcK0sPCandidateSelector { Configurable d_TPCNClsFindablePIDCut{"d_TPCNClsFindablePIDCut", 50., "Lower bound of TPC findable clusters for good PID"}; Configurable b_requireTPC{"b_requireTPC", true, "Flag to require a positive Number of found clusters in TPC"}; + // for debugging +#ifdef MY_DEBUG + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelProton{"v_labelProton", {729, 2810, 4393}, "labels of K0S positive daughters, for debug"}; +#endif + /// Gets corresponding pT bin from cut file array /// \param candPt is the pT of the candidate /// \return corresponding bin number of array @@ -334,8 +341,8 @@ struct HFLcK0sPCandidateSelector { auto labelPos = candidate.posTrack_as().mcParticleId(); auto labelNeg = candidate.negTrack_as().mcParticleId(); auto protonLabel = candidate.index0_as().mcParticleId(); - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg); + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, v_labelProton, v_labelK0Spos, v_labelK0Sneg); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, v_labelK0Spos, v_labelK0Sneg); #endif MY_DEBUG_MSG(isLc, printf("\n"); LOG(INFO) << "In selector: correct Lc found: proton --> " << protonLabel << ", posTrack --> " << labelPos << ", negTrack --> " << labelNeg); //MY_DEBUG_MSG(isLc != 1, printf("\n"); LOG(INFO) << "In selector: wrong Lc found: proton --> " << protonLabel << ", posTrack --> " << labelPos << ", negTrack --> " << labelNeg); diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index 415d8765481b2..a2027c5871f85 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -91,7 +91,12 @@ struct SelectTracks { Configurable d_dcaToPrimXYMinBach{"d_dcaToPrimXYMinBach", 0., "min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; // for PbPb 2018, the cut should be 0.0025 Configurable d_dcaToPrimXYMaxBach{"d_dcaToPrimXYMaxBach", 1.0, "max. DCAXY to prim. vtx. for bachelor in cascade candidate"}; Configurable d_etaMaxBach{"d_etaMaxBach", 0.8, "max. pseudorapidity for bachelor in cascade candidate"}; - +#ifdef MY_DEBUG + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelProton{"v_labelProton", {729, 2810, 4393}, "labels of K0S positive daughters, for debug"}; +#endif + HistogramRegistry registry{ "registry", {{"hpt_nocuts", "all tracks;#it{p}_{T}^{track} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, @@ -153,7 +158,7 @@ struct SelectTracks { #ifdef MY_DEBUG auto protonLabel = track.mcParticleId(); // LOG(INFO) << "Checking label " << protonLabel; - bool isProtonFromLc = isProtonFromLcFunc(protonLabel); + bool isProtonFromLc = isProtonFromLcFunc(protonLabel, v_labelProton); #endif @@ -1046,6 +1051,13 @@ struct HFTrackIndexSkimsCreatorCascades { Configurable d_cutCascInvMassLc{"d_cutCascInvMassLc", 1., "Lc candidate invariant mass difference wrt PDG"}; // for PbPb 2018: use 0.2 //Configurable cutCascDCADaughters{"cutCascDCADaughters", .1, "DCA between V0 and bachelor in cascade"}; + // for debugging +#ifdef MY_DEBUG + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelProton{"v_labelProton", {729, 2810, 4393}, "labels of K0S positive daughters, for debug"}; +#endif + // histograms HistogramRegistry registry{ "registry", @@ -1098,7 +1110,7 @@ struct HFTrackIndexSkimsCreatorCascades { MY_DEBUG_MSG(1, printf("\n"); LOG(INFO) << "Bachelor loop"); #ifdef MY_DEBUG auto protonLabel = bach.mcParticleId(); - bool isProtonFromLc = isProtonFromLcFunc(protonLabel); + bool isProtonFromLc = isProtonFromLcFunc(protonLabel, v_labelProton); #endif // selections on the bachelor // pT cut @@ -1129,9 +1141,9 @@ struct HFTrackIndexSkimsCreatorCascades { #ifdef MY_DEBUG auto labelPos = posTrack.mcParticleId(); auto labelNeg = negTrack.mcParticleId(); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, v_labelK0Spos, v_labelK0Sneg); - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg); + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, v_labelProton, v_labelK0Spos, v_labelK0Sneg); #endif MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S from Lc found, posTrack --> " << labelPos << ", negTrack --> " << labelNeg); diff --git a/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx b/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx index 39c284cee74a0..bf24cf096c13a 100644 --- a/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx +++ b/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx @@ -76,7 +76,7 @@ DECLARE_SOA_TABLE(V0GoodIndices, "AOD", "V0GOODINDICES", o2::soa::Index<>, using FullTracksExt = soa::Join; using FullTracksExtMC = soa::Join; -//#define MY_DEBUG +#define MY_DEBUG #ifdef MY_DEBUG using MyTracks = FullTracksExtMC; #define MY_DEBUG_MSG(condition, cmd) \ @@ -97,6 +97,12 @@ struct lambdakzeroprefilterpairs { Configurable mincrossedrows{"mincrossedrows", 70, "min crossed rows"}; Configurable tpcrefit{"tpcrefit", 1, "demand TPC refit"}; + // for debugging +#ifdef MY_DEBUG + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; +#endif + HistogramRegistry registry{ "registry", { @@ -119,7 +125,7 @@ struct lambdakzeroprefilterpairs { #ifdef MY_DEBUG auto labelPos = V0.posTrack_as().mcParticleId(); auto labelNeg = V0.negTrack_as().mcParticleId(); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, v_labelK0Spos, v_labelK0Sneg); #endif MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "V0 builder: found K0S from Lc, posTrack --> " << labelPos << ", negTrack --> " << labelNeg); @@ -183,6 +189,12 @@ struct lambdakzerobuilder { Configurable dcav0dau{"dcav0dau", 1.0, "DCA V0 Daughters"}; Configurable v0radius{"v0radius", 5.0, "v0radius"}; + // for debugging +#ifdef MY_DEBUG + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; +#endif + double massPi = TDatabasePDG::Instance()->GetParticle(kPiPlus)->Mass(); double massKa = TDatabasePDG::Instance()->GetParticle(kKPlus)->Mass(); double massPr = TDatabasePDG::Instance()->GetParticle(kProton)->Mass(); @@ -216,7 +228,7 @@ struct lambdakzerobuilder { #ifdef MY_DEBUG auto labelPos = V0.posTrack_as().mcParticleId(); auto labelNeg = V0.negTrack_as().mcParticleId(); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, v_labelK0Spos, v_labelK0Sneg); #endif MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "labelPos = " << labelPos << ", labelNeg = " << labelNeg); diff --git a/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h b/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h index b24719ee48553..804df528f1c0e 100644 --- a/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h +++ b/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h @@ -10,27 +10,54 @@ /// \file UtilsDebugLcK0Sp /// \brief Some utilities to do debugging for the LcK0Sp task -/// this MC info apply to: /alice/sim/2020/LHC20l3a/286350/PWGZZ/Run3_Conversion/156_20210308-1000/0001/AO2D.root /// +/// For example, for: /alice/sim/2020/LHC20l3a/286350/PWGZZ/Run3_Conversion/156_20210308-1000/0001/AO2D.root +/// +/// listLabelsProton = {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789, 10385, 12601, 13819, 17443, 19936, 21715, 23285, 23999, 25676, 28660, 30684, 32049, 34846, 37042, 39278, 40278, 41567, 43696, 44819, 45232, 46578, 47831, 48981, 53527, 57152, 58155, 59296, 61010, 61932, 63577, 65683, 68047, 69657, 70721, 73141, 75320, 76581, 78165, 79504, 80662, 81552, 84208, 86342, 86829, 87347, 89922, 95032, 96087, 97410, 100154, 101743, 103368, 104635, 106089, 108676, 110308, 111335, 111342, 112606, 113469, 114529, 114533, 116388, 117754, 118765, 118784, 119733, 120691, 121773, 123970, 125316, 127253, 129008, 129883, 131408, 132349, 132395, 133263, 134063, 135417, 136194, 137441, 138569, 139167, 141741, 143422, 144322, 145013, 145695, 147134, 148503, 149283, 149728, 153214, 154481, 155193, 158187, 159039, 160009, 161126, 162191, 163774, 165792, 166934, 168768, 174013, 174017, 175467, 177005, 177258, 178380, 179566, 179577, 181145, 187316, 188512, 189094, 191582, 193018, 194159, 195821, 197459, 201840, 202646, 203119, 203763, 205553, 207745, 208851, 211636, 216231, 217125, 217516, 218522, 219477, 219960, 223246, 224677, 224702, 225438, 227194, 230507, 231304, 232070, 232772, 234765, 235877, 236893, 237989, 239575, 241469, 243404, 244872, 245511, 246688, 249625, 250580, 251879, 253031, 254465, 254511, 255917, 256782, 258734, 261436, 262878, 264465, 264467, 268907, 269974, 271856, 274044, 276071, 276915, 278461, 279559, 280441, 281783, 281976, 283405, 284722, 286324, 287929, 289681, 291005, 292324, 293478, 296484, 300536} +/// listLabelsK0SPos = {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810, 10388, 12665, 13830, 17460, 19955, 21786, 23319, 24010, 26234, 28713, 30699, 32056, 34866, 37075, 39314, 40287, 41617, 43790, 44868, 45252, 46587, 47866, 48992, 53534, 57211, 58160, 59355, 61019, 62003, 63580, 65691, 68164, 69721, 70852, 73167, 75331, 76641, 78188, 79595, 80678, 81613, 84311, 86376, 86840, 87374, 89998, 95078, 96094, 97425, 100157, 101788, 103468, 104646, 106155, 108696, 110388, 111355, 111348, 112712, 113578, 114556, 114550, 116432, 117766, 118796, 118790, 119766, 120728, 121872, 124027, 125407, 127284, 129068, 129924, 131453, 132456, 132436, 133266, 134084, 135470, 136207, 137446, 138616, 139217, 141832, 143513, 144416, 145018, 145702, 147139, 148508, 149290, 149737, 153271, 154515, 155206, 158200, 159059, 160082, 161140, 162208, 163777, 165874, 167001, 168852, 174033, 174027, 175501, 177396, 177265, 178383, 179595, 179580, 181168, 187326, 188608, 189128, 191591, 193025, 194170, 195824, 197472, 201905, 202664, 203163, 203835, 205556, 207838, 208866, 211654, 216312, 217132, 217554, 218616, 219503, 219996, 223354, 224713, 224707, 225482, 227207, 230562, 231324, 232083, 232809, 234774, 235892, 236900, 238038, 239629, 241517, 243460, 244881, 245553, 246721, 249672, 250589, 251882, 253034, 254543, 254539, 255941, 256808, 258807, 261612, 262887, 264473, 264471, 268912, 270023, 271998, 274081, 276125, 276952, 278530, 279613, 280446, 282152, 282034, 283408, 284753, 286615, 288037, 289736, 291009, 292336, 293565, 296529, 300564} +/// listLabelsK0SNeg = {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811, 10389, 12666, 13831, 17461, 19956, 21787, 23320, 24011, 26235, 28714, 30700, 32057, 34867, 37076, 39315, 40288, 41618, 43791, 44869, 45253, 46588, 47867, 48993, 53535, 57212, 58161, 59356, 61020, 62004, 63581, 65692, 68165, 69722, 70853, 73168, 75332, 76642, 78189, 79596, 80679, 81614, 84312, 86377, 86841, 87375, 89999, 95079, 96095, 97426, 100158, 101789, 103469, 104647, 106156, 108697, 110389, 111356, 111349, 112713, 113579, 114557, 114551, 116433, 117767, 118797, 118791, 119767, 120729, 121873, 124028, 125408, 127285, 129069, 129925, 131454, 132457, 132437, 133267, 134085, 135471, 136208, 137447, 138617, 139218, 141833, 143514, 144417, 145019, 145703, 147140, 148509, 149291, 149738, 153272, 154516, 155207, 158201, 159060, 160083, 161141, 162209, 163778, 165875, 167002, 168853, 174034, 174028, 175502, 177397, 177266, 178384, 179596, 179581, 181169, 187327, 188609, 189129, 191592, 193026, 194171, 195825, 197473, 201906, 202665, 203164, 203836, 205557, 207839, 208867, 211655, 216313, 217133, 217555, 218617, 219504, 219997, 223355, 224714, 224708, 225483, 227208, 230563, 231325, 232084, 232810, 234775, 235893, 236901, 238039, 239630, 241518, 243461, 244882, 245554, 246722, 249673, 250590, 251883, 253035, 254544, 254540, 255942, 256809, 258808, 261613, 262888, 264474, 264472, 268913, 270024, 271999, 274082, 276126, 276953, 278531, 279614, 280447, 282153, 282035, 283409, 284754, 286616, 288038, 289737, 291010, 292337, 293566, 296530, 300565} +/// + +#include -inline bool isK0SfromLcFunc(int labelK0SPos, int labelK0SNeg) +inline bool isK0SfromLcFunc(int labelK0SPos, int labelK0SNeg, std::vector listLabelsK0SPos, std::vector listLabelsK0SNeg) { - return (labelK0SPos == 729 && labelK0SNeg == 730) || (labelK0SPos == 2866 && labelK0SNeg == 2867) || (labelK0SPos == 4754 && labelK0SNeg == 4755) || (labelK0SPos == 5457 && labelK0SNeg == 5458) || (labelK0SPos == 6891 && labelK0SNeg == 6892) || (labelK0SPos == 7824 && labelK0SNeg == 7825) || (labelK0SPos == 9243 && labelK0SNeg == 9244) || (labelK0SPos == 9810 && labelK0SNeg == 9811) || (labelK0SPos == 10388 && labelK0SNeg == 10389) || (labelK0SPos == 12665 && labelK0SNeg == 12666) || (labelK0SPos == 13830 && labelK0SNeg == 13831) || (labelK0SPos == 17460 && labelK0SNeg == 17461) || (labelK0SPos == 19955 && labelK0SNeg == 19956) || (labelK0SPos == 21786 && labelK0SNeg == 21787) || (labelK0SPos == 23319 && labelK0SNeg == 23320) || (labelK0SPos == 24010 && labelK0SNeg == 24011) || (labelK0SPos == 26234 && labelK0SNeg == 26235) || (labelK0SPos == 28713 && labelK0SNeg == 28714) || (labelK0SPos == 30699 && labelK0SNeg == 30700) || (labelK0SPos == 32056 && labelK0SNeg == 32057) || (labelK0SPos == 34866 && labelK0SNeg == 34867) || (labelK0SPos == 37075 && labelK0SNeg == 37076) || (labelK0SPos == 39314 && labelK0SNeg == 39315) || (labelK0SPos == 40287 && labelK0SNeg == 40288) || (labelK0SPos == 41617 && labelK0SNeg == 41618) || (labelK0SPos == 43790 && labelK0SNeg == 43791) || (labelK0SPos == 44868 && labelK0SNeg == 44869) || (labelK0SPos == 45252 && labelK0SNeg == 45253) || (labelK0SPos == 46587 && labelK0SNeg == 46588) || (labelK0SPos == 47866 && labelK0SNeg == 47867) || (labelK0SPos == 48992 && labelK0SNeg == 48993) || (labelK0SPos == 53534 && labelK0SNeg == 53535) || (labelK0SPos == 57211 && labelK0SNeg == 57212) || (labelK0SPos == 58160 && labelK0SNeg == 58161) || (labelK0SPos == 59355 && labelK0SNeg == 59356) || (labelK0SPos == 61019 && labelK0SNeg == 61020) || (labelK0SPos == 62003 && labelK0SNeg == 62004) || (labelK0SPos == 63580 && labelK0SNeg == 63581) || (labelK0SPos == 65691 && labelK0SNeg == 65692) || (labelK0SPos == 68164 && labelK0SNeg == 68165) || (labelK0SPos == 69721 && labelK0SNeg == 69722) || (labelK0SPos == 70852 && labelK0SNeg == 70853) || (labelK0SPos == 73167 && labelK0SNeg == 73168) || (labelK0SPos == 75331 && labelK0SNeg == 75332) || (labelK0SPos == 76641 && labelK0SNeg == 76642) || (labelK0SPos == 78188 && labelK0SNeg == 78189) || (labelK0SPos == 79595 && labelK0SNeg == 79596) || (labelK0SPos == 80678 && labelK0SNeg == 80679) || (labelK0SPos == 81613 && labelK0SNeg == 81614) || (labelK0SPos == 84311 && labelK0SNeg == 84312) || (labelK0SPos == 86376 && labelK0SNeg == 86377) || (labelK0SPos == 86840 && labelK0SNeg == 86841) || (labelK0SPos == 87374 && labelK0SNeg == 87375) || (labelK0SPos == 89998 && labelK0SNeg == 89999) || (labelK0SPos == 95078 && labelK0SNeg == 95079) || (labelK0SPos == 96094 && labelK0SNeg == 96095) || (labelK0SPos == 97425 && labelK0SNeg == 97426) || (labelK0SPos == 100157 && labelK0SNeg == 100158) || (labelK0SPos == 101788 && labelK0SNeg == 101789) || (labelK0SPos == 103468 && labelK0SNeg == 103469) || (labelK0SPos == 104646 && labelK0SNeg == 104647) || (labelK0SPos == 106155 && labelK0SNeg == 106156) || (labelK0SPos == 108696 && labelK0SNeg == 108697) || (labelK0SPos == 110388 && labelK0SNeg == 110389) || (labelK0SPos == 111355 && labelK0SNeg == 111356) || (labelK0SPos == 111348 && labelK0SNeg == 111349) || (labelK0SPos == 112712 && labelK0SNeg == 112713) || (labelK0SPos == 113578 && labelK0SNeg == 113579) || (labelK0SPos == 114556 && labelK0SNeg == 114557) || (labelK0SPos == 114550 && labelK0SNeg == 114551) || (labelK0SPos == 116432 && labelK0SNeg == 116433) || (labelK0SPos == 117766 && labelK0SNeg == 117767) || (labelK0SPos == 118796 && labelK0SNeg == 118797) || (labelK0SPos == 118790 && labelK0SNeg == 118791) || (labelK0SPos == 119766 && labelK0SNeg == 119767) || (labelK0SPos == 120728 && labelK0SNeg == 120729) || (labelK0SPos == 121872 && labelK0SNeg == 121873) || (labelK0SPos == 124027 && labelK0SNeg == 124028) || (labelK0SPos == 125407 && labelK0SNeg == 125408) || (labelK0SPos == 127284 && labelK0SNeg == 127285) || (labelK0SPos == 129068 && labelK0SNeg == 129069) || (labelK0SPos == 129924 && labelK0SNeg == 129925) || (labelK0SPos == 131453 && labelK0SNeg == 131454) || (labelK0SPos == 132456 && labelK0SNeg == 132457) || (labelK0SPos == 132436 && labelK0SNeg == 132437) || (labelK0SPos == 133266 && labelK0SNeg == 133267) || (labelK0SPos == 134084 && labelK0SNeg == 134085) || (labelK0SPos == 135470 && labelK0SNeg == 135471) || (labelK0SPos == 136207 && labelK0SNeg == 136208) || (labelK0SPos == 137446 && labelK0SNeg == 137447) || (labelK0SPos == 138616 && labelK0SNeg == 138617) || (labelK0SPos == 139217 && labelK0SNeg == 139218) || (labelK0SPos == 141832 && labelK0SNeg == 141833) || (labelK0SPos == 143513 && labelK0SNeg == 143514) || (labelK0SPos == 144416 && labelK0SNeg == 144417) || (labelK0SPos == 145018 && labelK0SNeg == 145019) || (labelK0SPos == 145702 && labelK0SNeg == 145703) || (labelK0SPos == 147139 && labelK0SNeg == 147140) || (labelK0SPos == 148508 && labelK0SNeg == 148509) || (labelK0SPos == 149290 && labelK0SNeg == 149291) || (labelK0SPos == 149737 && labelK0SNeg == 149738) || (labelK0SPos == 153271 && labelK0SNeg == 153272) || (labelK0SPos == 154515 && labelK0SNeg == 154516) || (labelK0SPos == 155206 && labelK0SNeg == 155207) || (labelK0SPos == 158200 && labelK0SNeg == 158201) || (labelK0SPos == 159059 && labelK0SNeg == 159060) || (labelK0SPos == 160082 && labelK0SNeg == 160083) || (labelK0SPos == 161140 && labelK0SNeg == 161141) || (labelK0SPos == 162208 && labelK0SNeg == 162209) || (labelK0SPos == 163777 && labelK0SNeg == 163778) || (labelK0SPos == 165874 && labelK0SNeg == 165875) || (labelK0SPos == 167001 && labelK0SNeg == 167002) || (labelK0SPos == 168852 && labelK0SNeg == 168853) || (labelK0SPos == 174033 && labelK0SNeg == 174034) || (labelK0SPos == 174027 && labelK0SNeg == 174028) || (labelK0SPos == 175501 && labelK0SNeg == 175502) || (labelK0SPos == 177396 && labelK0SNeg == 177397) || (labelK0SPos == 177265 && labelK0SNeg == 177266) || (labelK0SPos == 178383 && labelK0SNeg == 178384) || (labelK0SPos == 179595 && labelK0SNeg == 179596) || (labelK0SPos == 179580 && labelK0SNeg == 179581) || (labelK0SPos == 181168 && labelK0SNeg == 181169) || (labelK0SPos == 187326 && labelK0SNeg == 187327) || (labelK0SPos == 188608 && labelK0SNeg == 188609) || (labelK0SPos == 189128 && labelK0SNeg == 189129) || (labelK0SPos == 191591 && labelK0SNeg == 191592) || (labelK0SPos == 193025 && labelK0SNeg == 193026) || (labelK0SPos == 194170 && labelK0SNeg == 194171) || (labelK0SPos == 195824 && labelK0SNeg == 195825) || (labelK0SPos == 197472 && labelK0SNeg == 197473) || (labelK0SPos == 201905 && labelK0SNeg == 201906) || (labelK0SPos == 202664 && labelK0SNeg == 202665) || (labelK0SPos == 203163 && labelK0SNeg == 203164) || (labelK0SPos == 203835 && labelK0SNeg == 203836) || (labelK0SPos == 205556 && labelK0SNeg == 205557) || (labelK0SPos == 207838 && labelK0SNeg == 207839) || (labelK0SPos == 208866 && labelK0SNeg == 208867) || (labelK0SPos == 211654 && labelK0SNeg == 211655) || (labelK0SPos == 216312 && labelK0SNeg == 216313) || (labelK0SPos == 217132 && labelK0SNeg == 217133) || (labelK0SPos == 217554 && labelK0SNeg == 217555) || (labelK0SPos == 218616 && labelK0SNeg == 218617) || (labelK0SPos == 219503 && labelK0SNeg == 219504) || (labelK0SPos == 219996 && labelK0SNeg == 219997) || (labelK0SPos == 223354 && labelK0SNeg == 223355) || (labelK0SPos == 224713 && labelK0SNeg == 224714) || (labelK0SPos == 224707 && labelK0SNeg == 224708) || (labelK0SPos == 225482 && labelK0SNeg == 225483) || (labelK0SPos == 227207 && labelK0SNeg == 227208) || (labelK0SPos == 230562 && labelK0SNeg == 230563) || (labelK0SPos == 231324 && labelK0SNeg == 231325) || (labelK0SPos == 232083 && labelK0SNeg == 232084) || (labelK0SPos == 232809 && labelK0SNeg == 232810) || (labelK0SPos == 234774 && labelK0SNeg == 234775) || (labelK0SPos == 235892 && labelK0SNeg == 235893) || (labelK0SPos == 236900 && labelK0SNeg == 236901) || (labelK0SPos == 238038 && labelK0SNeg == 238039) || (labelK0SPos == 239629 && labelK0SNeg == 239630) || (labelK0SPos == 241517 && labelK0SNeg == 241518) || (labelK0SPos == 243460 && labelK0SNeg == 243461) || (labelK0SPos == 244881 && labelK0SNeg == 244882) || (labelK0SPos == 245553 && labelK0SNeg == 245554) || (labelK0SPos == 246721 && labelK0SNeg == 246722) || (labelK0SPos == 249672 && labelK0SNeg == 249673) || (labelK0SPos == 250589 && labelK0SNeg == 250590) || (labelK0SPos == 251882 && labelK0SNeg == 251883) || (labelK0SPos == 253034 && labelK0SNeg == 253035) || (labelK0SPos == 254543 && labelK0SNeg == 254544) || (labelK0SPos == 254539 && labelK0SNeg == 254540) || (labelK0SPos == 255941 && labelK0SNeg == 255942) || (labelK0SPos == 256808 && labelK0SNeg == 256809) || (labelK0SPos == 258807 && labelK0SNeg == 258808) || (labelK0SPos == 261612 && labelK0SNeg == 261613) || (labelK0SPos == 262887 && labelK0SNeg == 262888) || (labelK0SPos == 264473 && labelK0SNeg == 264474) || (labelK0SPos == 264471 && labelK0SNeg == 264472) || (labelK0SPos == 268912 && labelK0SNeg == 268913) || (labelK0SPos == 270023 && labelK0SNeg == 270024) || (labelK0SPos == 271998 && labelK0SNeg == 271999) || (labelK0SPos == 274081 && labelK0SNeg == 274082) || (labelK0SPos == 276125 && labelK0SNeg == 276126) || (labelK0SPos == 276952 && labelK0SNeg == 276953) || (labelK0SPos == 278530 && labelK0SNeg == 278531) || (labelK0SPos == 279613 && labelK0SNeg == 279614) || (labelK0SPos == 280446 && labelK0SNeg == 280447) || (labelK0SPos == 282152 && labelK0SNeg == 282153) || (labelK0SPos == 282034 && labelK0SNeg == 282035) || (labelK0SPos == 283408 && labelK0SNeg == 283409) || (labelK0SPos == 284753 && labelK0SNeg == 284754) || (labelK0SPos == 286615 && labelK0SNeg == 286616) || (labelK0SPos == 288037 && labelK0SNeg == 288038) || (labelK0SPos == 289736 && labelK0SNeg == 289737) || (labelK0SPos == 291009 && labelK0SNeg == 291010) || (labelK0SPos == 292336 && labelK0SNeg == 292337) || (labelK0SPos == 293565 && labelK0SNeg == 293566) || (labelK0SPos == 296529 && labelK0SNeg == 296530) || (labelK0SPos == 300564 && labelK0SNeg == 300565); + assert(listLabelsK0SPos.size() == listLabelsK0SPos.size()); + for (auto i = 0; i < listLabelsK0SPos.size(); ++i) { + if (labelK0SPos == listLabelsK0SPos[i] && labelK0SNeg == listLabelsK0SNeg[i]) { + return true; + } + } + return false; } //------------------------------- -inline bool isProtonFromLcFunc(int labelProton) +inline bool isProtonFromLcFunc(int labelProton, std::vector listLabelsProton) { - return (labelProton == 717) || (labelProton == 2810) || (labelProton == 4393) || (labelProton == 5442) || (labelProton == 6769) || (labelProton == 7793) || (labelProton == 9002) || (labelProton == 9789) || (labelProton == 10385) || (labelProton == 12601) || (labelProton == 13819) || (labelProton == 17443) || (labelProton == 19936) || (labelProton == 21715) || (labelProton == 23285) || (labelProton == 23999) || (labelProton == 25676) || (labelProton == 28660) || (labelProton == 30684) || (labelProton == 32049) || (labelProton == 34846) || (labelProton == 37042) || (labelProton == 39278) || (labelProton == 40278) || (labelProton == 41567) || (labelProton == 43696) || (labelProton == 44819) || (labelProton == 45232) || (labelProton == 46578) || (labelProton == 47831) || (labelProton == 48981) || (labelProton == 53527) || (labelProton == 57152) || (labelProton == 58155) || (labelProton == 59296) || (labelProton == 61010) || (labelProton == 61932) || (labelProton == 63577) || (labelProton == 65683) || (labelProton == 68047) || (labelProton == 69657) || (labelProton == 70721) || (labelProton == 73141) || (labelProton == 75320) || (labelProton == 76581) || (labelProton == 78165) || (labelProton == 79504) || (labelProton == 80662) || (labelProton == 81552) || (labelProton == 84208) || (labelProton == 86342) || (labelProton == 86829) || (labelProton == 87347) || (labelProton == 89922) || (labelProton == 95032) || (labelProton == 96087) || (labelProton == 97410) || (labelProton == 100154) || (labelProton == 101743) || (labelProton == 103368) || (labelProton == 104635) || (labelProton == 106089) || (labelProton == 108676) || (labelProton == 110308) || (labelProton == 111335) || (labelProton == 111342) || (labelProton == 112606) || (labelProton == 113469) || (labelProton == 114529) || (labelProton == 114533) || (labelProton == 116388) || (labelProton == 117754) || (labelProton == 118765) || (labelProton == 118784) || (labelProton == 119733) || (labelProton == 120691) || (labelProton == 121773) || (labelProton == 123970) || (labelProton == 125316) || (labelProton == 127253) || (labelProton == 129008) || (labelProton == 129883) || (labelProton == 131408) || (labelProton == 132349) || (labelProton == 132395) || (labelProton == 133263) || (labelProton == 134063) || (labelProton == 135417) || (labelProton == 136194) || (labelProton == 137441) || (labelProton == 138569) || (labelProton == 139167) || (labelProton == 141741) || (labelProton == 143422) || (labelProton == 144322) || (labelProton == 145013) || (labelProton == 145695) || (labelProton == 147134) || (labelProton == 148503) || (labelProton == 149283) || (labelProton == 149728) || (labelProton == 153214) || (labelProton == 154481) || (labelProton == 155193) || (labelProton == 158187) || (labelProton == 159039) || (labelProton == 160009) || (labelProton == 161126) || (labelProton == 162191) || (labelProton == 163774) || (labelProton == 165792) || (labelProton == 166934) || (labelProton == 168768) || (labelProton == 174013) || (labelProton == 174017) || (labelProton == 175467) || (labelProton == 177005) || (labelProton == 177258) || (labelProton == 178380) || (labelProton == 179566) || (labelProton == 179577) || (labelProton == 181145) || (labelProton == 187316) || (labelProton == 188512) || (labelProton == 189094) || (labelProton == 191582) || (labelProton == 193018) || (labelProton == 194159) || (labelProton == 195821) || (labelProton == 197459) || (labelProton == 201840) || (labelProton == 202646) || (labelProton == 203119) || (labelProton == 203763) || (labelProton == 205553) || (labelProton == 207745) || (labelProton == 208851) || (labelProton == 211636) || (labelProton == 216231) || (labelProton == 217125) || (labelProton == 217516) || (labelProton == 218522) || (labelProton == 219477) || (labelProton == 219960) || (labelProton == 223246) || (labelProton == 224677) || (labelProton == 224702) || (labelProton == 225438) || (labelProton == 227194) || (labelProton == 230507) || (labelProton == 231304) || (labelProton == 232070) || (labelProton == 232772) || (labelProton == 234765) || (labelProton == 235877) || (labelProton == 236893) || (labelProton == 237989) || (labelProton == 239575) || (labelProton == 241469) || (labelProton == 243404) || (labelProton == 244872) || (labelProton == 245511) || (labelProton == 246688) || (labelProton == 249625) || (labelProton == 250580) || (labelProton == 251879) || (labelProton == 253031) || (labelProton == 254465) || (labelProton == 254511) || (labelProton == 255917) || (labelProton == 256782) || (labelProton == 258734) || (labelProton == 261436) || (labelProton == 262878) || (labelProton == 264465) || (labelProton == 264467) || (labelProton == 268907) || (labelProton == 269974) || (labelProton == 271856) || (labelProton == 274044) || (labelProton == 276071) || (labelProton == 276915) || (labelProton == 278461) || (labelProton == 279559) || (labelProton == 280441) || (labelProton == 281783) || (labelProton == 281976) || (labelProton == 283405) || (labelProton == 284722) || (labelProton == 286324) || (labelProton == 287929) || (labelProton == 289681) || (labelProton == 291005) || (labelProton == 292324) || (labelProton == 293478) || (labelProton == 296484) || (labelProton == 300536); + for (auto i = 0; i < listLabelsProton.size(); ++i) { + if (labelProton == listLabelsProton[i]) { + return true; + } + } + return false; + } //--------------------------------- -inline bool isLcK0SpFunc(int labelProton, int labelK0SPos, int labelK0SNeg) +inline bool isLcK0SpFunc(int labelProton, int labelK0SPos, int labelK0SNeg, std::vector listLabelsProton, std::vector listLabelsK0SPos, std::vector listLabelsK0SNeg) { - return (labelProton == 717 && labelK0SPos == 729 && labelK0SNeg == 730) || (labelProton == 2810 && labelK0SPos == 2866 && labelK0SNeg == 2867) || (labelProton == 4393 && labelK0SPos == 4754 && labelK0SNeg == 4755) || (labelProton == 5442 && labelK0SPos == 5457 && labelK0SNeg == 5458) || (labelProton == 6769 && labelK0SPos == 6891 && labelK0SNeg == 6892) || (labelProton == 7793 && labelK0SPos == 7824 && labelK0SNeg == 7825) || (labelProton == 9002 && labelK0SPos == 9243 && labelK0SNeg == 9244) || (labelProton == 9789 && labelK0SPos == 9810 && labelK0SNeg == 9811) || (labelProton == 10385 && labelK0SPos == 10388 && labelK0SNeg == 10389) || (labelProton == 12601 && labelK0SPos == 12665 && labelK0SNeg == 12666) || (labelProton == 13819 && labelK0SPos == 13830 && labelK0SNeg == 13831) || (labelProton == 17443 && labelK0SPos == 17460 && labelK0SNeg == 17461) || (labelProton == 19936 && labelK0SPos == 19955 && labelK0SNeg == 19956) || (labelProton == 21715 && labelK0SPos == 21786 && labelK0SNeg == 21787) || (labelProton == 23285 && labelK0SPos == 23319 && labelK0SNeg == 23320) || (labelProton == 23999 && labelK0SPos == 24010 && labelK0SNeg == 24011) || (labelProton == 25676 && labelK0SPos == 26234 && labelK0SNeg == 26235) || (labelProton == 28660 && labelK0SPos == 28713 && labelK0SNeg == 28714) || (labelProton == 30684 && labelK0SPos == 30699 && labelK0SNeg == 30700) || (labelProton == 32049 && labelK0SPos == 32056 && labelK0SNeg == 32057) || (labelProton == 34846 && labelK0SPos == 34866 && labelK0SNeg == 34867) || (labelProton == 37042 && labelK0SPos == 37075 && labelK0SNeg == 37076) || (labelProton == 39278 && labelK0SPos == 39314 && labelK0SNeg == 39315) || (labelProton == 40278 && labelK0SPos == 40287 && labelK0SNeg == 40288) || (labelProton == 41567 && labelK0SPos == 41617 && labelK0SNeg == 41618) || (labelProton == 43696 && labelK0SPos == 43790 && labelK0SNeg == 43791) || (labelProton == 44819 && labelK0SPos == 44868 && labelK0SNeg == 44869) || (labelProton == 45232 && labelK0SPos == 45252 && labelK0SNeg == 45253) || (labelProton == 46578 && labelK0SPos == 46587 && labelK0SNeg == 46588) || (labelProton == 47831 && labelK0SPos == 47866 && labelK0SNeg == 47867) || (labelProton == 48981 && labelK0SPos == 48992 && labelK0SNeg == 48993) || (labelProton == 53527 && labelK0SPos == 53534 && labelK0SNeg == 53535) || (labelProton == 57152 && labelK0SPos == 57211 && labelK0SNeg == 57212) || (labelProton == 58155 && labelK0SPos == 58160 && labelK0SNeg == 58161) || (labelProton == 59296 && labelK0SPos == 59355 && labelK0SNeg == 59356) || (labelProton == 61010 && labelK0SPos == 61019 && labelK0SNeg == 61020) || (labelProton == 61932 && labelK0SPos == 62003 && labelK0SNeg == 62004) || (labelProton == 63577 && labelK0SPos == 63580 && labelK0SNeg == 63581) || (labelProton == 65683 && labelK0SPos == 65691 && labelK0SNeg == 65692) || (labelProton == 68047 && labelK0SPos == 68164 && labelK0SNeg == 68165) || (labelProton == 69657 && labelK0SPos == 69721 && labelK0SNeg == 69722) || (labelProton == 70721 && labelK0SPos == 70852 && labelK0SNeg == 70853) || (labelProton == 73141 && labelK0SPos == 73167 && labelK0SNeg == 73168) || (labelProton == 75320 && labelK0SPos == 75331 && labelK0SNeg == 75332) || (labelProton == 76581 && labelK0SPos == 76641 && labelK0SNeg == 76642) || (labelProton == 78165 && labelK0SPos == 78188 && labelK0SNeg == 78189) || (labelProton == 79504 && labelK0SPos == 79595 && labelK0SNeg == 79596) || (labelProton == 80662 && labelK0SPos == 80678 && labelK0SNeg == 80679) || (labelProton == 81552 && labelK0SPos == 81613 && labelK0SNeg == 81614) || (labelProton == 84208 && labelK0SPos == 84311 && labelK0SNeg == 84312) || (labelProton == 86342 && labelK0SPos == 86376 && labelK0SNeg == 86377) || (labelProton == 86829 && labelK0SPos == 86840 && labelK0SNeg == 86841) || (labelProton == 87347 && labelK0SPos == 87374 && labelK0SNeg == 87375) || (labelProton == 89922 && labelK0SPos == 89998 && labelK0SNeg == 89999) || (labelProton == 95032 && labelK0SPos == 95078 && labelK0SNeg == 95079) || (labelProton == 96087 && labelK0SPos == 96094 && labelK0SNeg == 96095) || (labelProton == 97410 && labelK0SPos == 97425 && labelK0SNeg == 97426) || (labelProton == 100154 && labelK0SPos == 100157 && labelK0SNeg == 100158) || (labelProton == 101743 && labelK0SPos == 101788 && labelK0SNeg == 101789) || (labelProton == 103368 && labelK0SPos == 103468 && labelK0SNeg == 103469) || (labelProton == 104635 && labelK0SPos == 104646 && labelK0SNeg == 104647) || (labelProton == 106089 && labelK0SPos == 106155 && labelK0SNeg == 106156) || (labelProton == 108676 && labelK0SPos == 108696 && labelK0SNeg == 108697) || (labelProton == 110308 && labelK0SPos == 110388 && labelK0SNeg == 110389) || (labelProton == 111335 && labelK0SPos == 111355 && labelK0SNeg == 111356) || (labelProton == 111342 && labelK0SPos == 111348 && labelK0SNeg == 111349) || (labelProton == 112606 && labelK0SPos == 112712 && labelK0SNeg == 112713) || (labelProton == 113469 && labelK0SPos == 113578 && labelK0SNeg == 113579) || (labelProton == 114529 && labelK0SPos == 114556 && labelK0SNeg == 114557) || (labelProton == 114533 && labelK0SPos == 114550 && labelK0SNeg == 114551) || (labelProton == 116388 && labelK0SPos == 116432 && labelK0SNeg == 116433) || (labelProton == 117754 && labelK0SPos == 117766 && labelK0SNeg == 117767) || (labelProton == 118765 && labelK0SPos == 118796 && labelK0SNeg == 118797) || (labelProton == 118784 && labelK0SPos == 118790 && labelK0SNeg == 118791) || (labelProton == 119733 && labelK0SPos == 119766 && labelK0SNeg == 119767) || (labelProton == 120691 && labelK0SPos == 120728 && labelK0SNeg == 120729) || (labelProton == 121773 && labelK0SPos == 121872 && labelK0SNeg == 121873) || (labelProton == 123970 && labelK0SPos == 124027 && labelK0SNeg == 124028) || (labelProton == 125316 && labelK0SPos == 125407 && labelK0SNeg == 125408) || (labelProton == 127253 && labelK0SPos == 127284 && labelK0SNeg == 127285) || (labelProton == 129008 && labelK0SPos == 129068 && labelK0SNeg == 129069) || (labelProton == 129883 && labelK0SPos == 129924 && labelK0SNeg == 129925) || (labelProton == 131408 && labelK0SPos == 131453 && labelK0SNeg == 131454) || (labelProton == 132349 && labelK0SPos == 132456 && labelK0SNeg == 132457) || (labelProton == 132395 && labelK0SPos == 132436 && labelK0SNeg == 132437) || (labelProton == 133263 && labelK0SPos == 133266 && labelK0SNeg == 133267) || (labelProton == 134063 && labelK0SPos == 134084 && labelK0SNeg == 134085) || (labelProton == 135417 && labelK0SPos == 135470 && labelK0SNeg == 135471) || (labelProton == 136194 && labelK0SPos == 136207 && labelK0SNeg == 136208) || (labelProton == 137441 && labelK0SPos == 137446 && labelK0SNeg == 137447) || (labelProton == 138569 && labelK0SPos == 138616 && labelK0SNeg == 138617) || (labelProton == 139167 && labelK0SPos == 139217 && labelK0SNeg == 139218) || (labelProton == 141741 && labelK0SPos == 141832 && labelK0SNeg == 141833) || (labelProton == 143422 && labelK0SPos == 143513 && labelK0SNeg == 143514) || (labelProton == 144322 && labelK0SPos == 144416 && labelK0SNeg == 144417) || (labelProton == 145013 && labelK0SPos == 145018 && labelK0SNeg == 145019) || (labelProton == 145695 && labelK0SPos == 145702 && labelK0SNeg == 145703) || (labelProton == 147134 && labelK0SPos == 147139 && labelK0SNeg == 147140) || (labelProton == 148503 && labelK0SPos == 148508 && labelK0SNeg == 148509) || (labelProton == 149283 && labelK0SPos == 149290 && labelK0SNeg == 149291) || (labelProton == 149728 && labelK0SPos == 149737 && labelK0SNeg == 149738) || (labelProton == 153214 && labelK0SPos == 153271 && labelK0SNeg == 153272) || (labelProton == 154481 && labelK0SPos == 154515 && labelK0SNeg == 154516) || (labelProton == 155193 && labelK0SPos == 155206 && labelK0SNeg == 155207) || (labelProton == 158187 && labelK0SPos == 158200 && labelK0SNeg == 158201) || (labelProton == 159039 && labelK0SPos == 159059 && labelK0SNeg == 159060) || (labelProton == 160009 && labelK0SPos == 160082 && labelK0SNeg == 160083) || (labelProton == 161126 && labelK0SPos == 161140 && labelK0SNeg == 161141) || (labelProton == 162191 && labelK0SPos == 162208 && labelK0SNeg == 162209) || (labelProton == 163774 && labelK0SPos == 163777 && labelK0SNeg == 163778) || (labelProton == 165792 && labelK0SPos == 165874 && labelK0SNeg == 165875) || (labelProton == 166934 && labelK0SPos == 167001 && labelK0SNeg == 167002) || (labelProton == 168768 && labelK0SPos == 168852 && labelK0SNeg == 168853) || (labelProton == 174013 && labelK0SPos == 174033 && labelK0SNeg == 174034) || (labelProton == 174017 && labelK0SPos == 174027 && labelK0SNeg == 174028) || (labelProton == 175467 && labelK0SPos == 175501 && labelK0SNeg == 175502) || (labelProton == 177005 && labelK0SPos == 177396 && labelK0SNeg == 177397) || (labelProton == 177258 && labelK0SPos == 177265 && labelK0SNeg == 177266) || (labelProton == 178380 && labelK0SPos == 178383 && labelK0SNeg == 178384) || (labelProton == 179566 && labelK0SPos == 179595 && labelK0SNeg == 179596) || (labelProton == 179577 && labelK0SPos == 179580 && labelK0SNeg == 179581) || (labelProton == 181145 && labelK0SPos == 181168 && labelK0SNeg == 181169) || (labelProton == 187316 && labelK0SPos == 187326 && labelK0SNeg == 187327) || (labelProton == 188512 && labelK0SPos == 188608 && labelK0SNeg == 188609) || (labelProton == 189094 && labelK0SPos == 189128 && labelK0SNeg == 189129) || (labelProton == 191582 && labelK0SPos == 191591 && labelK0SNeg == 191592) || (labelProton == 193018 && labelK0SPos == 193025 && labelK0SNeg == 193026) || (labelProton == 194159 && labelK0SPos == 194170 && labelK0SNeg == 194171) || (labelProton == 195821 && labelK0SPos == 195824 && labelK0SNeg == 195825) || (labelProton == 197459 && labelK0SPos == 197472 && labelK0SNeg == 197473) || (labelProton == 201840 && labelK0SPos == 201905 && labelK0SNeg == 201906) || (labelProton == 202646 && labelK0SPos == 202664 && labelK0SNeg == 202665) || (labelProton == 203119 && labelK0SPos == 203163 && labelK0SNeg == 203164) || (labelProton == 203763 && labelK0SPos == 203835 && labelK0SNeg == 203836) || (labelProton == 205553 && labelK0SPos == 205556 && labelK0SNeg == 205557) || (labelProton == 207745 && labelK0SPos == 207838 && labelK0SNeg == 207839) || (labelProton == 208851 && labelK0SPos == 208866 && labelK0SNeg == 208867) || (labelProton == 211636 && labelK0SPos == 211654 && labelK0SNeg == 211655) || (labelProton == 216231 && labelK0SPos == 216312 && labelK0SNeg == 216313) || (labelProton == 217125 && labelK0SPos == 217132 && labelK0SNeg == 217133) || (labelProton == 217516 && labelK0SPos == 217554 && labelK0SNeg == 217555) || (labelProton == 218522 && labelK0SPos == 218616 && labelK0SNeg == 218617) || (labelProton == 219477 && labelK0SPos == 219503 && labelK0SNeg == 219504) || (labelProton == 219960 && labelK0SPos == 219996 && labelK0SNeg == 219997) || (labelProton == 223246 && labelK0SPos == 223354 && labelK0SNeg == 223355) || (labelProton == 224677 && labelK0SPos == 224713 && labelK0SNeg == 224714) || (labelProton == 224702 && labelK0SPos == 224707 && labelK0SNeg == 224708) || (labelProton == 225438 && labelK0SPos == 225482 && labelK0SNeg == 225483) || (labelProton == 227194 && labelK0SPos == 227207 && labelK0SNeg == 227208) || (labelProton == 230507 && labelK0SPos == 230562 && labelK0SNeg == 230563) || (labelProton == 231304 && labelK0SPos == 231324 && labelK0SNeg == 231325) || (labelProton == 232070 && labelK0SPos == 232083 && labelK0SNeg == 232084) || (labelProton == 232772 && labelK0SPos == 232809 && labelK0SNeg == 232810) || (labelProton == 234765 && labelK0SPos == 234774 && labelK0SNeg == 234775) || (labelProton == 235877 && labelK0SPos == 235892 && labelK0SNeg == 235893) || (labelProton == 236893 && labelK0SPos == 236900 && labelK0SNeg == 236901) || (labelProton == 237989 && labelK0SPos == 238038 && labelK0SNeg == 238039) || (labelProton == 239575 && labelK0SPos == 239629 && labelK0SNeg == 239630) || (labelProton == 241469 && labelK0SPos == 241517 && labelK0SNeg == 241518) || (labelProton == 243404 && labelK0SPos == 243460 && labelK0SNeg == 243461) || (labelProton == 244872 && labelK0SPos == 244881 && labelK0SNeg == 244882) || (labelProton == 245511 && labelK0SPos == 245553 && labelK0SNeg == 245554) || (labelProton == 246688 && labelK0SPos == 246721 && labelK0SNeg == 246722) || (labelProton == 249625 && labelK0SPos == 249672 && labelK0SNeg == 249673) || (labelProton == 250580 && labelK0SPos == 250589 && labelK0SNeg == 250590) || (labelProton == 251879 && labelK0SPos == 251882 && labelK0SNeg == 251883) || (labelProton == 253031 && labelK0SPos == 253034 && labelK0SNeg == 253035) || (labelProton == 254465 && labelK0SPos == 254543 && labelK0SNeg == 254544) || (labelProton == 254511 && labelK0SPos == 254539 && labelK0SNeg == 254540) || (labelProton == 255917 && labelK0SPos == 255941 && labelK0SNeg == 255942) || (labelProton == 256782 && labelK0SPos == 256808 && labelK0SNeg == 256809) || (labelProton == 258734 && labelK0SPos == 258807 && labelK0SNeg == 258808) || (labelProton == 261436 && labelK0SPos == 261612 && labelK0SNeg == 261613) || (labelProton == 262878 && labelK0SPos == 262887 && labelK0SNeg == 262888) || (labelProton == 264465 && labelK0SPos == 264473 && labelK0SNeg == 264474) || (labelProton == 264467 && labelK0SPos == 264471 && labelK0SNeg == 264472) || (labelProton == 268907 && labelK0SPos == 268912 && labelK0SNeg == 268913) || (labelProton == 269974 && labelK0SPos == 270023 && labelK0SNeg == 270024) || (labelProton == 271856 && labelK0SPos == 271998 && labelK0SNeg == 271999) || (labelProton == 274044 && labelK0SPos == 274081 && labelK0SNeg == 274082) || (labelProton == 276071 && labelK0SPos == 276125 && labelK0SNeg == 276126) || (labelProton == 276915 && labelK0SPos == 276952 && labelK0SNeg == 276953) || (labelProton == 278461 && labelK0SPos == 278530 && labelK0SNeg == 278531) || (labelProton == 279559 && labelK0SPos == 279613 && labelK0SNeg == 279614) || (labelProton == 280441 && labelK0SPos == 280446 && labelK0SNeg == 280447) || (labelProton == 281783 && labelK0SPos == 282152 && labelK0SNeg == 282153) || (labelProton == 281976 && labelK0SPos == 282034 && labelK0SNeg == 282035) || (labelProton == 283405 && labelK0SPos == 283408 && labelK0SNeg == 283409) || (labelProton == 284722 && labelK0SPos == 284753 && labelK0SNeg == 284754) || (labelProton == 286324 && labelK0SPos == 286615 && labelK0SNeg == 286616) || (labelProton == 287929 && labelK0SPos == 288037 && labelK0SNeg == 288038) || (labelProton == 289681 && labelK0SPos == 289736 && labelK0SNeg == 289737) || (labelProton == 291005 && labelK0SPos == 291009 && labelK0SNeg == 291010) || (labelProton == 292324 && labelK0SPos == 292336 && labelK0SNeg == 292337) || (labelProton == 293478 && labelK0SPos == 293565 && labelK0SNeg == 293566) || (labelProton == 296484 && labelK0SPos == 296529 && labelK0SNeg == 296530) || (labelProton == 300536 && labelK0SPos == 300564 && labelK0SNeg == 300565); + assert(listLabelsK0SPos.size() == listLabelsK0SPos.size()); + assert(listLabelsProton.size() == listLabelsK0SPos.size()); + for (auto i = 0; i < listLabelsK0SPos.size(); ++i) { + if (labelProton == listLabelsProton[i] && labelK0SPos == listLabelsK0SPos[i] && labelK0SNeg == listLabelsK0SNeg[i]) { + return true; + } + } + return false; + } From eae737e531480a35a4df0299f3e792006facce90 Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Fri, 9 Apr 2021 00:10:05 +0200 Subject: [PATCH 11/14] Anton's comments clang-format --- .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 44 +++++++------- .../Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx | 6 +- .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 17 +++--- Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx | 6 +- .../AnalysisTasksUtils/UtilsDebugLcK0Sp.h | 57 ++++++++++++++----- 5 files changed, 80 insertions(+), 50 deletions(-) diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index e05b5a73cf7f6..cd94f5c7c5b18 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -32,6 +32,19 @@ void customize(std::vector& workflowOptions) #include "Framework/runDataProcessing.h" +//#define MY_DEBUG + +#ifdef MY_DEBUG +using MyTracks = aod::BigTracksMC; +#define MY_DEBUG_MSG(condition, cmd) \ + if (condition) { \ + cmd; \ + } +#else +using MyTracks = aod::BigTracks; +#define MY_DEBUG_MSG(condition, cmd) +#endif + /// Reconstruction of heavy-flavour cascade decay candidates struct HFCandidateCreatorCascade { @@ -44,12 +57,14 @@ struct HFCandidateCreatorCascade { Configurable d_minParamChange{"d_minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; Configurable d_minRelChi2Change{"d_minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; Configurable b_doValPlots{"b_doValPlots", true, "do validation plots"}; + + // for debugging #ifdef MY_DEBUG - Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelProton{"v_labelProton", {729, 2810, 4393}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; + Configurable> v_labelProton{"v_labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; #endif - + OutputObj hmass2{TH1F("hmass2", "2-prong candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", 500, 0., 5.)}; OutputObj hCovPVXX{TH1F("hCovPVXX", "2-prong candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)}; OutputObj hCovSVXX{TH1F("hCovSVXX", "2-prong candidates;XX element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)}; @@ -60,19 +75,6 @@ struct HFCandidateCreatorCascade { double massLc = RecoDecay::getMassPDG(4122); double mass2K0sP{0.}; - //#define MY_DEBUG - -#ifdef MY_DEBUG - using MyTracks = aod::BigTracksMC; -#define MY_DEBUG_MSG(condition, cmd) \ - if (condition) { \ - cmd; \ - } -#else - using MyTracks = aod::BigTracks; -#define MY_DEBUG_MSG(condition, cmd) -#endif - void process(aod::Collisions const& collisions, aod::HfTrackIndexCasc const& rowsTrackIndexCasc, MyTracks const& tracks, @@ -208,9 +210,9 @@ struct HFCandidateCreatorCascadeMC { Produces rowMCMatchGen; #ifdef MY_DEBUG - Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelProton{"v_labelProton", {729, 2810, 4393}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; + Configurable> v_labelProton{"v_labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; #endif void process(aod::HfCandCascade const& candidates, @@ -228,7 +230,7 @@ struct HFCandidateCreatorCascadeMC { auto arrayDaughtersLc = array{candidate.index0_as(), candidate.posTrack_as(), candidate.negTrack_as()}; // First we check the K0s - printf("\n"); + LOG(DEBUG) << "\n"; LOG(DEBUG) << "Checking MC for candidate!"; LOG(DEBUG) << "Looking for K0s"; auto labelPos = candidate.posTrack_as().mcParticleId(); diff --git a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx index 191f407eb88d2..2edcb70b5deca 100644 --- a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx +++ b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx @@ -72,9 +72,9 @@ struct HFLcK0sPCandidateSelector { // for debugging #ifdef MY_DEBUG - Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelProton{"v_labelProton", {729, 2810, 4393}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; + Configurable> v_labelProton{"v_labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; #endif /// Gets corresponding pT bin from cut file array diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index a2027c5871f85..434e6cba41ff9 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -91,12 +91,14 @@ struct SelectTracks { Configurable d_dcaToPrimXYMinBach{"d_dcaToPrimXYMinBach", 0., "min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; // for PbPb 2018, the cut should be 0.0025 Configurable d_dcaToPrimXYMaxBach{"d_dcaToPrimXYMaxBach", 1.0, "max. DCAXY to prim. vtx. for bachelor in cascade candidate"}; Configurable d_etaMaxBach{"d_etaMaxBach", 0.8, "max. pseudorapidity for bachelor in cascade candidate"}; + + // for debugging #ifdef MY_DEBUG - Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelProton{"v_labelProton", {729, 2810, 4393}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; + Configurable> v_labelProton{"v_labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; #endif - + HistogramRegistry registry{ "registry", {{"hpt_nocuts", "all tracks;#it{p}_{T}^{track} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, @@ -1053,9 +1055,9 @@ struct HFTrackIndexSkimsCreatorCascades { // for debugging #ifdef MY_DEBUG - Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelProton{"v_labelProton", {729, 2810, 4393}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; + Configurable> v_labelProton{"v_labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; #endif // histograms @@ -1276,7 +1278,6 @@ struct HFTrackIndexTestMCCasc { for (const auto& v0 : V0s) { // selections on the V0 daughters auto arrayDaughtersV0 = array{v0.posTrack_as(), v0.negTrack_as()}; - LOG(INFO) << "Looking for K0s "; RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, 310, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s } return; diff --git a/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx b/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx index bf24cf096c13a..c71af8da32fda 100644 --- a/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx +++ b/Analysis/Tasks/PWGLF/lambdakzerobuilder.cxx @@ -76,7 +76,7 @@ DECLARE_SOA_TABLE(V0GoodIndices, "AOD", "V0GOODINDICES", o2::soa::Index<>, using FullTracksExt = soa::Join; using FullTracksExtMC = soa::Join; -#define MY_DEBUG +//#define MY_DEBUG #ifdef MY_DEBUG using MyTracks = FullTracksExtMC; #define MY_DEBUG_MSG(condition, cmd) \ @@ -100,9 +100,9 @@ struct lambdakzeroprefilterpairs { // for debugging #ifdef MY_DEBUG Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S positive daughters, for debug"}; + Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755}, "labels of K0S negative daughters, for debug"}; #endif - + HistogramRegistry registry{ "registry", { diff --git a/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h b/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h index 804df528f1c0e..1f480009456ef 100644 --- a/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h +++ b/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h @@ -19,16 +19,27 @@ /// #include +#include inline bool isK0SfromLcFunc(int labelK0SPos, int labelK0SNeg, std::vector listLabelsK0SPos, std::vector listLabelsK0SNeg) { - assert(listLabelsK0SPos.size() == listLabelsK0SPos.size()); - for (auto i = 0; i < listLabelsK0SPos.size(); ++i) { - if (labelK0SPos == listLabelsK0SPos[i] && labelK0SNeg == listLabelsK0SNeg[i]) { - return true; - } + auto nPositiveDau = listLabelsK0SPos.size(); + auto nNegativeDau = listLabelsK0SNeg.size(); + + // checking sizes of vectors: they should be identical + if (nPositiveDau != nNegativeDau) { + LOG(ERROR) << "Number of elements in vector of positive daughters of K0S different from the number of elements in the vector for the negative ones: " << nPositiveDau << " : " << nNegativeDau; + throw std::runtime_error("sizes of configurables for debug do not match"); } + + // checking if we find the candidate + bool matchesK0Spositive = std::any_of(listLabelsK0SPos.begin(), listLabelsK0SPos.end(), [&labelK0SPos](const int& label) { return label == labelK0SPos; }); + bool matchesK0Snegative = std::any_of(listLabelsK0SNeg.begin(), listLabelsK0SNeg.end(), [&labelK0SNeg](const int& label) { return label == labelK0SNeg; }); + if (matchesK0Spositive && matchesK0Snegative) { + return true; + } + return false; } @@ -36,14 +47,12 @@ inline bool isK0SfromLcFunc(int labelK0SPos, int labelK0SNeg, std::vector l inline bool isProtonFromLcFunc(int labelProton, std::vector listLabelsProton) { - - for (auto i = 0; i < listLabelsProton.size(); ++i) { - if (labelProton == listLabelsProton[i]) { - return true; - } + // checking if we find the candidate` + bool matchesProton = std::any_of(listLabelsProton.begin(), listLabelsProton.end(), [&labelProton](const int& label) { return label == labelProton; }); + if (matchesProton) { + return true; } return false; - } //--------------------------------- @@ -51,13 +60,31 @@ inline bool isProtonFromLcFunc(int labelProton, std::vector listLabelsProto inline bool isLcK0SpFunc(int labelProton, int labelK0SPos, int labelK0SNeg, std::vector listLabelsProton, std::vector listLabelsK0SPos, std::vector listLabelsK0SNeg) { - assert(listLabelsK0SPos.size() == listLabelsK0SPos.size()); - assert(listLabelsProton.size() == listLabelsK0SPos.size()); - for (auto i = 0; i < listLabelsK0SPos.size(); ++i) { + auto nPositiveDau = listLabelsK0SPos.size(); + auto nNegativeDau = listLabelsK0SNeg.size(); + auto nProtons = listLabelsProton.size(); + + // checking sizes of vectors: they should be identical + if (nPositiveDau != nNegativeDau || nPositiveDau != nProtons) { + LOG(ERROR) << "Number of elements in vector of positive daughters of K0S, in vector of negative daughters of K0S, and in vector of protons differ: " << nPositiveDau << " : " << nNegativeDau << " : " << nProtons; + throw std::runtime_error("sizes of configurables for debug do not match"); + } + + // checking if we find the candidate + bool matchesK0Spositive = std::any_of(listLabelsK0SPos.begin(), listLabelsK0SPos.end(), [&labelK0SPos](const int& label) { return label == labelK0SPos; }); + bool matchesK0Snegative = std::any_of(listLabelsK0SNeg.begin(), listLabelsK0SNeg.end(), [&labelK0SNeg](const int& label) { return label == labelK0SNeg; }); + bool matchesProton = std::any_of(listLabelsProton.begin(), listLabelsProton.end(), [&labelProton](const int& label) { return label == labelProton; }); + if (matchesK0Spositive && matchesK0Snegative && matchesProton) { + return true; + } + + /* + auto nElements = nPositiveDau; + for (auto i = 0; i < nPositiveDau; ++i) { if (labelProton == listLabelsProton[i] && labelK0SPos == listLabelsK0SPos[i] && labelK0SNeg == listLabelsK0SNeg[i]) { return true; } } + */ return false; - } From 2a6759e0f3e20f6cac8f74807dac825f4f2579e7 Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Fri, 9 Apr 2021 23:47:25 +0200 Subject: [PATCH 12/14] Implementation of comments by Anton and Vit misc fixes clang-format --- .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 23 +++++----- .../Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx | 4 +- .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 43 +++++-------------- Analysis/Tasks/PWGHF/taskLcK0sP.cxx | 8 ++-- 4 files changed, 31 insertions(+), 47 deletions(-) diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index cd94f5c7c5b18..46bf9ec8eab85 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -19,10 +19,12 @@ #include "ReconstructionDataFormats/DCA.h" #include "ReconstructionDataFormats/V0.h" #include "AnalysisTasksUtils/UtilsDebugLcK0Sp.h" +#include "AnalysisCore/HFSelectorCuts.h" using namespace o2; using namespace o2::framework; using namespace o2::aod::hf_cand_prong2; +using namespace o2::analysis; void customize(std::vector& workflowOptions) { @@ -72,7 +74,7 @@ struct HFCandidateCreatorCascade { double massP = RecoDecay::getMassPDG(kProton); double massK0s = RecoDecay::getMassPDG(kK0Short); double massPi = RecoDecay::getMassPDG(kPiPlus); - double massLc = RecoDecay::getMassPDG(4122); + double massLc = RecoDecay::getMassPDG(pdg::code::kLambdaCPlus); double mass2K0sP{0.}; void process(aod::Collisions const& collisions, @@ -119,7 +121,7 @@ struct HFCandidateCreatorCascade { const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; // we build the neutral track to then build the cascade - auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track (indices for v0 daughters set to 0 for now) + auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, {0, 0, 0, 0, 0, 0}, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track (indices for v0 daughters set to 0 for now) auto collision = bach.collision(); @@ -166,7 +168,8 @@ struct HFCandidateCreatorCascade { // fill candidate table rows MY_DEBUG_MSG(isLc, LOG(INFO) << "IT IS A Lc! Filling for Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg); - rowCandidateBase(collision.posX(), collision.posY(), collision.posZ(), + rowCandidateBase(collision.globalIndex(), + collision.posX(), collision.posY(), collision.posZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], errorDecayLength, errorDecayLengthXY, chi2PCA, @@ -244,14 +247,14 @@ struct HFCandidateCreatorCascadeMC { MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "correct K0S in the Lc daughters: posTrack --> " << labelPos << ", negTrack --> " << labelNeg); //if (isLc) { - RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, 310, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s + RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, kK0Short, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s if (sign != 0) { // we have already positively checked the K0s // then we check the Lc MY_DEBUG_MSG(sign, LOG(INFO) << "K0S was correct! now we check the Lc"); auto labelProton = candidate.index0_as().mcParticleId(); MY_DEBUG_MSG(sign, LOG(INFO) << "label proton = " << labelProton); - RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersLc, 4122, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); // 3-levels Lc --> p + K0 --> p + K0s --> p + pi+ pi- + RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersLc, pdg::code::kLambdaCPlus, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); // 3-levels Lc --> p + K0 --> p + K0s --> p + pi+ pi- MY_DEBUG_MSG(sign, LOG(INFO) << "Lc found with sign " << sign; printf("\n")); } @@ -262,12 +265,12 @@ struct HFCandidateCreatorCascadeMC { // Match generated particles. for (auto& particle : particlesMC) { // checking if I have a Lc --> K0S + p - RecoDecay::isMatchedMCGen(particlesMC, particle, 4122, array{+kProton, 310}, true, &sign, 2); + RecoDecay::isMatchedMCGen(particlesMC, particle, pdg::code::kLambdaCPlus, array{+kProton, +kK0Short}, true, &sign, 2); if (sign != 0) { MY_DEBUG_MSG(sign, LOG(INFO) << "Lc in K0S p"); arrDaughLcIndex.clear(); // checking that the final daughters (decay depth = 3) are p, pi+, pi- - RecoDecay::getDaughters(particlesMC, particle.globalIndex(), &arrDaughLcIndex, arrDaughLcPDGRef, 3); // best would be to check the K0S daughters + RecoDecay::getDaughters(particlesMC, particle, &arrDaughLcIndex, arrDaughLcPDGRef, 3); // best would be to check the K0S daughters if (arrDaughLcIndex.size() == 3) { for (auto iProng = 0; iProng < arrDaughLcIndex.size(); ++iProng) { auto daughI = particlesMC.iteratorAt(arrDaughLcIndex[iProng]); @@ -291,11 +294,11 @@ struct HFCandidateCreatorCascadeMC { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { WorkflowSpec workflow{ - adaptAnalysisTask(cfgc, "hf-cand-creator-cascade"), - adaptAnalysisTask(cfgc, "hf-cand-creator-cascade-expressions")}; + adaptAnalysisTask(cfgc, TaskName{"hf-cand-creator-cascade"}), + adaptAnalysisTask(cfgc, TaskName{"hf-cand-creator-cascade-expressions"})}; const bool doMC = cfgc.options().get("doMC"); if (doMC) { - workflow.push_back(adaptAnalysisTask(cfgc, "hf-cand-creator-cascade-mc")); + workflow.push_back(adaptAnalysisTask(cfgc, TaskName{"hf-cand-creator-cascade-mc"})); } return workflow; } diff --git a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx index 2edcb70b5deca..8d0933ae7a6f0 100644 --- a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx +++ b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx @@ -192,7 +192,7 @@ struct HFLcK0sPCandidateSelector { template bool validTPCPID(const T& track) { - if (TMath::Abs(track.pt()) < d_pidTPCMinPt || TMath::Abs(track.pt()) >= d_pidTPCMaxPt) { + if (track.pt() < d_pidTPCMinPt || track.pt() >= d_pidTPCMaxPt) { LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we trust TPC PID in [" << d_pidTPCMinPt << ", " << d_pidTPCMaxPt << "]"; return false; } @@ -396,5 +396,5 @@ struct HFLcK0sPCandidateSelector { WorkflowSpec defineDataProcessing(ConfigContext const& cfcg) { return WorkflowSpec{ - adaptAnalysisTask(cfcg, "hf-lc-tok0sp-candidate-selector")}; + adaptAnalysisTask(cfcg, TaskName{"hf-lc-tok0sp-candidate-selector"})}; } diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index 434e6cba41ff9..7dfafb42d9b5e 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -26,6 +26,7 @@ #include "AnalysisDataModel/TrackSelectionTables.h" #include "ReconstructionDataFormats/V0.h" #include "AnalysisTasksUtils/UtilsDebugLcK0Sp.h" +#include "AnalysisCore/HFSelectorCuts.h" #include @@ -35,10 +36,11 @@ using namespace o2::framework::expressions; using namespace o2::aod; using namespace o2::analysis; using namespace o2::analysis::hf_cuts_single_track; +>>>>>>> Implementation of comments by Anton and Vit void customize(std::vector& workflowOptions) { - ConfigParamSpec optionDoMC{"doMC-for-V0", VariantType::Bool, false, {"Perform MC matching for V0s."}}; + ConfigParamSpec optionDoMC{"do-LcK0Sp", VariantType::Bool, false, {"Skim also Lc --> K0S+p"}}; workflowOptions.push_back(optionDoMC); } @@ -216,13 +218,7 @@ struct SelectTracks { // DCA cut array dca; if (status_prong > 0) { -<<<<<<< HEAD - double dcatoprimxymin_bach_ptdep = dcatoprimxymin_bach * TMath::Max(0., (1 - TMath::Floor(trackPt / dcatoprimxy_maxpt_bach))); -======= - double dcatoprimxymin_2prong_ptdep = dcatoprimxymin_2prong * TMath::Max(0., (1 - TMath::Floor(trackPt / dcatoprimxy_2prong_maxpt))); - double dcatoprimxymin_3prong_ptdep = dcatoprimxymin_3prong * TMath::Max(0., (1 - TMath::Floor(trackPt / dcatoprimxy_3prong_maxpt))); double d_dcaToPrimXYMinBach_ptDep = d_dcaToPrimXYMinBach * TMath::Max(0., (1 - TMath::Floor(trackPt / d_dcaToPrimXYMaxPtBach))); ->>>>>>> Comments by Vit auto trackparvar0 = getTrackParCov(track); if (!trackparvar0.propagateParamToDCA(vtxXYZ, d_bz, &dca, 100.)) { // get impact parameters status_prong = 0; @@ -1076,7 +1072,7 @@ struct HFTrackIndexSkimsCreatorCascades { double massP = RecoDecay::getMassPDG(kProton); double massK0s = RecoDecay::getMassPDG(kK0Short); double massPi = RecoDecay::getMassPDG(kPiPlus); - double massLc = RecoDecay::getMassPDG(4122); + double massLc = RecoDecay::getMassPDG(pdg::code::kLambdaCPlus); double mass2K0sP{0.}; // WHY HERE? using FullTracksExt = soa::Join; @@ -1209,7 +1205,7 @@ struct HFTrackIndexSkimsCreatorCascades { const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; // we build the neutral track to then build the cascade - auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track + auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, {0, 0, 0, 0, 0, 0}, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track // now we find the DCA between the V0 and the bachelor, for the cascade int nCand2 = fitter.process(trackV0, bachTrack); @@ -1268,35 +1264,18 @@ struct HFTrackIndexSkimsCreatorCascades { } // process }; -struct HFTrackIndexTestMCCasc { - void process(aod::BigTracksMC const& tracks, - aod::V0Datas const& V0s, - aod::McParticles const& particlesMC) - - { - int8_t sign = 0; - for (const auto& v0 : V0s) { - // selections on the V0 daughters - auto arrayDaughtersV0 = array{v0.posTrack_as(), v0.negTrack_as()}; - RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, 310, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s - } - return; - } -}; - //________________________________________________________________________________________________________________________ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { - return WorkflowSpec{ + WorkflowSpec workflow{ adaptAnalysisTask(cfgc, TaskName{"hf-produce-sel-track"}), - adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-creator"}), - adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-cascades-creator"})}; + adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-creator"})}; - const bool doMCforV0 = cfgc.options().get("doMC-for-V0"); - if (doMCforV0) { - workflow.push_back(adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-creator-MC"})); + const bool doLcK0Sp = cfgc.options().get("do-LcK0Sp"); + if (doLcK0Sp) { + workflow.push_back(adaptAnalysisTask(cfgc, TaskName{"hf-track-index-skims-cascades-creator"})); } - return workflow; + return workflow; } diff --git a/Analysis/Tasks/PWGHF/taskLcK0sP.cxx b/Analysis/Tasks/PWGHF/taskLcK0sP.cxx index 8148d303d675f..2949ca242f477 100644 --- a/Analysis/Tasks/PWGHF/taskLcK0sP.cxx +++ b/Analysis/Tasks/PWGHF/taskLcK0sP.cxx @@ -19,11 +19,13 @@ #include "Framework/HistogramRegistry.h" #include "AnalysisDataModel/HFSecondaryVertex.h" #include "AnalysisDataModel/HFCandidateSelectionTables.h" +#include "AnalysisCore/HFSelectorCuts.h" using namespace o2; using namespace o2::framework; using namespace o2::aod::hf_cand_casc; using namespace o2::framework::expressions; +using namespace o2::analysis; void customize(std::vector& workflowOptions) { @@ -114,7 +116,7 @@ struct TaskLcK0SpMC { } if (std::abs(candidate.flagMCMatchRec()) == 1) { // Get the corresponding MC particle. - auto indexMother = RecoDecay::getMother(particlesMC, candidate.index0_as().mcParticle_as>(), 4122, true); + auto indexMother = RecoDecay::getMother(particlesMC, candidate.index0_as().mcParticle_as>(), pdg::code::kLambdaCPlus, true); auto particleMother = particlesMC.iteratorAt(indexMother); registry.fill(HIST("hPtGenSig"), particleMother.pt()); // gen. level pT registry.fill(HIST("hPtRecSig"), candidate.pt()); // rec. level pT @@ -144,10 +146,10 @@ struct TaskLcK0SpMC { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { WorkflowSpec workflow{ - adaptAnalysisTask(cfgc, "hf-task-lc-tok0sP")}; + adaptAnalysisTask(cfgc, TaskName{"hf-task-lc-tok0sP"})}; const bool doMC = cfgc.options().get("doMC"); if (doMC) { - workflow.push_back(adaptAnalysisTask(cfgc, "hf-task-lc-tok0sP-mc")); + workflow.push_back(adaptAnalysisTask(cfgc, TaskName{"hf-task-lc-tok0sP-mc"})); } return workflow; } From 5f0469c0ba3f4e059821f25c54cf20c375815702 Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Thu, 29 Apr 2021 15:10:31 +0200 Subject: [PATCH 13/14] more comments by Vit clang-format --- .../Core/include/AnalysisCore/RecoDecay.h | 2 +- .../HFCandidateSelectionTables.h | 2 +- .../AnalysisDataModel/HFSecondaryVertex.h | 31 +- Analysis/Tasks/PWGHF/CMakeLists.txt | 2 +- .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 81 +++--- .../Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx | 54 ++-- .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 265 +++++++++--------- Analysis/Tasks/PWGHF/taskLcK0sP.cxx | 60 ++-- 8 files changed, 249 insertions(+), 248 deletions(-) diff --git a/Analysis/Core/include/AnalysisCore/RecoDecay.h b/Analysis/Core/include/AnalysisCore/RecoDecay.h index e4a6289b6afa3..369f2dae6ca24 100644 --- a/Analysis/Core/include/AnalysisCore/RecoDecay.h +++ b/Analysis/Core/include/AnalysisCore/RecoDecay.h @@ -874,7 +874,7 @@ class RecoDecay *listIndexDaughters = arrAllDaughtersIndex; } } - //Printf("MC Gen: Accepted: m: %ld", candidate.globalIndex()); + //Printf("MC Gen: Accepted: m: %d", candidate.globalIndex()); if (sign) { *sign = sgn; } diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h b/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h index a54259b0217f0..50c5057e30ca8 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFCandidateSelectionTables.h @@ -47,7 +47,7 @@ namespace hf_selcandidate_lc_k0sp DECLARE_SOA_COLUMN(IsSelLcK0sP, isSelLcK0sP, int); } // namespace hf_selcandidate_lc_k0sp DECLARE_SOA_TABLE(HFSelLcK0sPCandidate, "AOD", "HFSELLCK0SPCAND", //! - hf_selcandidate_lc_k0sp::IsSelLcK0sP); + hf_selcandidate_lc_k0sp::IsSelLcK0sP); } // namespace o2::aod diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h index e1b6f4fc825b1..64d0583c33ab6 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h @@ -71,12 +71,12 @@ DECLARE_SOA_TABLE(HfTrackIndexProng2, "AOD", "HFTRACKIDXP2", //! hf_track_index::Index1Id, hf_track_index::HFflag); - DECLARE_SOA_TABLE(HfTrackIndexCasc, "AOD", "HFTRACKIDXCASC", //! +DECLARE_SOA_TABLE(HfTrackIndexCasc, "AOD", "HFTRACKIDXCASC", //! hf_track_index::Index0Id, hf_track_index::IndexV0Id, hf_track_index::HFflag); - DECLARE_SOA_TABLE(HfCutStatusProng2, "AOD", "HFCUTSTATUSP2", //! +DECLARE_SOA_TABLE(HfCutStatusProng2, "AOD", "HFCUTSTATUSP2", //! hf_track_index::D0ToKPiFlag, hf_track_index::JpsiToEEFlag); @@ -369,14 +369,19 @@ DECLARE_SOA_TABLE(HfCandProng2MCGen, "AOD", "HFCANDP2MCGEN", //! namespace hf_cand_casc { -DECLARE_SOA_EXPRESSION_COLUMN(Px, px, float, 1.f * aod::hf_cand::pxProng0 + 1.f * aod::hf_cand::pxProng1); -DECLARE_SOA_EXPRESSION_COLUMN(Py, py, float, 1.f * aod::hf_cand::pyProng0 + 1.f * aod::hf_cand::pyProng1); -DECLARE_SOA_EXPRESSION_COLUMN(Pz, pz, float, 1.f * aod::hf_cand::pzProng0 + 1.f * aod::hf_cand::pzProng1); +DECLARE_SOA_EXPRESSION_COLUMN(Px, px, //! + float, 1.f * aod::hf_cand::pxProng0 + 1.f * aod::hf_cand::pxProng1); +DECLARE_SOA_EXPRESSION_COLUMN(Py, py, //! + float, 1.f * aod::hf_cand::pyProng0 + 1.f * aod::hf_cand::pyProng1); +DECLARE_SOA_EXPRESSION_COLUMN(Pz, pz, //! + float, 1.f * aod::hf_cand::pzProng0 + 1.f * aod::hf_cand::pzProng1); //DECLARE_SOA_DYNAMIC_COLUMN(M, m, [](float px0, float py0, float pz0, float px1, float py1, float pz1, const array& m) { return RecoDecay::M(array{array{px0, py0, pz0}, array{px1, py1, pz1}}, m); }); -DECLARE_SOA_DYNAMIC_COLUMN(PtV0Pos, ptV0Pos, [](float px, float py) { return RecoDecay::Pt(px, py); }); -DECLARE_SOA_DYNAMIC_COLUMN(PtV0Neg, ptV0Neg, [](float px, float py) { return RecoDecay::Pt(px, py); }); -DECLARE_SOA_COLUMN(FlagMCMatchRec, flagMCMatchRec, int8_t); // reconstruction level -DECLARE_SOA_COLUMN(FlagMCMatchGen, flagMCMatchGen, int8_t); // generator level +DECLARE_SOA_DYNAMIC_COLUMN(PtV0Pos, ptV0Pos, //! + [](float px, float py) { return RecoDecay::Pt(px, py); }); +DECLARE_SOA_DYNAMIC_COLUMN(PtV0Neg, ptV0Neg, //! + [](float px, float py) { return RecoDecay::Pt(px, py); }); +DECLARE_SOA_COLUMN(FlagMCMatchRec, flagMCMatchRec, int8_t); //! reconstruction level +DECLARE_SOA_COLUMN(FlagMCMatchGen, flagMCMatchGen, int8_t); //! generator level template auto InvMassLcToK0sP(const T& candidate) @@ -392,7 +397,7 @@ auto InvMassGamma(const T& candidate) } // namespace hf_cand_casc -DECLARE_SOA_TABLE(HfCandCascBase, "AOD", "HFCANDCASCBASE", +DECLARE_SOA_TABLE(HfCandCascBase, "AOD", "HFCANDCASCBASE", //! // general columns HFCAND_COLUMNS, // cascade specific columns @@ -446,17 +451,17 @@ DECLARE_SOA_TABLE(HfCandCascBase, "AOD", "HFCANDCASCBASE", v0data::MK0Short); */ // extended table with expression columns that can be used as arguments of dynamic columns -DECLARE_SOA_EXTENDED_TABLE_USER(HfCandCascExt, HfCandCascBase, "HFCANDCASCEXT", +DECLARE_SOA_EXTENDED_TABLE_USER(HfCandCascExt, HfCandCascBase, "HFCANDCASCEXT", //! hf_cand_casc::Px, hf_cand_casc::Py, hf_cand_casc::Pz); using HfCandCascade = HfCandCascExt; // table with results of reconstruction level MC matching for Cascade -DECLARE_SOA_TABLE(HfCandCascadeMCRec, "AOD", "HFCANDCASCMCREC", +DECLARE_SOA_TABLE(HfCandCascadeMCRec, "AOD", "HFCANDCASCMCREC", //! hf_cand_casc::FlagMCMatchRec); // table with results of generator level MC matching -DECLARE_SOA_TABLE(HfCandCascadeMCGen, "AOD", "HFCANDCASCMCGEN", +DECLARE_SOA_TABLE(HfCandCascadeMCGen, "AOD", "HFCANDCASCMCGEN", //! hf_cand_casc::FlagMCMatchGen); // specific 3-prong decay properties diff --git a/Analysis/Tasks/PWGHF/CMakeLists.txt b/Analysis/Tasks/PWGHF/CMakeLists.txt index 59be5fc31369a..37517c72640bf 100644 --- a/Analysis/Tasks/PWGHF/CMakeLists.txt +++ b/Analysis/Tasks/PWGHF/CMakeLists.txt @@ -25,7 +25,7 @@ o2_add_dpl_workflow(qa-simple o2_add_dpl_workflow(hf-track-index-skims-creator SOURCES HFTrackIndexSkimsCreator.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing O2::AnalysisTasksUtils ROOT::EG + PUBLIC_LINK_LIBRARIES O2::Framework O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing O2::AnalysisTasksUtils ROOT::EG COMPONENT_NAME Analysis) o2_add_dpl_workflow(hf-candidate-creator-2prong diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index 46bf9ec8eab85..322e84afd4695 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -19,12 +19,10 @@ #include "ReconstructionDataFormats/DCA.h" #include "ReconstructionDataFormats/V0.h" #include "AnalysisTasksUtils/UtilsDebugLcK0Sp.h" -#include "AnalysisCore/HFSelectorCuts.h" using namespace o2; using namespace o2::framework; using namespace o2::aod::hf_cand_prong2; -using namespace o2::analysis; void customize(std::vector& workflowOptions) { @@ -37,13 +35,13 @@ void customize(std::vector& workflowOptions) //#define MY_DEBUG #ifdef MY_DEBUG -using MyTracks = aod::BigTracksMC; +using MyBigTracks = aod::BigTracksMC; #define MY_DEBUG_MSG(condition, cmd) \ if (condition) { \ cmd; \ } #else -using MyTracks = aod::BigTracks; +using MyBigTracks = aod::BigTracks; #define MY_DEBUG_MSG(condition, cmd) #endif @@ -52,19 +50,19 @@ struct HFCandidateCreatorCascade { Produces rowCandidateBase; - Configurable d_bZ{"d_bZ", 5., "magnetic field"}; - Configurable b_propDCA{"b_propDCA", true, "create tracks version propagated to PCA"}; - Configurable d_maxR{"d_maxR", 200., "reject PCA's above this radius"}; - Configurable d_maxDZIni{"d_maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; - Configurable d_minParamChange{"d_minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; - Configurable d_minRelChi2Change{"d_minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; - Configurable b_doValPlots{"b_doValPlots", true, "do validation plots"}; + Configurable bZ{"bZ", 5., "magnetic field"}; + Configurable propDCA{"propDCA", true, "create tracks version propagated to PCA"}; + Configurable maxR{"maxR", 200., "reject PCA's above this radius"}; + Configurable maxDZIni{"maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; + Configurable minParamChange{"minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable minRelChi2Change{"minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"}; + Configurable doValPlots{"doValPlots", true, "do validation plots"}; // for debugging #ifdef MY_DEBUG - Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; - Configurable> v_labelProton{"v_labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; + Configurable> labelK0Spos{"labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; + Configurable> labelK0Sneg{"labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; + Configurable> labelProton{"labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; #endif OutputObj hmass2{TH1F("hmass2", "2-prong candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", 500, 0., 5.)}; @@ -74,12 +72,12 @@ struct HFCandidateCreatorCascade { double massP = RecoDecay::getMassPDG(kProton); double massK0s = RecoDecay::getMassPDG(kK0Short); double massPi = RecoDecay::getMassPDG(kPiPlus); - double massLc = RecoDecay::getMassPDG(pdg::code::kLambdaCPlus); + double massLc = RecoDecay::getMassPDG(pdg::Code::kLambdaCPlus); double mass2K0sP{0.}; void process(aod::Collisions const& collisions, aod::HfTrackIndexCasc const& rowsTrackIndexCasc, - MyTracks const& tracks, + MyBigTracks const& tracks, aod::V0Datas const& V0s #ifdef MY_DEBUG , @@ -89,35 +87,36 @@ struct HFCandidateCreatorCascade { { // 2-prong vertex fitter o2::vertexing::DCAFitterN<2> df; - df.setBz(d_bZ); - df.setPropagateToPCA(b_propDCA); - df.setMaxR(d_maxR); - df.setMaxDZIni(d_maxDZIni); - df.setMinParamChange(d_minParamChange); - df.setMinRelChi2Change(d_minRelChi2Change); + df.setBz(bZ); + df.setPropagateToPCA(propDCA); + df.setMaxR(maxR); + df.setMaxDZIni(maxDZIni); + df.setMinParamChange(minParamChange); + df.setMinRelChi2Change(minRelChi2Change); df.setUseAbsDCA(true); // loop over pairs of track indeces for (const auto& casc : rowsTrackIndexCasc) { - const auto& bach = casc.index0_as(); + + const auto& bach = casc.index0_as(); auto trackParCovBach = getTrackParCov(bach); const auto& v0 = casc.indexV0_as(); - const auto& posTrack = v0.posTrack_as(); - const auto& negTrack = v0.negTrack_as(); + const auto& posTrack = v0.posTrack_as(); + const auto& negTrack = v0.negTrack_as(); #ifdef MY_DEBUG auto protonLabel = bach.mcParticleId(); auto labelPos = posTrack.mcParticleId(); auto labelNeg = negTrack.mcParticleId(); - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, v_labelProton, v_labelK0Spos, v_labelK0Sneg); + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, labelProton, labelK0Spos, labelK0Sneg); #endif MY_DEBUG_MSG(isLc, LOG(INFO) << "Processing the Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg); - auto posTrackParCov = getTrackParCov(posTrack); // check that MyTracks does not need TracksExtended! - auto negTrackParCov = getTrackParCov(negTrack); // check that MyTracks does not need TracksExtended! - posTrackParCov.propagateTo(v0.posX(), d_bZ); // propagate the track to the X closest to the V0 vertex - negTrackParCov.propagateTo(v0.negX(), d_bZ); // propagate the track to the X closest to the V0 vertex + auto posTrackParCov = getTrackParCov(posTrack); // check that MyBigTracks does not need TracksExtended! + auto negTrackParCov = getTrackParCov(negTrack); // check that MyBigTracks does not need TracksExtended! + posTrackParCov.propagateTo(v0.posX(), bZ); // propagate the track to the X closest to the V0 vertex + negTrackParCov.propagateTo(v0.negX(), bZ); // propagate the track to the X closest to the V0 vertex const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; // we build the neutral track to then build the cascade @@ -157,8 +156,8 @@ struct HFCandidateCreatorCascade { hCovPVXX->Fill(covMatrixPV[0]); o2::dataformats::DCA impactParameterV0; o2::dataformats::DCA impactParameterBach; - trackParVarV0.propagateToDCA(primaryVertex, d_bZ, &impactParameterV0); // we do this wrt the primary vtx - trackParVarBach.propagateToDCA(primaryVertex, d_bZ, &impactParameterBach); + trackParVarV0.propagateToDCA(primaryVertex, bZ, &impactParameterV0); // we do this wrt the primary vtx + trackParVarBach.propagateToDCA(primaryVertex, bZ, &impactParameterBach); // get uncertainty of the decay length double phi, theta; @@ -181,7 +180,7 @@ struct HFCandidateCreatorCascade { casc.hfflag(), v0.x(), v0.y(), v0.z(), //v0.posTrack(), v0.negTrack(), // why this was not fine? - v0.posTrack_as().globalIndex(), v0.negTrack_as().globalIndex(), + v0.posTrack_as().globalIndex(), v0.negTrack_as().globalIndex(), v0.pxpos(), v0.pypos(), v0.pzpos(), v0.pxneg(), v0.pyneg(), v0.pzneg(), v0.dcaV0daughters(), @@ -189,7 +188,7 @@ struct HFCandidateCreatorCascade { v0.dcanegtopv()); // fill histograms - if (b_doValPlots) { + if (doValPlots) { // calculate invariant masses auto arrayMomenta = array{pVecBach, pVecV0}; mass2K0sP = RecoDecay::M(arrayMomenta, array{massP, massK0s}); @@ -213,9 +212,9 @@ struct HFCandidateCreatorCascadeMC { Produces rowMCMatchGen; #ifdef MY_DEBUG - Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; - Configurable> v_labelProton{"v_labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; + Configurable> labelK0Spos{"labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; + Configurable> labelK0Sneg{"labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; + Configurable> labelProton{"labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; #endif void process(aod::HfCandCascade const& candidates, @@ -241,8 +240,8 @@ struct HFCandidateCreatorCascadeMC { auto protonLabel = candidate.index0_as().mcParticleId(); #ifdef MY_DEBUG - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, v_labelProton, v_labelK0Spos, v_labelK0Sneg); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, v_labelK0Spos, v_labelK0Sneg); + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, labelProton, labelK0Spos, labelK0Sneg); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, labelK0Spos, labelK0Sneg); #endif MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "correct K0S in the Lc daughters: posTrack --> " << labelPos << ", negTrack --> " << labelNeg); @@ -254,7 +253,7 @@ struct HFCandidateCreatorCascadeMC { MY_DEBUG_MSG(sign, LOG(INFO) << "K0S was correct! now we check the Lc"); auto labelProton = candidate.index0_as().mcParticleId(); MY_DEBUG_MSG(sign, LOG(INFO) << "label proton = " << labelProton); - RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersLc, pdg::code::kLambdaCPlus, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); // 3-levels Lc --> p + K0 --> p + K0s --> p + pi+ pi- + RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersLc, pdg::Code::kLambdaCPlus, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); // 3-levels Lc --> p + K0 --> p + K0s --> p + pi+ pi- MY_DEBUG_MSG(sign, LOG(INFO) << "Lc found with sign " << sign; printf("\n")); } @@ -265,7 +264,7 @@ struct HFCandidateCreatorCascadeMC { // Match generated particles. for (auto& particle : particlesMC) { // checking if I have a Lc --> K0S + p - RecoDecay::isMatchedMCGen(particlesMC, particle, pdg::code::kLambdaCPlus, array{+kProton, +kK0Short}, true, &sign, 2); + RecoDecay::isMatchedMCGen(particlesMC, particle, pdg::Code::kLambdaCPlus, array{+kProton, +kK0Short}, true, &sign, 2); if (sign != 0) { MY_DEBUG_MSG(sign, LOG(INFO) << "Lc in K0S p"); arrDaughLcIndex.clear(); diff --git a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx index 8d0933ae7a6f0..f0a40c2361331 100644 --- a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx +++ b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx @@ -56,25 +56,25 @@ struct HFLcK0sPCandidateSelector { Produces hfSelLcK0sPCandidate; - Configurable d_pTCandMin{"d_pTCandMin", 0., "Lower bound of candidate pT"}; - Configurable d_pTCandMax{"d_pTCandMax", 50., "Upper bound of candidate pT"}; + Configurable pTCandMin{"pTCandMin", 0., "Lower bound of candidate pT"}; + Configurable pTCandMax{"pTCandMax", 50., "Upper bound of candidate pT"}; // PID - Configurable d_applyPidTPCMinPt{"d_applyPidTPCMinPt", 4., "Lower bound of track pT to apply TPC PID"}; - Configurable d_pidTPCMinPt{"d_pidTPCMinPt", 0., "Lower bound of track pT for TPC PID"}; - Configurable d_pidTPCMaxPt{"d_pidTPCMaxPt", 100., "Upper bound of track pT for TPC PID"}; - Configurable d_pidCombMaxP{"d_pidCombMaxP", 4., "Upper bound of track p to use TOF + TPC Bayes PID"}; - Configurable d_nSigmaTPC{"d_nSigmaTPC", 3., "Nsigma cut on TPC only"}; + Configurable applyPidTPCMinPt{"applyPidTPCMinPt", 4., "Lower bound of track pT to apply TPC PID"}; + Configurable pidTPCMinPt{"pidTPCMinPt", 0., "Lower bound of track pT for TPC PID"}; + Configurable pidTPCMaxPt{"pidTPCMaxPt", 100., "Upper bound of track pT for TPC PID"}; + Configurable pidCombMaxP{"pidCombMaxP", 4., "Upper bound of track p to use TOF + TPC Bayes PID"}; + Configurable nSigmaTPC{"nSigmaTPC", 3., "Nsigma cut on TPC only"}; // track quality - Configurable d_TPCNClsFindablePIDCut{"d_TPCNClsFindablePIDCut", 50., "Lower bound of TPC findable clusters for good PID"}; - Configurable b_requireTPC{"b_requireTPC", true, "Flag to require a positive Number of found clusters in TPC"}; + Configurable TPCNClsFindablePIDCut{"TPCNClsFindablePIDCut", 50., "Lower bound of TPC findable clusters for good PID"}; + Configurable requireTPC{"requireTPC", true, "Flag to require a positive Number of found clusters in TPC"}; // for debugging #ifdef MY_DEBUG - Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; - Configurable> v_labelProton{"v_labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; + Configurable> labelK0Spos{"labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; + Configurable> labelK0Sneg{"labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; + Configurable> labelProton{"labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; #endif /// Gets corresponding pT bin from cut file array @@ -107,7 +107,7 @@ struct HFLcK0sPCandidateSelector { if (track.sign() == 0) { return false; } - if (b_requireTPC.value && track.tpcNClsFound() == 0) { + if (requireTPC.value && track.tpcNClsFound() == 0) { return false; //is it clusters findable or found - need to check } return true; @@ -125,8 +125,8 @@ struct HFLcK0sPCandidateSelector { return false; } - if (candPt < d_pTCandMin || candPt >= d_pTCandMax) { - LOG(DEBUG) << "cand pt (first check) cut failed: from cascade --> " << candPt << ", cut --> " << d_pTCandMax; + if (candPt < pTCandMin || candPt >= pTCandMax) { + LOG(DEBUG) << "cand pt (first check) cut failed: from cascade --> " << candPt << ", cut --> " << pTCandMax; return false; //check that the candidate pT is within the analysis range } @@ -192,8 +192,8 @@ struct HFLcK0sPCandidateSelector { template bool validTPCPID(const T& track) { - if (track.pt() < d_pidTPCMinPt || track.pt() >= d_pidTPCMaxPt) { - LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we trust TPC PID in [" << d_pidTPCMinPt << ", " << d_pidTPCMaxPt << "]"; + if (track.pt() < pidTPCMinPt || track.pt() >= pidTPCMaxPt) { + LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we trust TPC PID in [" << pidTPCMinPt << ", " << pidTPCMaxPt << "]"; return false; } return true; @@ -206,11 +206,11 @@ struct HFLcK0sPCandidateSelector { template bool applyTPCPID(const T& track) { - if (TMath::Abs(track.pt()) < d_applyPidTPCMinPt) { - LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we apply TPC PID from " << d_applyPidTPCMinPt; + if (TMath::Abs(track.pt()) < applyPidTPCMinPt) { + LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we apply TPC PID from " << applyPidTPCMinPt; return false; } - LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we apply TPC PID from " << d_applyPidTPCMinPt; + LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we apply TPC PID from " << applyPidTPCMinPt; return true; } @@ -221,7 +221,7 @@ struct HFLcK0sPCandidateSelector { template bool validCombPID(const T& track) { - if (TMath::Abs(track.pt()) > d_pidCombMaxP) { // is the pt sign used for the charge? If it is always positive, we should remove the abs + if (TMath::Abs(track.pt()) > pidCombMaxP) { // is the pt sign used for the charge? If it is always positive, we should remove the abs return false; } return true; @@ -283,10 +283,10 @@ struct HFLcK0sPCandidateSelector { if (validTPCPID(track)) { LOG(DEBUG) << "We check the TPC PID now"; - if (!selectionPIDTPC(track, d_nSigmaTPC)) { + if (!selectionPIDTPC(track, nSigmaTPC)) { statusTPC = 0; /* - if (!selectionPIDTPC(track, nPDG, d_nSigmaTPCCombined)) { + if (!selectionPIDTPC(track, nPDG, nSigmaTPCCombined)) { statusTPC = 0; //rejected by PID } else { statusTPC = 1; //potential to be acceepted if combined with TOF @@ -303,8 +303,8 @@ struct HFLcK0sPCandidateSelector { return statusTPC; /* if (validTOFPID(track)) { - if (!selectionPIDTOF(track, nPDG, d_nSigmaTOF)) { - if (!selectionPIDTOF(track, nPDG, d_nSigmaTOFCombined)) { + if (!selectionPIDTOF(track, nPDG, nSigmaTOF)) { + if (!selectionPIDTOF(track, nPDG, nSigmaTOFCombined)) { statusTOF = 0; //rejected by PID } else { statusTOF = 1; //potential to be acceepted if combined with TOF @@ -341,8 +341,8 @@ struct HFLcK0sPCandidateSelector { auto labelPos = candidate.posTrack_as().mcParticleId(); auto labelNeg = candidate.negTrack_as().mcParticleId(); auto protonLabel = candidate.index0_as().mcParticleId(); - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, v_labelProton, v_labelK0Spos, v_labelK0Sneg); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, v_labelK0Spos, v_labelK0Sneg); + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, labelProton, labelK0Spos, labelK0Sneg); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, labelK0Spos, labelK0Sneg); #endif MY_DEBUG_MSG(isLc, printf("\n"); LOG(INFO) << "In selector: correct Lc found: proton --> " << protonLabel << ", posTrack --> " << labelPos << ", negTrack --> " << labelNeg); //MY_DEBUG_MSG(isLc != 1, printf("\n"); LOG(INFO) << "In selector: wrong Lc found: proton --> " << protonLabel << ", posTrack --> " << labelPos << ", negTrack --> " << labelNeg); diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index 7dfafb42d9b5e..b83744b78a659 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -36,7 +36,6 @@ using namespace o2::framework::expressions; using namespace o2::aod; using namespace o2::analysis; using namespace o2::analysis::hf_cuts_single_track; ->>>>>>> Implementation of comments by Anton and Vit void customize(std::vector& workflowOptions) { @@ -72,11 +71,11 @@ struct SelectTracks { Produces rowSelectedTrack; - Configurable b_dovalplots{"b_dovalplots", true, "fill histograms"}; - Configurable d_bz{"d_bz", 5., "bz field"}; + Configurable dovalplots{"dovalplots", true, "fill histograms"}; + Configurable bz{"bz", 5., "bz field"}; // quality cut Configurable doCutQuality{"doCutQuality", true, "apply quality cuts"}; - Configurable d_tpcnclsfound{"d_tpcnclsfound", 70, ">= min. number of TPC clusters needed"}; + Configurable tpcnclsfound{"tpcnclsfound", 70, ">= min. number of TPC clusters needed"}; // pT bins for single-track cuts Configurable> pTBinsTrack{"ptbins_singletrack", std::vector{hf_cuts_single_track::pTBinsTrack_v}, "track pT bin limits for 2-prong DCAXY pT-depentend cut"}; // 2-prong cuts @@ -88,17 +87,17 @@ struct SelectTracks { Configurable> cutsTrack3Prong{"cuts_singletrack_3prong", {hf_cuts_single_track::cutsTrack[0], npTBinsTrack, nCutVarsTrack, pTBinLabelsTrack, cutVarLabelsTrack}, "Single-track selections per pT bin for 3-prong candidates"}; Configurable etamax_3prong{"etamax_3prong", 4., "max. pseudorapidity for 3 prong candidate"}; // bachelor cuts (when using cascades) - Configurable d_ptMinTrackBach{"d_ptMinTrackBach", 0.3, "min. track pT for bachelor in cascade candidate"}; // 0.5 for PbPb 2015? - Configurable d_dcaToPrimXYMaxPtBach{"d_dcaToPrimXYMaxPtBach", 2., "max pt cut for min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; - Configurable d_dcaToPrimXYMinBach{"d_dcaToPrimXYMinBach", 0., "min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; // for PbPb 2018, the cut should be 0.0025 - Configurable d_dcaToPrimXYMaxBach{"d_dcaToPrimXYMaxBach", 1.0, "max. DCAXY to prim. vtx. for bachelor in cascade candidate"}; - Configurable d_etaMaxBach{"d_etaMaxBach", 0.8, "max. pseudorapidity for bachelor in cascade candidate"}; + Configurable ptMinTrackBach{"ptMinTrackBach", 0.3, "min. track pT for bachelor in cascade candidate"}; // 0.5 for PbPb 2015? + Configurable dcaToPrimXYMaxPtBach{"dcaToPrimXYMaxPtBach", 2., "max pt cut for min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; + Configurable dcaToPrimXYMinBach{"dcaToPrimXYMinBach", 0., "min. DCAXY to prim. vtx. for bachelor in cascade candidate"}; // for PbPb 2018, the cut should be 0.0025 + Configurable dcaToPrimXYMaxBach{"dcaToPrimXYMaxBach", 1.0, "max. DCAXY to prim. vtx. for bachelor in cascade candidate"}; + Configurable etaMaxBach{"etaMaxBach", 0.8, "max. pseudorapidity for bachelor in cascade candidate"}; // for debugging #ifdef MY_DEBUG - Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; - Configurable> v_labelProton{"v_labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; + Configurable> labelK0Spos{"labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; + Configurable> labelK0Sneg{"labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; + Configurable> labelProton{"labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; #endif HistogramRegistry registry{ @@ -111,7 +110,7 @@ struct SelectTracks { // 3-prong histograms {"hpt_cuts_3prong", "tracks selected for 3-prong vertexing;#it{p}_{T}^{track} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, {"hdcatoprimxy_cuts_3prong", "tracks selected for 3-prong vertexing;DCAxy to prim. vtx. (cm);entries", {HistType::kTH1F, {{400, -2., 2.}}}}, - {"heta_cuts_3prong", "tracks selected for 3-prong vertexing;#it{#eta};entries", {HistType::kTH1F, {{static_cast(1.2 * etamax_3prong * 100), -1.2 * etamax_3prong, 1.2 * etamax_3prong}}}}}}; + {"heta_cuts_3prong", "tracks selected for 3-prong vertexing;#it{#eta};entries", {HistType::kTH1F, {{static_cast(1.2 * etamax_3prong * 100), -1.2 * etamax_3prong, 1.2 * etamax_3prong}}}}, // bachelor (for cascades) histograms {"hpt_cuts_bach", "bachelor tracks selected for cascade vertexing;#it{p}_{T}^{track} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, {"hdcatoprimxy_cuts_bach", "bachelor tracks selected for cascade vertexing;DCAxy to prim. vtx. (cm);entries", {HistType::kTH1F, {{100, -1., 1.}}}}, @@ -162,7 +161,7 @@ struct SelectTracks { #ifdef MY_DEBUG auto protonLabel = track.mcParticleId(); // LOG(INFO) << "Checking label " << protonLabel; - bool isProtonFromLc = isProtonFromLcFunc(protonLabel, v_labelProton); + bool isProtonFromLc = isProtonFromLcFunc(protonLabel, labelProton); #endif @@ -171,7 +170,7 @@ struct SelectTracks { int status_prong = 7; // selection flag , 3 bits on auto trackPt = track.pt(); - if (b_dovalplots.value) { + if (dovalplots.value) { registry.get(HIST("hpt_nocuts"))->Fill(trackPt); } @@ -182,9 +181,9 @@ struct SelectTracks { if (trackPt < ptmintrack_3prong) { status_prong = status_prong & ~(1 << 1); } - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " pt = " << track.pt() << " (cut " << d_ptMinTrackBach << ")"); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " pt = " << track.pt() << " (cut " << ptMinTrackBach << ")"); - if (track.pt() < d_ptMinTrackBach) { + if (track.pt() < ptMinTrackBach) { status_prong = status_prong & ~(1 << 2); } @@ -196,18 +195,18 @@ struct SelectTracks { if ((status_prong & (1 << 1)) && abs(trackEta) > etamax_3prong) { status_prong = status_prong & ~(1 << 1); } - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " eta = " << track.eta() << " (cut " << d_etaMaxBach << ")"); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " eta = " << track.eta() << " (cut " << etaMaxBach << ")"); - if ((status_prong & (1 << 2)) && abs(track.eta()) > d_etaMaxBach) { + if ((status_prong & (1 << 2)) && abs(track.eta()) > etaMaxBach) { status_prong = status_prong & ~(1 << 2); } // quality cut - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " tpcNClsFound = " << track.tpcNClsFound() << " (cut " << d_tpcnclsfound.value << ")"); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " tpcNClsFound = " << track.tpcNClsFound() << " (cut " << tpcnclsfound.value << ")"); if (doCutQuality.value && status_prong > 0) { // FIXME to make a more complete selection e.g track.flags() & o2::aod::track::TPCrefit && track.flags() & o2::aod::track::GoldenChi2 && UChar_t clustermap = track.itsClusterMap(); - if (!(track.tpcNClsFound() >= d_tpcnclsfound.value && // is this the number of TPC clusters? It should not be used + if (!(track.tpcNClsFound() >= tpcnclsfound.value && // is this the number of TPC clusters? It should not be used track.flags() & o2::aod::track::ITSrefit && (TESTBIT(clustermap, 0) || TESTBIT(clustermap, 1)))) { status_prong = 0; @@ -218,9 +217,9 @@ struct SelectTracks { // DCA cut array dca; if (status_prong > 0) { - double d_dcaToPrimXYMinBach_ptDep = d_dcaToPrimXYMinBach * TMath::Max(0., (1 - TMath::Floor(trackPt / d_dcaToPrimXYMaxPtBach))); + double dcaToPrimXYMinBach_ptDep = dcaToPrimXYMinBach * TMath::Max(0., (1 - TMath::Floor(trackPt / dcaToPrimXYMaxPtBach))); auto trackparvar0 = getTrackParCov(track); - if (!trackparvar0.propagateParamToDCA(vtxXYZ, d_bz, &dca, 100.)) { // get impact parameters + if (!trackparvar0.propagateParamToDCA(vtxXYZ, bz, &dca, 100.)) { // get impact parameters status_prong = 0; } if ((status_prong & (1 << 0)) && !isSelectedTrack(track, dca, Cand2Prong)) { @@ -229,17 +228,17 @@ struct SelectTracks { if ((status_prong & (1 << 1)) && !isSelectedTrack(track, dca, Cand3Prong)) { status_prong = status_prong & ~(1 << 1); } - if ((status_prong & (1 << 2)) && (abs(dca[0]) < d_dcaToPrimXYMinBach_ptDep || abs(dca[0]) > d_dcaToPrimXYMaxBach)) { + if ((status_prong & (1 << 2)) && (abs(dca[0]) < dcaToPrimXYMinBach_ptDep || abs(dca[0]) > dcaToPrimXYMaxBach)) { MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " did not pass DCA cut"; - LOG(INFO) << "dca[0] = " << dca[0] << " (lower cut " << d_dcaToPrimXYMinBach_ptDep << ", upper cut " << d_dcaToPrimXYMaxBach << ")";); + LOG(INFO) << "dca[0] = " << dca[0] << " (lower cut " << dcaToPrimXYMinBach_ptDep << ", upper cut " << dcaToPrimXYMaxBach << ")";); status_prong = status_prong & ~(1 << 2); } } MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "status_prong = " << status_prong; printf("\n")); // fill histograms - if (b_dovalplots) { + if (dovalplots) { if (status_prong & (1 << 0)) { registry.get(HIST("hpt_cuts_2prong"))->Fill(trackPt); registry.get(HIST("hdcatoprimxy_cuts_2prong"))->Fill(dca[0]); @@ -274,20 +273,20 @@ struct HFTrackIndexSkimsCreator { Produces rowProng3CutStatus; //Configurable nCollsMax{"nCollsMax", -1, "Max collisions per file"}; //can be added to run over limited collisions per file - for tesing purposes - Configurable b_dovalplots{"b_dovalplots", true, "fill histograms"}; + Configurable dovalplots{"dovalplots", true, "fill histograms"}; Configurable do3prong{"do3prong", 0, "do 3 prong"}; // event selection Configurable triggerindex{"triggerindex", -1, "trigger index"}; // vertexing parameters - Configurable d_bz{"d_bz", 5., "magnetic field kG"}; - Configurable b_propdca{"b_propdca", true, "create tracks version propagated to PCA"}; + Configurable bz{"bz", 5., "magnetic field kG"}; + Configurable propdca{"propdca", true, "create tracks version propagated to PCA"}; Configurable useAbsDCA{"useAbsDCA", true, "Minimise abs. distance rather than chi2"}; - Configurable d_maxr{"d_maxr", 200., "reject PCA's above this radius"}; - Configurable d_maxdzini{"d_maxdzini", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; - Configurable d_minparamchange{"d_minparamchange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; - Configurable d_minrelchi2change{"d_minrelchi2change", 0.9, "stop iterations if chi2/chi2old > this"}; + Configurable maxr{"maxr", 200., "reject PCA's above this radius"}; + Configurable maxdzini{"maxdzini", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; + Configurable minparamchange{"minparamchange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable minrelchi2change{"minrelchi2change", 0.9, "stop iterations if chi2/chi2old > this"}; Configurable configs{"configs", {}, "configurables"}; - Configurable b_debug{"b_debug", false, "debug mode"}; + Configurable debug{"debug", false, "debug mode"}; HistogramRegistry registry{ "registry", @@ -443,22 +442,22 @@ struct HFTrackIndexSkimsCreator { // 2-prong vertex fitter o2::vertexing::DCAFitterN<2> df2; - df2.setBz(d_bz); - df2.setPropagateToPCA(b_propdca); - df2.setMaxR(d_maxr); - df2.setMaxDZIni(d_maxdzini); - df2.setMinParamChange(d_minparamchange); - df2.setMinRelChi2Change(d_minrelchi2change); + df2.setBz(bz); + df2.setPropagateToPCA(propdca); + df2.setMaxR(maxr); + df2.setMaxDZIni(maxdzini); + df2.setMinParamChange(minparamchange); + df2.setMinRelChi2Change(minrelchi2change); df2.setUseAbsDCA(useAbsDCA); // 3-prong vertex fitter o2::vertexing::DCAFitterN<3> df3; - df3.setBz(d_bz); - df3.setPropagateToPCA(b_propdca); - df3.setMaxR(d_maxr); - df3.setMaxDZIni(d_maxdzini); - df3.setMinParamChange(d_minparamchange); - df3.setMinRelChi2Change(d_minrelchi2change); + df3.setBz(bz); + df3.setPropagateToPCA(propdca); + df3.setMaxR(maxr); + df3.setMaxDZIni(maxdzini); + df3.setMinParamChange(minparamchange); + df3.setMinRelChi2Change(minrelchi2change); df3.setUseAbsDCA(useAbsDCA); // used to calculate number of candidiates per event @@ -500,7 +499,7 @@ struct HFTrackIndexSkimsCreator { int isSelected2ProngCand = n2ProngBit; //bitmap for checking status of two-prong candidates (1 is true, 0 is rejected) - if (b_debug) { + if (debug) { for (int n2 = 0; n2 < n2ProngDecays; n2++) { for (int n2cut = 0; n2cut < nCuts2Prong; n2cut++) { cutStatus2Prong[n2][n2cut] = true; @@ -517,11 +516,11 @@ struct HFTrackIndexSkimsCreator { for (int n2 = 0; n2 < n2ProngDecays; n2++) { mass2ProngHypo1[n2] = RecoDecay::M(arrMom, arr2Mass1[n2]); mass2ProngHypo2[n2] = RecoDecay::M(arrMom, arr2Mass2[n2]); - if ((b_debug || (isSelected2ProngCand & 1 << n2)) && cut2ProngInvMassCandMin[n2] >= 0. && cut2ProngInvMassCandMax[n2] > 0.) { //no need to check isSelected2Prong but to avoid mistakes + if ((debug || (isSelected2ProngCand & 1 << n2)) && cut2ProngInvMassCandMin[n2] >= 0. && cut2ProngInvMassCandMax[n2] > 0.) { //no need to check isSelected2Prong but to avoid mistakes if ((mass2ProngHypo1[n2] < cut2ProngInvMassCandMin[n2] || mass2ProngHypo1[n2] >= cut2ProngInvMassCandMax[n2]) && (mass2ProngHypo2[n2] < cut2ProngInvMassCandMin[n2] || mass2ProngHypo2[n2] >= cut2ProngInvMassCandMax[n2])) { isSelected2ProngCand = isSelected2ProngCand & ~(1 << n2); - if (b_debug) { + if (debug) { cutStatus2Prong[n2][iDebugCut] = false; } } @@ -542,12 +541,12 @@ struct HFTrackIndexSkimsCreator { auto pVecCandProng2 = RecoDecay::PVec(pvec0, pvec1); // candidate pT cut - if ((b_debug || isSelected2ProngCand > 0) && (std::count_if(std::begin(cut2ProngPtCandMin), std::end(cut2ProngPtCandMin), [](double d) { return d >= 0.; }) > 0)) { + if ((debug || isSelected2ProngCand > 0) && (std::count_if(std::begin(cut2ProngPtCandMin), std::end(cut2ProngPtCandMin), [](double d) { return d >= 0.; }) > 0)) { double cand2ProngPt = RecoDecay::Pt(pVecCandProng2); for (int n2 = 0; n2 < n2ProngDecays; n2++) { - if ((b_debug || (isSelected2ProngCand & 1 << n2)) && cand2ProngPt < cut2ProngPtCandMin[n2]) { + if ((debug || (isSelected2ProngCand & 1 << n2)) && cand2ProngPt < cut2ProngPtCandMin[n2]) { isSelected2ProngCand = isSelected2ProngCand & ~(1 << n2); - if (b_debug) { + if (debug) { cutStatus2Prong[n2][iDebugCut] = false; } } @@ -556,12 +555,12 @@ struct HFTrackIndexSkimsCreator { iDebugCut++; // imp. par. product cut - if ((b_debug || isSelected2ProngCand > 0) && (std::count_if(std::begin(cut2ProngImpParProductCandMax), std::end(cut2ProngImpParProductCandMax), [](double d) { return d < 100.; }) > 0)) { + if ((debug || isSelected2ProngCand > 0) && (std::count_if(std::begin(cut2ProngImpParProductCandMax), std::end(cut2ProngImpParProductCandMax), [](double d) { return d < 100.; }) > 0)) { auto impParProduct = trackPos1.dcaPrim0() * trackNeg1.dcaPrim0(); for (int n2 = 0; n2 < n2ProngDecays; n2++) { - if ((b_debug || (isSelected2ProngCand & 1 << n2)) && impParProduct > cut2ProngImpParProductCandMax[n2]) { + if ((debug || (isSelected2ProngCand & 1 << n2)) && impParProduct > cut2ProngImpParProductCandMax[n2]) { isSelected2ProngCand = isSelected2ProngCand & ~(1 << n2); - if (b_debug) { + if (debug) { cutStatus2Prong[n2][iDebugCut] = false; } } @@ -570,12 +569,12 @@ struct HFTrackIndexSkimsCreator { iDebugCut++; // CPA cut - if ((b_debug || isSelected2ProngCand > 0) && (std::count_if(std::begin(cut2ProngCPACandMin), std::end(cut2ProngCPACandMin), [](double d) { return d > -2.; }) > 0)) { + if ((debug || isSelected2ProngCand > 0) && (std::count_if(std::begin(cut2ProngCPACandMin), std::end(cut2ProngCPACandMin), [](double d) { return d > -2.; }) > 0)) { auto cpa = RecoDecay::CPA(array{collision.posX(), collision.posY(), collision.posZ()}, secondaryVertex2, pVecCandProng2); for (int n2 = 0; n2 < n2ProngDecays; n2++) { - if ((b_debug || (isSelected2ProngCand & 1 << n2)) && cpa < cut2ProngCPACandMin[n2]) { + if ((debug || (isSelected2ProngCand & 1 << n2)) && cpa < cut2ProngCPACandMin[n2]) { isSelected2ProngCand = isSelected2ProngCand & ~(1 << n2); - if (b_debug) { + if (debug) { cutStatus2Prong[n2][iDebugCut] = false; } } @@ -587,7 +586,7 @@ struct HFTrackIndexSkimsCreator { // fill table row rowTrackIndexProng2(trackPos1.globalIndex(), trackNeg1.globalIndex(), isSelected2ProngCand); - if (b_debug) { + if (debug) { int Prong2CutStatus[n2ProngDecays]; for (int n2 = 0; n2 < n2ProngDecays; n2++) { Prong2CutStatus[n2] = nCutStatus2ProngBit; @@ -601,7 +600,7 @@ struct HFTrackIndexSkimsCreator { } // fill histograms - if (b_dovalplots) { + if (dovalplots) { registry.get(HIST("hvtx2_x"))->Fill(secondaryVertex2[0]); registry.get(HIST("hvtx2_y"))->Fill(secondaryVertex2[1]); @@ -649,7 +648,7 @@ struct HFTrackIndexSkimsCreator { int isSelected3ProngCand = n3ProngBit; - if (b_debug) { + if (debug) { for (int n3 = 0; n3 < n3ProngDecays; n3++) { for (int n3cut = 0; n3cut < nCuts3Prong; n3cut++) { cutStatus3Prong[n3][n3cut] = true; @@ -671,13 +670,13 @@ struct HFTrackIndexSkimsCreator { if ((mass3ProngHypo1[n3] < cut3ProngInvMassCandMin[n3] || mass3ProngHypo1[n3] >= cut3ProngInvMassCandMax[n3]) && (mass3ProngHypo2[n3] < cut3ProngInvMassCandMin[n3] || mass3ProngHypo2[n3] >= cut3ProngInvMassCandMax[n3])) { isSelected3ProngCand = isSelected3ProngCand & ~(1 << n3); - if (b_debug) { + if (debug) { cutStatus3Prong[n3][iDebugCut] = false; } } } } - if (!b_debug && isSelected3ProngCand == 0) { + if (!debug && isSelected3ProngCand == 0) { continue; } iDebugCut++; @@ -706,11 +705,11 @@ struct HFTrackIndexSkimsCreator { if (cand3ProngPt < cut3ProngPtCandMin[n3]) { isSelected3ProngCand = isSelected3ProngCand & ~(1 << n3); } - if (b_debug) { + if (debug) { cutStatus3Prong[n3][iDebugCut] = false; } } - if (!b_debug && isSelected3ProngCand == 0) { + if (!debug && isSelected3ProngCand == 0) { continue; //this and all further instances should be changed if 4 track loop is added } } @@ -723,11 +722,11 @@ struct HFTrackIndexSkimsCreator { if ((isSelected3ProngCand & 1 << n3) && cpa < cut3ProngCPACandMin[n3]) { isSelected3ProngCand = isSelected3ProngCand & ~(1 << n3); } - if (b_debug) { + if (debug) { cutStatus3Prong[n3][iDebugCut] = false; } } - if (!b_debug && isSelected3ProngCand == 0) { + if (!debug && isSelected3ProngCand == 0) { continue; } } @@ -739,12 +738,12 @@ struct HFTrackIndexSkimsCreator { for (int n3 = 0; n3 < n3ProngDecays; n3++) { if ((isSelected3ProngCand & 1 << n3) && decayLength < cut3ProngDecLenCandMin[n3]) { isSelected3ProngCand = isSelected3ProngCand & ~(1 << n3); - if (b_debug) { + if (debug) { cutStatus3Prong[n3][iDebugCut] = false; } } } - if (!b_debug && isSelected3ProngCand == 0) { + if (!debug && isSelected3ProngCand == 0) { continue; } } @@ -755,7 +754,7 @@ struct HFTrackIndexSkimsCreator { trackNeg1.globalIndex(), trackPos2.globalIndex(), isSelected3ProngCand); - if (b_debug) { + if (debug) { int Prong3CutStatus[n3ProngDecays]; for (int n3 = 0; n3 < n3ProngDecays; n3++) { Prong3CutStatus[n3] = nCutStatus3ProngBit; @@ -769,7 +768,7 @@ struct HFTrackIndexSkimsCreator { } // fill histograms - if (b_dovalplots) { + if (dovalplots) { registry.get(HIST("hvtx3_x"))->Fill(secondaryVertex3[0]); registry.get(HIST("hvtx3_y"))->Fill(secondaryVertex3[1]); @@ -821,7 +820,7 @@ struct HFTrackIndexSkimsCreator { int isSelected3ProngCand = n3ProngBit; - if (b_debug) { + if (debug) { for (int n3 = 0; n3 < n3ProngDecays; n3++) { for (int n3cut = 0; n3cut < nCuts3Prong; n3cut++) { cutStatus3Prong[n3][n3cut] = true; @@ -843,13 +842,13 @@ struct HFTrackIndexSkimsCreator { if ((mass3ProngHypo1[n3] < cut3ProngInvMassCandMin[n3] || mass3ProngHypo1[n3] >= cut3ProngInvMassCandMax[n3]) && (mass3ProngHypo2[n3] < cut3ProngInvMassCandMin[n3] || mass3ProngHypo2[n3] >= cut3ProngInvMassCandMax[n3])) { isSelected3ProngCand = isSelected3ProngCand & ~(1 << n3); - if (b_debug) { + if (debug) { cutStatus3Prong[n3][iDebugCut] = false; } } } } - if (!b_debug && isSelected3ProngCand == 0) { + if (!debug && isSelected3ProngCand == 0) { continue; } iDebugCut++; @@ -878,12 +877,12 @@ struct HFTrackIndexSkimsCreator { for (int n3 = 0; n3 < n3ProngDecays; n3++) { if (cand3ProngPt < cut3ProngPtCandMin[n3]) { isSelected3ProngCand = isSelected3ProngCand & ~(1 << n3); - if (b_debug) { + if (debug) { cutStatus3Prong[n3][iDebugCut] = false; } } } - if (!b_debug && isSelected3ProngCand == 0) { + if (!debug && isSelected3ProngCand == 0) { continue; } } @@ -895,12 +894,12 @@ struct HFTrackIndexSkimsCreator { for (int n3 = 0; n3 < n3ProngDecays; n3++) { if ((isSelected3ProngCand & 1 << n3) && cpa < cut3ProngCPACandMin[n3]) { isSelected3ProngCand = isSelected3ProngCand & ~(1 << n3); - if (b_debug) { + if (debug) { cutStatus3Prong[n3][iDebugCut] = false; } } } - if (!b_debug && isSelected3ProngCand == 0) { + if (!debug && isSelected3ProngCand == 0) { continue; } } @@ -912,12 +911,12 @@ struct HFTrackIndexSkimsCreator { for (int n3 = 0; n3 < n3ProngDecays; n3++) { if ((isSelected3ProngCand & 1 << n3) && decayLength < cut3ProngDecLenCandMin[n3]) { isSelected3ProngCand = isSelected3ProngCand & ~(1 << n3); - if (b_debug) { + if (debug) { cutStatus3Prong[n3][iDebugCut] = false; } } } - if (!b_debug && isSelected3ProngCand == 0) { + if (!debug && isSelected3ProngCand == 0) { continue; } } @@ -928,7 +927,7 @@ struct HFTrackIndexSkimsCreator { trackPos1.globalIndex(), trackNeg2.globalIndex(), isSelected3ProngCand); - if (b_debug) { + if (debug) { int Prong3CutStatus[n3ProngDecays]; for (int n3 = 0; n3 < n3ProngDecays; n3++) { Prong3CutStatus[n3] = nCutStatus3ProngBit; @@ -942,7 +941,7 @@ struct HFTrackIndexSkimsCreator { } // fill histograms - if (b_dovalplots) { + if (dovalplots) { registry.get(HIST("hvtx3_x"))->Fill(secondaryVertex3[0]); registry.get(HIST("hvtx3_y"))->Fill(secondaryVertex3[1]); @@ -1011,49 +1010,49 @@ struct HFTrackIndexSkimsCreatorCascades { // Produces rowTrackIndexCasc; // whether to do or not validation plots - Configurable b_doValPlots{"b_doValPlots", true, "fill histograms"}; + Configurable doValPlots{"doValPlots", true, "fill histograms"}; // event selection //Configurable triggerindex{"triggerindex", -1, "trigger index"}; // vertexing parameters - Configurable d_bZ{"d_bZ", 5., "magnetic field"}; - Configurable b_propDCA{"b_propDCA", true, "create tracks version propagated to PCA"}; - Configurable d_maxR{"d_maxR", 200., "reject PCA's above this radius"}; - Configurable d_maxDZIni{"d_maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; - Configurable d_minParamChange{"d_minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; - Configurable d_minRelChi2Change{"d_minRelChi2Change", 0.9, "stop iterations if chi2/chi2old > this"}; - Configurable d_UseAbsDCA{"d_UseAbsDCA", true, "Use Abs DCAs"}; + Configurable bZ{"bZ", 5., "magnetic field"}; + Configurable propDCA{"propDCA", true, "create tracks version propagated to PCA"}; + Configurable maxR{"maxR", 200., "reject PCA's above this radius"}; + Configurable maxDZIni{"maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"}; + Configurable minParamChange{"minParamChange", 1.e-3, "stop iterations if largest change of any X is smaller than this"}; + Configurable minRelChi2Change{"minRelChi2Change", 0.9, "stop iterations if chi2/chi2old > this"}; + Configurable UseAbsDCA{"UseAbsDCA", true, "Use Abs DCAs"}; // quality cut Configurable doCutQuality{"doCutQuality", true, "apply quality cuts"}; // track cuts for V0 daughters - Configurable b_TPCRefit{"b_TPCRefit", true, "request TPC refit V0 daughters"}; + Configurable TPCRefit{"TPCRefit", true, "request TPC refit V0 daughters"}; Configurable i_minCrossedRows{"i_minCrossedRows", 50, "min crossed rows V0 daughters"}; - Configurable d_etaMax{"d_etaMax", 1.1, "max. pseudorapidity V0 daughters"}; - Configurable d_ptMin{"d_ptMin", 0.05, "min. pT V0 daughters"}; + Configurable etaMax{"etaMax", 1.1, "max. pseudorapidity V0 daughters"}; + Configurable ptMin{"ptMin", 0.05, "min. pT V0 daughters"}; // bachelor cuts // Configurable dcabachtopv{"dcabachtopv", .1, "DCA Bach To PV"}; // Configurable ptminbach{"ptminbach", -1., "min. track pT bachelor"}; // v0 cuts - Configurable d_cosPAV0{"d_cosPAV0", .995, "CosPA V0"}; // as in the task that create the V0s - Configurable d_dcaXYNegToPV{"d_dcaXYNegToPV", .1, "DCA_XY Neg To PV"}; // check: in HF Run 2, it was 0 at filtering - Configurable d_dcaXYPosToPV{"d_dcaXYPosToPVS", .1, "DCA_XY Pos To PV"}; // check: in HF Run 2, it was 0 at filtering - Configurable d_cutInvMassV0{"d_cutInvMassV0", 0.05, "V0 candidate invariant mass difference wrt PDG"}; + Configurable cosPAV0{"cosPAV0", .995, "CosPA V0"}; // as in the task that create the V0s + Configurable dcaXYNegToPV{"dcaXYNegToPV", .1, "DCA_XY Neg To PV"}; // check: in HF Run 2, it was 0 at filtering + Configurable dcaXYPosToPV{"dcaXYPosToPVS", .1, "DCA_XY Pos To PV"}; // check: in HF Run 2, it was 0 at filtering + Configurable cutInvMassV0{"cutInvMassV0", 0.05, "V0 candidate invariant mass difference wrt PDG"}; // cascade cuts - Configurable d_cutCascPtCandMin{"d_cutCascPtCandMin", -1., "min. pT of the 2-prong candidate"}; // PbPb 2018: use 1 - Configurable d_cutCascInvMassLc{"d_cutCascInvMassLc", 1., "Lc candidate invariant mass difference wrt PDG"}; // for PbPb 2018: use 0.2 + Configurable cutCascPtCandMin{"cutCascPtCandMin", -1., "min. pT of the 2-prong candidate"}; // PbPb 2018: use 1 + Configurable cutCascInvMassLc{"cutCascInvMassLc", 1., "Lc candidate invariant mass difference wrt PDG"}; // for PbPb 2018: use 0.2 //Configurable cutCascDCADaughters{"cutCascDCADaughters", .1, "DCA between V0 and bachelor in cascade"}; // for debugging #ifdef MY_DEBUG - Configurable> v_labelK0Spos{"v_labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; - Configurable> v_labelK0Sneg{"v_labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; - Configurable> v_labelProton{"v_labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; + Configurable> labelK0Spos{"labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; + Configurable> labelK0Sneg{"labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; + Configurable> labelProton{"labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; #endif // histograms @@ -1072,7 +1071,7 @@ struct HFTrackIndexSkimsCreatorCascades { double massP = RecoDecay::getMassPDG(kProton); double massK0s = RecoDecay::getMassPDG(kK0Short); double massPi = RecoDecay::getMassPDG(kPiPlus); - double massLc = RecoDecay::getMassPDG(pdg::code::kLambdaCPlus); + double massLc = RecoDecay::getMassPDG(pdg::Code::kLambdaCPlus); double mass2K0sP{0.}; // WHY HERE? using FullTracksExt = soa::Join; @@ -1091,14 +1090,14 @@ struct HFTrackIndexSkimsCreatorCascades { //Define o2 fitter, 2-prong o2::vertexing::DCAFitterN<2> fitter; - fitter.setBz(d_bZ); - fitter.setPropagateToPCA(b_propDCA); - fitter.setMaxR(d_maxR); - fitter.setMinParamChange(d_minParamChange); - fitter.setMinRelChi2Change(d_minRelChi2Change); + fitter.setBz(bZ); + fitter.setPropagateToPCA(propDCA); + fitter.setMaxR(maxR); + fitter.setMinParamChange(minParamChange); + fitter.setMinRelChi2Change(minRelChi2Change); //fitter.setMaxDZIni(1e9); // used in cascadeproducer.cxx, but not for the 2 prongs //fitter.setMaxChi2(1e9); // used in cascadeproducer.cxx, but not for the 2 prongs - fitter.setUseAbsDCA(d_UseAbsDCA); + fitter.setUseAbsDCA(UseAbsDCA); // fist we loop over the bachelor candidate @@ -1108,7 +1107,7 @@ struct HFTrackIndexSkimsCreatorCascades { MY_DEBUG_MSG(1, printf("\n"); LOG(INFO) << "Bachelor loop"); #ifdef MY_DEBUG auto protonLabel = bach.mcParticleId(); - bool isProtonFromLc = isProtonFromLcFunc(protonLabel, v_labelProton); + bool isProtonFromLc = isProtonFromLcFunc(protonLabel, labelProton); #endif // selections on the bachelor // pT cut @@ -1117,7 +1116,7 @@ struct HFTrackIndexSkimsCreatorCascades { continue; } - if (b_TPCRefit) { + if (TPCRefit) { if (!(bach.trackType() & o2::aod::track::TPCrefit)) { MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << ": rejected due to TPCrefit"); continue; @@ -1139,9 +1138,9 @@ struct HFTrackIndexSkimsCreatorCascades { #ifdef MY_DEBUG auto labelPos = posTrack.mcParticleId(); auto labelNeg = negTrack.mcParticleId(); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, v_labelK0Spos, v_labelK0Sneg); + bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, labelK0Spos, labelK0Sneg); - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, v_labelProton, v_labelK0Spos, v_labelK0Sneg); + bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, labelProton, labelK0Spos, labelK0Sneg); #endif MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S from Lc found, posTrack --> " << labelPos << ", negTrack --> " << labelNeg); @@ -1152,7 +1151,7 @@ struct HFTrackIndexSkimsCreatorCascades { MY_DEBUG_MSG(isLc, LOG(INFO) << "Combination of K0S and p which correspond to a Lc found!"); - if (b_TPCRefit) { + if (TPCRefit) { if (!(posTrack.trackType() & o2::aod::track::TPCrefit) || !(negTrack.trackType() & o2::aod::track::TPCrefit)) { MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to TPCrefit"); @@ -1165,39 +1164,39 @@ struct HFTrackIndexSkimsCreatorCascades { continue; } // - // if (posTrack.dcaXY() < d_dcaXYPosToPV || // to the filters? - // negTrack.dcaXY() < d_dcaXYNegToPV) { + // if (posTrack.dcaXY() < dcaXYPosToPV || // to the filters? + // negTrack.dcaXY() < dcaXYNegToPV) { // continue; // } // - if (posTrack.pt() < d_ptMin || // to the filters? I can't for now, it is not in the tables - negTrack.pt() < d_ptMin) { - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to minPt --> pos " << posTrack.pt() << ", neg " << negTrack.pt() << " (cut " << d_ptMin << ")"); + if (posTrack.pt() < ptMin || // to the filters? I can't for now, it is not in the tables + negTrack.pt() < ptMin) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to minPt --> pos " << posTrack.pt() << ", neg " << negTrack.pt() << " (cut " << ptMin << ")"); continue; } - if (abs(posTrack.eta()) > d_etaMax || // to the filters? I can't for now, it is not in the tables - abs(negTrack.eta()) > d_etaMax) { - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to eta --> pos " << posTrack.eta() << ", neg " << negTrack.eta() << " (cut " << d_etaMax << ")"); + if (abs(posTrack.eta()) > etaMax || // to the filters? I can't for now, it is not in the tables + abs(negTrack.eta()) > etaMax) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to eta --> pos " << posTrack.eta() << ", neg " << negTrack.eta() << " (cut " << etaMax << ")"); continue; } // V0 invariant mass selection - if (std::abs(v0.mK0Short() - massK0s) > d_cutInvMassV0) { - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to invMass --> " << v0.mK0Short() - massK0s << " (cut " << d_cutInvMassV0 << ")"); + if (std::abs(v0.mK0Short() - massK0s) > cutInvMassV0) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to invMass --> " << v0.mK0Short() - massK0s << " (cut " << cutInvMassV0 << ")"); continue; // should go to the filter, but since it is a dynamic column, I cannot use it there } // V0 cosPointingAngle selection - if (v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < d_cosPAV0) { - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to cosPA --> " << v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) << " (cut " << d_cosPAV0 << ")"); + if (v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < cosPAV0) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to cosPA --> " << v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) << " (cut " << cosPAV0 << ")"); continue; } MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "KEPT! K0S from Lc with daughters " << labelPos << " and " << labelNeg); auto posTrackParCov = getTrackParCov(posTrack); - posTrackParCov.propagateTo(v0.posX(), d_bZ); // propagate the track to the X closest to the V0 vertex + posTrackParCov.propagateTo(v0.posX(), bZ); // propagate the track to the X closest to the V0 vertex auto negTrackParCov = getTrackParCov(negTrack); - negTrackParCov.propagateTo(v0.negX(), d_bZ); // propagate the track to the X closest to the V0 vertex + negTrackParCov.propagateTo(v0.negX(), bZ); // propagate the track to the X closest to the V0 vertex std::array pVecV0 = {0., 0., 0.}; std::array pVecBach = {0., 0., 0.}; @@ -1224,8 +1223,8 @@ struct HFTrackIndexSkimsCreatorCascades { pVecBach[2] + pVecV0[2]}; // cascade candidate pT cut - if (RecoDecay::Pt(pVecCandCasc) < d_cutCascPtCandMin) { - MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to pt cut: " << RecoDecay::Pt(pVecCandCasc) << " (cut " << d_cutCascPtCandMin << ")"); + if (RecoDecay::Pt(pVecCandCasc) < cutCascPtCandMin) { + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to pt cut: " << RecoDecay::Pt(pVecCandCasc) << " (cut " << cutCascPtCandMin << ")"); continue; } @@ -1234,8 +1233,8 @@ struct HFTrackIndexSkimsCreatorCascades { auto arrMom = array{pVecBach, pVecV0}; mass2K0sP = RecoDecay::M(arrMom, array{massP, massK0s}); // invariant-mass cut - if ((d_cutCascInvMassLc >= 0.) && (std::abs(mass2K0sP - massLc) > d_cutCascInvMassLc)) { - MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to invMass cut: " << mass2K0sP << ", mass Lc " << massLc << " (cut " << d_cutCascInvMassLc << ")"); + if ((cutCascInvMassLc >= 0.) && (std::abs(mass2K0sP - massLc) > cutCascInvMassLc)) { + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to invMass cut: " << mass2K0sP << ", mass Lc " << massLc << " (cut " << cutCascInvMassLc << ")"); continue; } @@ -1250,7 +1249,7 @@ struct HFTrackIndexSkimsCreatorCascades { v0.globalIndex(), 1); // 1 should be the value for the Lc // fill histograms - if (b_doValPlots) { + if (doValPlots) { MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc && isLc, LOG(INFO) << "KEPT! True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg); registry.get(HIST("hvtx2_x"))->Fill(posCasc[0]); registry.get(HIST("hvtx2_y"))->Fill(posCasc[1]); diff --git a/Analysis/Tasks/PWGHF/taskLcK0sP.cxx b/Analysis/Tasks/PWGHF/taskLcK0sP.cxx index 2949ca242f477..237461d281c4e 100644 --- a/Analysis/Tasks/PWGHF/taskLcK0sP.cxx +++ b/Analysis/Tasks/PWGHF/taskLcK0sP.cxx @@ -9,7 +9,7 @@ // or submit itself to any jurisdiction. /// \file taskLcK0sp.cxx -/// \brief LcK0sp analysis task +/// \brief Lc -> K0S+p analysis task /// /// \author Chiara Zampolli, , CERN /// @@ -19,13 +19,11 @@ #include "Framework/HistogramRegistry.h" #include "AnalysisDataModel/HFSecondaryVertex.h" #include "AnalysisDataModel/HFCandidateSelectionTables.h" -#include "AnalysisCore/HFSelectorCuts.h" using namespace o2; using namespace o2::framework; using namespace o2::aod::hf_cand_casc; using namespace o2::framework::expressions; -using namespace o2::analysis; void customize(std::vector& workflowOptions) { @@ -39,21 +37,21 @@ void customize(std::vector& workflowOptions) struct TaskLcK0sP { HistogramRegistry registry{ "registry", - {{"hmass", "cascade candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0.0f, 5.0f}}}}, - {"hptcand", "cascade candidates;candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}}, - {"hptbach", "cascade candidates;bachelor #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}}, - {"hptv0", "cascade candidates;v0 #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}}, - {"hd0bach", "cascade candidates;bachelor DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -1.0f, 1.0f}}}}, - {"hd0v0pos", "cascade candidates;pos daugh v0 DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -5.0f, 5.0f}}}}, - {"hd0v0neg", "cascade candidates;neg daugh v0 DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -5.0f, 5.0f}}}}, - {"hv0CPA", "cascade candidates;v0 cosine of pointing angle;entries", {HistType::kTH1F, {{110, -0.98f, 1.1f}}}}, + {{"hMass", "cascade candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{500, 0.0f, 5.0f}}}}, + {"hPtCand", "cascade candidates;candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}}, + {"hPtBach", "cascade candidates;bachelor #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}}, + {"hPtV0", "cascade candidates;v0 #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0.0f, 10.0f}}}}, + {"hd0Bach", "cascade candidates;bachelor DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -1.0f, 1.0f}}}}, + {"hd0V0pos", "cascade candidates;pos daugh v0 DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -5.0f, 5.0f}}}}, + {"hd0V0neg", "cascade candidates;neg daugh v0 DCAxy to prim. vertex (cm);entries", {HistType::kTH1F, {{100, -5.0f, 5.0f}}}}, + {"hV0CPA", "cascade candidates;v0 cosine of pointing angle;entries", {HistType::kTH1F, {{110, -0.98f, 1.1f}}}}, {"hEta", "cascade candidates;candidate #it{#eta};entries", {HistType::kTH1F, {{100, -2.0f, 2.0f}}}}, - {"hselectionstatus", "cascade candidates;selection status;entries", {HistType::kTH1F, {{5, -0.5f, 4.5f}}}}}}; + {"hSelectionStatus", "cascade candidates;selection status;entries", {HistType::kTH1F, {{5, -0.5f, 4.5f}}}}}}; - Configurable d_selectionFlagLcK0sp{"d_selectionFlagLcK0sp", 1, "Selection Flag for LcK0sp"}; + Configurable selectionFlagLcK0sp{"selectionFlagLcK0sp", 1, "Selection Flag for LcK0sp"}; Configurable cutEtaCandMax{"cutEtaCandMax", -1., "max. cand. pseudorapidity"}; - Filter filterSelectCandidates = (aod::hf_selcandidate_lc_k0sp::isSelLcK0sP >= d_selectionFlagLcK0sp); + Filter filterSelectCandidates = (aod::hf_selcandidate_lc_k0sp::isSelLcK0sP >= selectionFlagLcK0sp); void process(soa::Filtered> const& candidates) { @@ -70,16 +68,16 @@ struct TaskLcK0sP { continue; } - registry.fill(HIST("hmass"), InvMassLcToK0sP(candidate)); - registry.fill(HIST("hptcand"), candidate.pt()); - registry.fill(HIST("hptbach"), candidate.ptProng0()); - registry.fill(HIST("hptv0"), candidate.ptProng1()); - registry.fill(HIST("hd0bach"), candidate.impactParameter0()); - registry.fill(HIST("hd0v0pos"), candidate.dcapostopv()); - registry.fill(HIST("hd0v0neg"), candidate.dcanegtopv()); - registry.fill(HIST("hv0CPA"), candidate.v0cosPA()); + registry.fill(HIST("hMass"), InvMassLcToK0sP(candidate)); + registry.fill(HIST("hPtCand"), candidate.pt()); + registry.fill(HIST("hPtBach"), candidate.ptProng0()); + registry.fill(HIST("hPtV0"), candidate.ptProng1()); + registry.fill(HIST("hd0Bach"), candidate.impactParameter0()); + registry.fill(HIST("hd0V0pos"), candidate.dcapostopv()); + registry.fill(HIST("hd0V0neg"), candidate.dcanegtopv()); + registry.fill(HIST("hV0CPA"), candidate.v0cosPA()); registry.fill(HIST("hEta"), candidate.eta()); - registry.fill(HIST("hselectionstatus"), candidate.isSelLcK0sP()); + registry.fill(HIST("hSelectionStatus"), candidate.isSelLcK0sP()); } } }; @@ -88,21 +86,21 @@ struct TaskLcK0sP { struct TaskLcK0SpMC { HistogramRegistry registry{ "registry", - {{"hPtRecSig", "cascade candidates (matched);#it{p}_{T}^{rec.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {{"hPtRecSig", "cascade candidates (MC);#it{p}_{T}^{rec.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, {"hPtRecBg", "cascade candidates (unmatched);#it{p}_{T}^{rec.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, - {"hPtGen", "cascade (matched);#it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, - {"hPtGenSig", "cascade candidates (matched);#it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hPtGen", "cascade (MC);#it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, + {"hPtGenSig", "cascade candidates (MC);#it{p}_{T}^{gen.} (GeV/#it{c});entries", {HistType::kTH1F, {{100, 0., 10.}}}}, {"hCPARecSig", "cascade candidates (matched);cosine of pointing angle;entries", {HistType::kTH1F, {{110, -1.1, 1.1}}}}, {"hCPARecBg", "cascade candidates (unmatched);cosine of pointing angle;entries", {HistType::kTH1F, {{110, -1.1, 1.1}}}}, {"hEtaRecSig", "cascade candidates (matched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}, {"hEtaRecBg", "cascade candidates (unmatched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}, - {"hEtaGen", "MC particles (matched);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}}}; + {"hEtaGen", "MC particles (MC);#it{#eta};entries", {HistType::kTH1F, {{100, -2., 2.}}}}}}; - Configurable d_selectionFlagLc{"d_selectionFlagLc", 1, "Selection Flag for Lc"}; - Configurable d_selectionFlagLcbar{"d_selectionFlagLcbar", 1, "Selection Flag for Lcbar"}; + Configurable selectionFlagLc{"selectionFlagLc", 1, "Selection Flag for Lc"}; + Configurable selectionFlagLcbar{"selectionFlagLcbar", 1, "Selection Flag for Lcbar"}; Configurable cutEtaCandMax{"cutEtaCandMax", -1., "max. cand. pseudorapidity"}; - Filter filterSelectCandidates = (aod::hf_selcandidate_lc_k0sp::isSelLcK0sP >= d_selectionFlagLc || aod::hf_selcandidate_lc_k0sp::isSelLcK0sP >= d_selectionFlagLcbar); + Filter filterSelectCandidates = (aod::hf_selcandidate_lc_k0sp::isSelLcK0sP >= selectionFlagLc || aod::hf_selcandidate_lc_k0sp::isSelLcK0sP >= selectionFlagLcbar); void process(soa::Filtered> const& candidates, soa::Join const& particlesMC, aod::BigTracksMC const& tracks) @@ -116,7 +114,7 @@ struct TaskLcK0SpMC { } if (std::abs(candidate.flagMCMatchRec()) == 1) { // Get the corresponding MC particle. - auto indexMother = RecoDecay::getMother(particlesMC, candidate.index0_as().mcParticle_as>(), pdg::code::kLambdaCPlus, true); + auto indexMother = RecoDecay::getMother(particlesMC, candidate.index0_as().mcParticle_as>(), pdg::Code::kLambdaCPlus, true); auto particleMother = particlesMC.iteratorAt(indexMother); registry.fill(HIST("hPtGenSig"), particleMother.pt()); // gen. level pT registry.fill(HIST("hPtRecSig"), candidate.pt()); // rec. level pT From 93f995624be8fee89d025aebac6fa23f5b69c996 Mon Sep 17 00:00:00 2001 From: Chiara Zampolli Date: Wed, 5 May 2021 00:48:51 +0200 Subject: [PATCH 14/14] Further comments implemented clang-format leftovers fixed Clang-format Few more Clang-format removing useless namespace declaration Optimization more clang-format typo Remove commented out code --- .../AnalysisDataModel/HFSecondaryVertex.h | 3 +- .../Tasks/PWGHF/HFCandidateCreatorCascade.cxx | 71 ++++---- .../Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx | 36 ++-- .../Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx | 161 +++++++++--------- Analysis/Tasks/PWGLF/CMakeLists.txt | 2 +- .../AnalysisTasksUtils/UtilsDebugLcK0Sp.h | 8 - 6 files changed, 133 insertions(+), 148 deletions(-) diff --git a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h index 64d0583c33ab6..e8b6566021563 100644 --- a/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h +++ b/Analysis/DataModel/include/AnalysisDataModel/HFSecondaryVertex.h @@ -44,7 +44,6 @@ using BigTracksMC = soa::Join; using BigTracksPID = soa::Join; -using V0Datas = aod::V0Datas; // FIXME: this is a workaround until we get the index columns to work with joins. @@ -54,7 +53,7 @@ DECLARE_SOA_INDEX_COLUMN_FULL(Index0, index0, int, Tracks, "_0"); //! DECLARE_SOA_INDEX_COLUMN_FULL(Index1, index1, int, Tracks, "_1"); //! DECLARE_SOA_INDEX_COLUMN_FULL(Index2, index2, int, Tracks, "_2"); //! DECLARE_SOA_INDEX_COLUMN_FULL(Index3, index3, int, Tracks, "_3"); //! -DECLARE_SOA_INDEX_COLUMN_FULL(IndexV0, indexV0, int, V0Datas, "_V0"); //! +DECLARE_SOA_INDEX_COLUMN_FULL(IndexV0, indexV0, int, aod::V0Datas, "_V0"); //! DECLARE_SOA_COLUMN(HFflag, hfflag, uint8_t); //! DECLARE_SOA_COLUMN(D0ToKPiFlag, d0ToKPiFlag, uint8_t); //! diff --git a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx index 322e84afd4695..951de55a845f2 100644 --- a/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx +++ b/Analysis/Tasks/PWGHF/HFCandidateCreatorCascade.cxx @@ -60,9 +60,9 @@ struct HFCandidateCreatorCascade { // for debugging #ifdef MY_DEBUG - Configurable> labelK0Spos{"labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; - Configurable> labelK0Sneg{"labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; - Configurable> labelProton{"labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; + Configurable> indexK0Spos{"indexK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "indices of K0S positive daughters, for debug"}; + Configurable> indexK0Sneg{"indexK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "indices of K0S negative daughters, for debug"}; + Configurable> indexProton{"indexProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "indices of protons, for debug"}; #endif OutputObj hmass2{TH1F("hmass2", "2-prong candidates;inv. mass (#pi K) (GeV/#it{c}^{2});entries", 500, 0., 5.)}; @@ -99,28 +99,28 @@ struct HFCandidateCreatorCascade { for (const auto& casc : rowsTrackIndexCasc) { const auto& bach = casc.index0_as(); - auto trackParCovBach = getTrackParCov(bach); const auto& v0 = casc.indexV0_as(); - const auto& posTrack = v0.posTrack_as(); - const auto& negTrack = v0.negTrack_as(); + const auto& trackV0DaughPos = v0.posTrack_as(); + const auto& trackV0DaughNeg = v0.negTrack_as(); #ifdef MY_DEBUG - auto protonLabel = bach.mcParticleId(); - auto labelPos = posTrack.mcParticleId(); - auto labelNeg = negTrack.mcParticleId(); - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, labelProton, labelK0Spos, labelK0Sneg); + auto indexBach = bach.mcParticleId(); + auto indexV0DaughPos = trackV0DaughPos.mcParticleId(); + auto indexV0DaughNeg = trackV0DaughNeg.mcParticleId(); + bool isLc = isLcK0SpFunc(indexBach, indexV0DaughPos, indexV0DaughNeg, indexProton, indexK0Spos, indexK0Sneg); #endif - MY_DEBUG_MSG(isLc, LOG(INFO) << "Processing the Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg); + MY_DEBUG_MSG(isLc, LOG(INFO) << "Processing the Lc with proton " << indexBach << " trackV0DaughPos " << indexV0DaughPos << " trackV0DaughNeg " << indexV0DaughNeg); - auto posTrackParCov = getTrackParCov(posTrack); // check that MyBigTracks does not need TracksExtended! - auto negTrackParCov = getTrackParCov(negTrack); // check that MyBigTracks does not need TracksExtended! - posTrackParCov.propagateTo(v0.posX(), bZ); // propagate the track to the X closest to the V0 vertex - negTrackParCov.propagateTo(v0.negX(), bZ); // propagate the track to the X closest to the V0 vertex + auto trackParCovBach = getTrackParCov(bach); + auto trackParCovV0DaughPos = getTrackParCov(trackV0DaughPos); // check that MyBigTracks does not need TracksExtended! + auto trackParCovV0DaughNeg = getTrackParCov(trackV0DaughNeg); // check that MyBigTracks does not need TracksExtended! + trackParCovV0DaughPos.propagateTo(v0.posX(), bZ); // propagate the track to the X closest to the V0 vertex + trackParCovV0DaughNeg.propagateTo(v0.negX(), bZ); // propagate the track to the X closest to the V0 vertex const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; // we build the neutral track to then build the cascade - auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, {0, 0, 0, 0, 0, 0}, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track (indices for v0 daughters set to 0 for now) + auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, {0, 0, 0, 0, 0, 0}, trackParCovV0DaughPos, trackParCovV0DaughNeg, {0, 0}, {0, 0}); // build the V0 track (indices for v0 daughters set to 0 for now) auto collision = bach.collision(); @@ -128,7 +128,7 @@ struct HFCandidateCreatorCascade { if (df.process(trackV0, trackParCovBach) == 0) { MY_DEBUG_MSG(isLc, LOG(INFO) << "Vertexing failed for Lc candidate"); // if (isLc) { - // LOG(INFO) << "Vertexing failed for Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg; + // LOG(INFO) << "Vertexing failed for Lc with proton " << indexBach << " trackV0DaughPos " << indexV0DaughPos << " trackV0DaughNeg " << indexV0DaughNeg; //} continue; } else { @@ -166,7 +166,7 @@ struct HFCandidateCreatorCascade { auto errorDecayLengthXY = std::sqrt(getRotatedCovMatrixXX(covMatrixPV, phi, 0.) + getRotatedCovMatrixXX(covMatrixPCA, phi, 0.)); // fill candidate table rows - MY_DEBUG_MSG(isLc, LOG(INFO) << "IT IS A Lc! Filling for Lc with proton " << protonLabel << " posTrack " << labelPos << " negTrack " << labelNeg); + MY_DEBUG_MSG(isLc, LOG(INFO) << "IT IS A Lc! Filling for Lc with proton " << indexBach << " trackV0DaughPos " << indexV0DaughPos << " trackV0DaughNeg " << indexV0DaughNeg); rowCandidateBase(collision.globalIndex(), collision.posX(), collision.posY(), collision.posZ(), secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], @@ -180,7 +180,7 @@ struct HFCandidateCreatorCascade { casc.hfflag(), v0.x(), v0.y(), v0.z(), //v0.posTrack(), v0.negTrack(), // why this was not fine? - v0.posTrack_as().globalIndex(), v0.negTrack_as().globalIndex(), + trackV0DaughPos.globalIndex(), trackV0DaughNeg.globalIndex(), v0.pxpos(), v0.pypos(), v0.pzpos(), v0.pxneg(), v0.pyneg(), v0.pzneg(), v0.dcaV0daughters(), @@ -190,8 +190,7 @@ struct HFCandidateCreatorCascade { // fill histograms if (doValPlots) { // calculate invariant masses - auto arrayMomenta = array{pVecBach, pVecV0}; - mass2K0sP = RecoDecay::M(arrayMomenta, array{massP, massK0s}); + mass2K0sP = RecoDecay::M(array{pVecBach, pVecV0}, array{massP, massK0s}); hmass2->Fill(mass2K0sP); } } @@ -212,9 +211,9 @@ struct HFCandidateCreatorCascadeMC { Produces rowMCMatchGen; #ifdef MY_DEBUG - Configurable> labelK0Spos{"labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; - Configurable> labelK0Sneg{"labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; - Configurable> labelProton{"labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; + Configurable> indexK0Spos{"indexK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "indices of K0S positive daughters, for debug"}; + Configurable> indexK0Sneg{"indexK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "indices of K0S negative daughters, for debug"}; + Configurable> indexProton{"indexProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "indices of protons, for debug"}; #endif void process(aod::HfCandCascade const& candidates, @@ -228,22 +227,27 @@ struct HFCandidateCreatorCascadeMC { // Match reconstructed candidates. for (auto& candidate : candidates) { - auto arrayDaughtersV0 = array{candidate.posTrack_as(), candidate.negTrack_as()}; - auto arrayDaughtersLc = array{candidate.index0_as(), candidate.posTrack_as(), candidate.negTrack_as()}; + + const auto& bach = candidate.index0_as(); + const auto& trackV0DaughPos = candidate.posTrack_as(); + const auto& trackV0DaughNeg = candidate.negTrack_as(); + + auto arrayDaughtersV0 = array{trackV0DaughPos, trackV0DaughNeg}; + auto arrayDaughtersLc = array{bach, trackV0DaughPos, trackV0DaughNeg}; // First we check the K0s LOG(DEBUG) << "\n"; LOG(DEBUG) << "Checking MC for candidate!"; LOG(DEBUG) << "Looking for K0s"; - auto labelPos = candidate.posTrack_as().mcParticleId(); - auto labelNeg = candidate.negTrack_as().mcParticleId(); - auto protonLabel = candidate.index0_as().mcParticleId(); + auto indexV0DaughPos = trackV0DaughPos.mcParticleId(); + auto indexV0DaughNeg = trackV0DaughNeg.mcParticleId(); + auto indexBach = bach.mcParticleId(); #ifdef MY_DEBUG - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, labelProton, labelK0Spos, labelK0Sneg); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, labelK0Spos, labelK0Sneg); + bool isLc = isLcK0SpFunc(indexBach, indexV0DaughPos, indexV0DaughNeg, indexProton, indexK0Spos, indexK0Sneg); + bool isK0SfromLc = isK0SfromLcFunc(indexV0DaughPos, indexV0DaughNeg, indexK0Spos, indexK0Sneg); #endif - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "correct K0S in the Lc daughters: posTrack --> " << labelPos << ", negTrack --> " << labelNeg); + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "correct K0S in the Lc daughters: posTrack --> " << indexV0DaughPos << ", negTrack --> " << indexV0DaughNeg); //if (isLc) { RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersV0, kK0Short, array{+kPiPlus, -kPiPlus}, true, &sign, 1); // does it matter the "acceptAntiParticle" in the K0s case? In principle, there is no anti-K0s @@ -251,8 +255,7 @@ struct HFCandidateCreatorCascadeMC { if (sign != 0) { // we have already positively checked the K0s // then we check the Lc MY_DEBUG_MSG(sign, LOG(INFO) << "K0S was correct! now we check the Lc"); - auto labelProton = candidate.index0_as().mcParticleId(); - MY_DEBUG_MSG(sign, LOG(INFO) << "label proton = " << labelProton); + MY_DEBUG_MSG(sign, LOG(INFO) << "index proton = " << indexBach); RecoDecay::getMatchedMCRec(particlesMC, arrayDaughtersLc, pdg::Code::kLambdaCPlus, array{+kProton, +kPiPlus, -kPiPlus}, true, &sign, 3); // 3-levels Lc --> p + K0 --> p + K0s --> p + pi+ pi- MY_DEBUG_MSG(sign, LOG(INFO) << "Lc found with sign " << sign; printf("\n")); } diff --git a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx index f0a40c2361331..b7b80669065e0 100644 --- a/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx +++ b/Analysis/Tasks/PWGHF/HFLcK0sPCandidateSelector.cxx @@ -72,9 +72,9 @@ struct HFLcK0sPCandidateSelector { // for debugging #ifdef MY_DEBUG - Configurable> labelK0Spos{"labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; - Configurable> labelK0Sneg{"labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; - Configurable> labelProton{"labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; + Configurable> indexK0Spos{"indexK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "indices of K0S positive daughters, for debug"}; + Configurable> indexK0Sneg{"indexK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "indices of K0S negative daughters, for debug"}; + Configurable> indexProton{"indexProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "indices of protons, for debug"}; #endif /// Gets corresponding pT bin from cut file array @@ -102,14 +102,9 @@ struct HFLcK0sPCandidateSelector { /// \param track is daughter track /// \return true if track is good template - bool daughterSelection(const T& track) // aren't these checks already in the indexskimscreator? + bool daughterSelection(const T& track) // there could be more checks done on the bachelor here { - if (track.sign() == 0) { - return false; - } - if (requireTPC.value && track.tpcNClsFound() == 0) { - return false; //is it clusters findable or found - need to check - } + // this is for now just a placeholder, in case we want to add extra checks return true; } @@ -206,7 +201,7 @@ struct HFLcK0sPCandidateSelector { template bool applyTPCPID(const T& track) { - if (TMath::Abs(track.pt()) < applyPidTPCMinPt) { + if (track.pt() < applyPidTPCMinPt) { LOG(DEBUG) << "Bachelor pt is " << track.pt() << ", we apply TPC PID from " << applyPidTPCMinPt; return false; } @@ -221,7 +216,7 @@ struct HFLcK0sPCandidateSelector { template bool validCombPID(const T& track) { - if (TMath::Abs(track.pt()) > pidCombMaxP) { // is the pt sign used for the charge? If it is always positive, we should remove the abs + if (track.pt() > pidCombMaxP) { // is the pt sign used for the charge? If it is always positive, we should remove the abs return false; } return true; @@ -337,15 +332,16 @@ struct HFLcK0sPCandidateSelector { for (auto& candidate : candidates) { //looping over cascade candidates + const auto& bach = candidate.index0_as(); //bachelor track #ifdef MY_DEBUG - auto labelPos = candidate.posTrack_as().mcParticleId(); - auto labelNeg = candidate.negTrack_as().mcParticleId(); - auto protonLabel = candidate.index0_as().mcParticleId(); - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, labelProton, labelK0Spos, labelK0Sneg); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, labelK0Spos, labelK0Sneg); + auto indexV0DaughPos = candidate.posTrack_as().mcParticleId(); + auto indexV0DaughNeg = candidate.negTrack_as().mcParticleId(); + auto indexBach = bach.mcParticleId(); + bool isLc = isLcK0SpFunc(indexBach, indexV0DaughPos, indexV0DaughNeg, indexProton, indexK0Spos, indexK0Sneg); + bool isK0SfromLc = isK0SfromLcFunc(indexV0DaughPos, indexV0DaughNeg, indexK0Spos, indexK0Sneg); #endif - MY_DEBUG_MSG(isLc, printf("\n"); LOG(INFO) << "In selector: correct Lc found: proton --> " << protonLabel << ", posTrack --> " << labelPos << ", negTrack --> " << labelNeg); - //MY_DEBUG_MSG(isLc != 1, printf("\n"); LOG(INFO) << "In selector: wrong Lc found: proton --> " << protonLabel << ", posTrack --> " << labelPos << ", negTrack --> " << labelNeg); + MY_DEBUG_MSG(isLc, printf("\n"); LOG(INFO) << "In selector: correct Lc found: proton --> " << indexBach << ", posTrack --> " << indexV0DaughPos << ", negTrack --> " << indexV0DaughNeg); + //MY_DEBUG_MSG(isLc != 1, printf("\n"); LOG(INFO) << "In selector: wrong Lc found: proton --> " << indexBach << ", posTrack --> " << indexV0DaughPos << ", negTrack --> " << indexV0DaughNeg); statusLc = 0; /* // not needed for the Lc @@ -355,8 +351,6 @@ struct HFLcK0sPCandidateSelector { } */ - const auto& bach = candidate.index0_as(); //bachelor track - topolLc = true; pidProton = -1; diff --git a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx index b83744b78a659..a2684c9e08cf3 100644 --- a/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx +++ b/Analysis/Tasks/PWGHF/HFTrackIndexSkimsCreator.cxx @@ -26,7 +26,6 @@ #include "AnalysisDataModel/TrackSelectionTables.h" #include "ReconstructionDataFormats/V0.h" #include "AnalysisTasksUtils/UtilsDebugLcK0Sp.h" -#include "AnalysisCore/HFSelectorCuts.h" #include @@ -34,7 +33,6 @@ using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; using namespace o2::aod; -using namespace o2::analysis; using namespace o2::analysis::hf_cuts_single_track; void customize(std::vector& workflowOptions) @@ -95,9 +93,9 @@ struct SelectTracks { // for debugging #ifdef MY_DEBUG - Configurable> labelK0Spos{"labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; - Configurable> labelK0Sneg{"labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; - Configurable> labelProton{"labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; + Configurable> indexK0Spos{"indexK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "indices of K0S positive daughters, for debug"}; + Configurable> indexK0Sneg{"indexK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "indices of K0S negative daughters, for debug"}; + Configurable> indexProton{"indexProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "indices of protons, for debug"}; #endif HistogramRegistry registry{ @@ -138,10 +136,10 @@ struct SelectTracks { return false; } - if (abs(dca[0]) < cutsSingleTrack[candType].get(pTBinTrack, "min_dcaxytoprimary")) { + if (std::abs(dca[0]) < cutsSingleTrack[candType].get(pTBinTrack, "min_dcaxytoprimary")) { return false; //minimum DCAxy } - if (abs(dca[0]) > cutsSingleTrack[candType].get(pTBinTrack, "max_dcaxytoprimary")) { + if (std::abs(dca[0]) > cutsSingleTrack[candType].get(pTBinTrack, "max_dcaxytoprimary")) { return false; //maximum DCAxy } return true; @@ -159,13 +157,13 @@ struct SelectTracks { for (auto& track : tracks) { #ifdef MY_DEBUG - auto protonLabel = track.mcParticleId(); - // LOG(INFO) << "Checking label " << protonLabel; - bool isProtonFromLc = isProtonFromLcFunc(protonLabel, labelProton); + auto indexBach = track.mcParticleId(); + // LOG(INFO) << "Checking label " << indexBach; + bool isProtonFromLc = isProtonFromLcFunc(indexBach, indexProton); #endif - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "\nWe found the proton " << protonLabel); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "\nWe found the proton " << indexBach); int status_prong = 7; // selection flag , 3 bits on @@ -181,7 +179,7 @@ struct SelectTracks { if (trackPt < ptmintrack_3prong) { status_prong = status_prong & ~(1 << 1); } - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " pt = " << track.pt() << " (cut " << ptMinTrackBach << ")"); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << indexBach << " pt = " << track.pt() << " (cut " << ptMinTrackBach << ")"); if (track.pt() < ptMinTrackBach) { status_prong = status_prong & ~(1 << 2); @@ -189,20 +187,20 @@ struct SelectTracks { auto trackEta = track.eta(); // eta cut - if ((status_prong & (1 << 0)) && abs(trackEta) > etamax_2prong) { + if ((status_prong & (1 << 0)) && std::abs(trackEta) > etamax_2prong) { status_prong = status_prong & ~(1 << 0); } - if ((status_prong & (1 << 1)) && abs(trackEta) > etamax_3prong) { + if ((status_prong & (1 << 1)) && std::abs(trackEta) > etamax_3prong) { status_prong = status_prong & ~(1 << 1); } - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " eta = " << track.eta() << " (cut " << etaMaxBach << ")"); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << indexBach << " eta = " << trackEta << " (cut " << etaMaxBach << ")"); - if ((status_prong & (1 << 2)) && abs(track.eta()) > etaMaxBach) { + if ((status_prong & (1 << 2)) && std::abs(trackEta) > etaMaxBach) { status_prong = status_prong & ~(1 << 2); } // quality cut - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " tpcNClsFound = " << track.tpcNClsFound() << " (cut " << tpcnclsfound.value << ")"); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << indexBach << " tpcNClsFound = " << track.tpcNClsFound() << " (cut " << tpcnclsfound.value << ")"); if (doCutQuality.value && status_prong > 0) { // FIXME to make a more complete selection e.g track.flags() & o2::aod::track::TPCrefit && track.flags() & o2::aod::track::GoldenChi2 && UChar_t clustermap = track.itsClusterMap(); @@ -210,7 +208,7 @@ struct SelectTracks { track.flags() & o2::aod::track::ITSrefit && (TESTBIT(clustermap, 0) || TESTBIT(clustermap, 1)))) { status_prong = 0; - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << " did not pass clusters cut"); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << indexBach << " did not pass clusters cut"); } } @@ -228,9 +226,9 @@ struct SelectTracks { if ((status_prong & (1 << 1)) && !isSelectedTrack(track, dca, Cand3Prong)) { status_prong = status_prong & ~(1 << 1); } - if ((status_prong & (1 << 2)) && (abs(dca[0]) < dcaToPrimXYMinBach_ptDep || abs(dca[0]) > dcaToPrimXYMaxBach)) { + if ((status_prong & (1 << 2)) && (std::abs(dca[0]) < dcaToPrimXYMinBach_ptDep || std::abs(dca[0]) > dcaToPrimXYMaxBach)) { MY_DEBUG_MSG(isProtonFromLc, - LOG(INFO) << "proton " << protonLabel << " did not pass DCA cut"; + LOG(INFO) << "proton " << indexBach << " did not pass DCA cut"; LOG(INFO) << "dca[0] = " << dca[0] << " (lower cut " << dcaToPrimXYMinBach_ptDep << ", upper cut " << dcaToPrimXYMaxBach << ")";); status_prong = status_prong & ~(1 << 2); } @@ -250,7 +248,7 @@ struct SelectTracks { registry.get(HIST("heta_cuts_3prong"))->Fill(trackEta); } if (status_prong & (1 << 2)) { - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "Will be kept: Proton from Lc " << protonLabel); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "Will be kept: Proton from Lc " << indexBach); registry.get(HIST("hpt_cuts_bach"))->Fill(trackPt); registry.get(HIST("hdcatoprimxy_cuts_bach"))->Fill(dca[0]); registry.get(HIST("heta_cuts_bach"))->Fill(trackEta); @@ -1050,9 +1048,9 @@ struct HFTrackIndexSkimsCreatorCascades { // for debugging #ifdef MY_DEBUG - Configurable> labelK0Spos{"labelK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "labels of K0S positive daughters, for debug"}; - Configurable> labelK0Sneg{"labelK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "labels of K0S negative daughters, for debug"}; - Configurable> labelProton{"labelProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "labels of protons, for debug"}; + Configurable> indexK0Spos{"indexK0Spos", {729, 2866, 4754, 5457, 6891, 7824, 9243, 9810}, "indices of K0S positive daughters, for debug"}; + Configurable> indexK0Sneg{"indexK0Sneg", {730, 2867, 4755, 5458, 6892, 7825, 9244, 9811}, "indices of K0S negative daughters, for debug"}; + Configurable> indexProton{"indexProton", {717, 2810, 4393, 5442, 6769, 7793, 9002, 9789}, "indices of protons, for debug"}; #endif // histograms @@ -1106,137 +1104,136 @@ struct HFTrackIndexSkimsCreatorCascades { MY_DEBUG_MSG(1, printf("\n"); LOG(INFO) << "Bachelor loop"); #ifdef MY_DEBUG - auto protonLabel = bach.mcParticleId(); - bool isProtonFromLc = isProtonFromLcFunc(protonLabel, labelProton); + auto indexBach = bach.mcParticleId(); + bool isProtonFromLc = isProtonFromLcFunc(indexBach, indexProton); #endif // selections on the bachelor // pT cut if (bach.isSelProng() < 4) { - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << ": rejected due to HFsel"); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << indexBach << ": rejected due to HFsel"); continue; } if (TPCRefit) { if (!(bach.trackType() & o2::aod::track::TPCrefit)) { - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << ": rejected due to TPCrefit"); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << indexBach << ": rejected due to TPCrefit"); continue; } } if (bach.tpcNClsCrossedRows() < i_minCrossedRows) { - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << protonLabel << ": rejected due to minNUmberOfCrossedRows " << bach.tpcNClsCrossedRows() << " (cut " << i_minCrossedRows << ")"); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "proton " << indexBach << ": rejected due to minNUmberOfCrossedRows " << bach.tpcNClsCrossedRows() << " (cut " << i_minCrossedRows << ")"); continue; } - MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "KEPT! proton from Lc with daughters " << protonLabel); + MY_DEBUG_MSG(isProtonFromLc, LOG(INFO) << "KEPT! proton from Lc with daughters " << indexBach); - auto bachTrack = getTrackParCov(bach); + auto trackBach = getTrackParCov(bach); // now we loop over the V0s for (const auto& v0 : V0s) { MY_DEBUG_MSG(1, LOG(INFO) << "*** Checking next K0S"); // selections on the V0 daughters - const auto& posTrack = v0.posTrack_as(); - const auto& negTrack = v0.negTrack_as(); + const auto& trackV0DaughPos = v0.posTrack_as(); + const auto& trackV0DaughNeg = v0.negTrack_as(); #ifdef MY_DEBUG - auto labelPos = posTrack.mcParticleId(); - auto labelNeg = negTrack.mcParticleId(); - bool isK0SfromLc = isK0SfromLcFunc(labelPos, labelNeg, labelK0Spos, labelK0Sneg); + auto indexV0DaughPos = trackV0DaughPos.mcParticleId(); + auto indexV0DaughNeg = trackV0DaughNeg.mcParticleId(); + bool isK0SfromLc = isK0SfromLcFunc(indexV0DaughPos, indexV0DaughNeg, indexK0Spos, indexK0Sneg); - bool isLc = isLcK0SpFunc(protonLabel, labelPos, labelNeg, labelProton, labelK0Spos, labelK0Sneg); + bool isLc = isLcK0SpFunc(indexBach, indexV0DaughPos, indexV0DaughNeg, indexProton, indexK0Spos, indexK0Sneg); #endif - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S from Lc found, posTrack --> " << labelPos << ", negTrack --> " << labelNeg); + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S from Lc found, trackV0DaughPos --> " << indexV0DaughPos << ", trackV0DaughNeg --> " << indexV0DaughNeg); MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "ACCEPTED!!!"; - LOG(INFO) << "proton belonging to a Lc found: label --> " << protonLabel; - LOG(INFO) << "K0S belonging to a Lc found: posTrack --> " << labelPos << ", negTrack --> " << labelNeg); + LOG(INFO) << "proton belonging to a Lc found: label --> " << indexBach; + LOG(INFO) << "K0S belonging to a Lc found: trackV0DaughPos --> " << indexV0DaughPos << ", trackV0DaughNeg --> " << indexV0DaughNeg); MY_DEBUG_MSG(isLc, LOG(INFO) << "Combination of K0S and p which correspond to a Lc found!"); if (TPCRefit) { - if (!(posTrack.trackType() & o2::aod::track::TPCrefit) || - !(negTrack.trackType() & o2::aod::track::TPCrefit)) { - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to TPCrefit"); + if (!(trackV0DaughPos.trackType() & o2::aod::track::TPCrefit) || + !(trackV0DaughNeg.trackType() & o2::aod::track::TPCrefit)) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << indexV0DaughPos << " and " << indexV0DaughNeg << ": rejected due to TPCrefit"); continue; } } - if (posTrack.tpcNClsCrossedRows() < i_minCrossedRows || - negTrack.tpcNClsCrossedRows() < i_minCrossedRows) { - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to minCrossedRows"); + if (trackV0DaughPos.tpcNClsCrossedRows() < i_minCrossedRows || + trackV0DaughNeg.tpcNClsCrossedRows() < i_minCrossedRows) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << indexV0DaughPos << " and " << indexV0DaughNeg << ": rejected due to minCrossedRows"); continue; } // - // if (posTrack.dcaXY() < dcaXYPosToPV || // to the filters? - // negTrack.dcaXY() < dcaXYNegToPV) { + // if (trackV0DaughPos.dcaXY() < dcaXYPosToPV || // to the filters? + // trackV0DaughNeg.dcaXY() < dcaXYNegToPV) { // continue; // } // - if (posTrack.pt() < ptMin || // to the filters? I can't for now, it is not in the tables - negTrack.pt() < ptMin) { - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to minPt --> pos " << posTrack.pt() << ", neg " << negTrack.pt() << " (cut " << ptMin << ")"); + if (trackV0DaughPos.pt() < ptMin || // to the filters? I can't for now, it is not in the tables + trackV0DaughNeg.pt() < ptMin) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << indexV0DaughPos << " and " << indexV0DaughNeg << ": rejected due to minPt --> pos " << trackV0DaughPos.pt() << ", neg " << trackV0DaughNeg.pt() << " (cut " << ptMin << ")"); continue; } - if (abs(posTrack.eta()) > etaMax || // to the filters? I can't for now, it is not in the tables - abs(negTrack.eta()) > etaMax) { - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to eta --> pos " << posTrack.eta() << ", neg " << negTrack.eta() << " (cut " << etaMax << ")"); + if (std::abs(trackV0DaughPos.eta()) > etaMax || // to the filters? I can't for now, it is not in the tables + std::abs(trackV0DaughNeg.eta()) > etaMax) { + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << indexV0DaughPos << " and " << indexV0DaughNeg << ": rejected due to eta --> pos " << trackV0DaughPos.eta() << ", neg " << trackV0DaughNeg.eta() << " (cut " << etaMax << ")"); continue; } // V0 invariant mass selection if (std::abs(v0.mK0Short() - massK0s) > cutInvMassV0) { - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to invMass --> " << v0.mK0Short() - massK0s << " (cut " << cutInvMassV0 << ")"); + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << indexV0DaughPos << " and " << indexV0DaughNeg << ": rejected due to invMass --> " << v0.mK0Short() - massK0s << " (cut " << cutInvMassV0 << ")"); continue; // should go to the filter, but since it is a dynamic column, I cannot use it there } // V0 cosPointingAngle selection if (v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < cosPAV0) { - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << labelPos << " and " << labelNeg << ": rejected due to cosPA --> " << v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) << " (cut " << cosPAV0 << ")"); + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "K0S with daughters " << indexV0DaughPos << " and " << indexV0DaughNeg << ": rejected due to cosPA --> " << v0.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) << " (cut " << cosPAV0 << ")"); continue; } - MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "KEPT! K0S from Lc with daughters " << labelPos << " and " << labelNeg); - auto posTrackParCov = getTrackParCov(posTrack); - posTrackParCov.propagateTo(v0.posX(), bZ); // propagate the track to the X closest to the V0 vertex - auto negTrackParCov = getTrackParCov(negTrack); - negTrackParCov.propagateTo(v0.negX(), bZ); // propagate the track to the X closest to the V0 vertex + const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; + + // invariant-mass cut: we do it here, before updating the momenta of bach and V0 during the fitting to save CPU + // TODO: but one should better check that the value here and after the fitter do not change significantly!!! + mass2K0sP = RecoDecay::M(array{array{bach.px(), bach.py(), bach.pz()}, momentumV0}, array{massP, massK0s}); + if ((cutCascInvMassLc >= 0.) && (std::abs(mass2K0sP - massLc) > cutCascInvMassLc)) { + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "True Lc from proton " << indexBach << " and K0S pos " << indexV0DaughPos << " and neg " << indexV0DaughNeg << " rejected due to invMass cut: " << mass2K0sP << ", mass Lc " << massLc << " (cut " << cutCascInvMassLc << ")"); + continue; + } + + MY_DEBUG_MSG(isK0SfromLc, LOG(INFO) << "KEPT! K0S from Lc with daughters " << indexV0DaughPos << " and " << indexV0DaughNeg); + + auto trackParCovV0DaughPos = getTrackParCov(trackV0DaughPos); + trackParCovV0DaughPos.propagateTo(v0.posX(), bZ); // propagate the track to the X closest to the V0 vertex + auto trackParCovV0DaughNeg = getTrackParCov(trackV0DaughNeg); + trackParCovV0DaughNeg.propagateTo(v0.negX(), bZ); // propagate the track to the X closest to the V0 vertex std::array pVecV0 = {0., 0., 0.}; std::array pVecBach = {0., 0., 0.}; const std::array vertexV0 = {v0.x(), v0.y(), v0.z()}; - const std::array momentumV0 = {v0.px(), v0.py(), v0.pz()}; - // we build the neutral track to then build the cascade - auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, {0, 0, 0, 0, 0, 0}, posTrackParCov, negTrackParCov, {0, 0}, {0, 0}); // build the V0 track + auto trackV0 = o2::dataformats::V0(vertexV0, momentumV0, {0, 0, 0, 0, 0, 0}, trackParCovV0DaughPos, trackParCovV0DaughNeg, {0, 0}, {0, 0}); // build the V0 track // now we find the DCA between the V0 and the bachelor, for the cascade - int nCand2 = fitter.process(trackV0, bachTrack); - MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "Fitter result = " << nCand2 << " proton = " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg); + int nCand2 = fitter.process(trackV0, trackBach); + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "Fitter result = " << nCand2 << " proton = " << indexBach << " and K0S pos " << indexV0DaughPos << " and neg " << indexV0DaughNeg); MY_DEBUG_MSG(isLc, LOG(INFO) << "Fitter result for true Lc = " << nCand2); if (nCand2 == 0) { continue; } - std::array pVecCandCasc = {0., 0., 0.}; fitter.propagateTracksToVertex(); // propagate the bach and V0 to the Lc vertex fitter.getTrack(0).getPxPyPzGlo(pVecV0); // take the momentum at the Lc vertex fitter.getTrack(1).getPxPyPzGlo(pVecBach); - pVecCandCasc = array{pVecBach[0] + pVecV0[0], - pVecBach[1] + pVecV0[1], - pVecBach[2] + pVecV0[2]}; - // cascade candidate pT cut - if (RecoDecay::Pt(pVecCandCasc) < cutCascPtCandMin) { - MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to pt cut: " << RecoDecay::Pt(pVecCandCasc) << " (cut " << cutCascPtCandMin << ")"); + auto ptCascCand = RecoDecay::Pt(pVecBach, pVecV0); + if (ptCascCand < cutCascPtCandMin) { + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "True Lc from proton " << indexBach << " and K0S pos " << indexV0DaughPos << " and neg " << indexV0DaughNeg << " rejected due to pt cut: " << ptCascCand << " (cut " << cutCascPtCandMin << ")"); continue; } // invariant mass - // calculate invariant masses - auto arrMom = array{pVecBach, pVecV0}; - mass2K0sP = RecoDecay::M(arrMom, array{massP, massK0s}); - // invariant-mass cut - if ((cutCascInvMassLc >= 0.) && (std::abs(mass2K0sP - massLc) > cutCascInvMassLc)) { - MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc, LOG(INFO) << "True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg << " rejected due to invMass cut: " << mass2K0sP << ", mass Lc " << massLc << " (cut " << cutCascInvMassLc << ")"); - continue; - } + // re-calculate invariant masses with updated momenta, to fill the histogram + mass2K0sP = RecoDecay::M(array{pVecBach, pVecV0}, array{massP, massK0s}); std::array posCasc = {0., 0., 0.}; const auto& cascVtx = fitter.getPCACandidate(); @@ -1250,7 +1247,7 @@ struct HFTrackIndexSkimsCreatorCascades { 1); // 1 should be the value for the Lc // fill histograms if (doValPlots) { - MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc && isLc, LOG(INFO) << "KEPT! True Lc from proton " << protonLabel << " and K0S pos " << labelPos << " and neg " << labelNeg); + MY_DEBUG_MSG(isK0SfromLc && isProtonFromLc && isLc, LOG(INFO) << "KEPT! True Lc from proton " << indexBach << " and K0S pos " << indexV0DaughPos << " and neg " << indexV0DaughNeg); registry.get(HIST("hvtx2_x"))->Fill(posCasc[0]); registry.get(HIST("hvtx2_y"))->Fill(posCasc[1]); registry.get(HIST("hvtx2_z"))->Fill(posCasc[2]); diff --git a/Analysis/Tasks/PWGLF/CMakeLists.txt b/Analysis/Tasks/PWGLF/CMakeLists.txt index 250b7cec35962..5e865fba760e9 100644 --- a/Analysis/Tasks/PWGLF/CMakeLists.txt +++ b/Analysis/Tasks/PWGLF/CMakeLists.txt @@ -59,7 +59,7 @@ o2_add_dpl_workflow(nuclei-spectra COMPONENT_NAME Analysis) o2_add_dpl_workflow(lambdakzerobuilder - SOURCES lambdakzerobuilder + SOURCES lambdakzerobuilder.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2::DetectorsBase O2::AnalysisDataModel O2::AnalysisCore O2::DetectorsVertexing O2::AnalysisTasksUtils COMPONENT_NAME Analysis) diff --git a/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h b/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h index 1f480009456ef..03758fd2d59bf 100644 --- a/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h +++ b/Analysis/Tasks/Utils/include/AnalysisTasksUtils/UtilsDebugLcK0Sp.h @@ -78,13 +78,5 @@ inline bool isLcK0SpFunc(int labelProton, int labelK0SPos, int labelK0SNeg, std: return true; } - /* - auto nElements = nPositiveDau; - for (auto i = 0; i < nPositiveDau; ++i) { - if (labelProton == listLabelsProton[i] && labelK0SPos == listLabelsK0SPos[i] && labelK0SNeg == listLabelsK0SNeg[i]) { - return true; - } - } - */ return false; }