diff --git a/ALICE3/DataModel/OTFMcTrackExtra.h b/ALICE3/DataModel/OTFMcTrackExtra.h deleted file mode 100644 index bb75c86746c..00000000000 --- a/ALICE3/DataModel/OTFMcTrackExtra.h +++ /dev/null @@ -1,42 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -/// -/// \file OTFMcTrackExtra.h -/// \author Jesper Karlsson Gumprecht -/// \since 05/08/2024 -/// \brief Table to to hold MC information specifically for xi daughters created in the otf-tracker -/// - -#ifndef ALICE3_DATAMODEL_OTFMCTRACKEXTRA_H_ -#define ALICE3_DATAMODEL_OTFMCTRACKEXTRA_H_ - -// O2 includes -#include "Framework/AnalysisDataModel.h" - -namespace o2::aod -{ -namespace otf_mctrack_extra -{ -DECLARE_SOA_COLUMN(NewPdgCode, newPdgCode, int); //! PDG code (duplicate column but needed for particles created in the otf-tracker) -DECLARE_SOA_COLUMN(IsFromXi, isFromXi, bool); //! From Xi decayed in otf-tracker -DECLARE_SOA_COLUMN(IsFromL0, isFromL0, bool); //! From L0 decayed in otf-tracker -} // namespace otf_mctrack_extra -DECLARE_SOA_TABLE(OTFMcExtra, "AOD", "OTFMcExtra", - otf_mctrack_extra::NewPdgCode, - otf_mctrack_extra::IsFromXi, - otf_mctrack_extra::IsFromL0); - -using OTFMcTrackExtra = OTFMcExtra::iterator; - -} // namespace o2::aod - -#endif // ALICE3_DATAMODEL_OTFMCTRACKEXTRA_H_ diff --git a/ALICE3/DataModel/OTFMulticharm.h b/ALICE3/DataModel/OTFMulticharm.h index 955654c5b47..1fca25575d9 100644 --- a/ALICE3/DataModel/OTFMulticharm.h +++ b/ALICE3/DataModel/OTFMulticharm.h @@ -21,6 +21,8 @@ #define ALICE3_DATAMODEL_OTFMULTICHARM_H_ // O2 includes +#include "ALICE3/DataModel/OTFStrangeness.h" + #include "Framework/AnalysisDataModel.h" namespace o2::aod @@ -36,8 +38,8 @@ DECLARE_SOA_COLUMN(XicMass, xicMass, float); DECLARE_SOA_COLUMN(XiccMass, xiccMass, float); // kine vars -DECLARE_SOA_COLUMN(Pt, pt, float); -DECLARE_SOA_COLUMN(Eta, eta, float); +DECLARE_SOA_COLUMN(XiccPt, xiccPt, float); +DECLARE_SOA_COLUMN(XiccEta, xiccEta, float); // topo vars DECLARE_SOA_COLUMN(XiDCAz, xiDCAz, float); @@ -49,18 +51,18 @@ DECLARE_SOA_COLUMN(XiccDauDCA, xiccDauDCA, float); DECLARE_SOA_COLUMN(XiccDCAxy, xiccDCAxy, float); DECLARE_SOA_COLUMN(XiccDCAz, xiccDCAz, float); -DECLARE_SOA_COLUMN(PiFromXiDCAxy, piFromXiDCAxy, float); -DECLARE_SOA_COLUMN(PiFromLaDCAxy, piFromLaDCAxy, float); -DECLARE_SOA_COLUMN(PrFromLaDCAxy, prFromLaDCAxy, float); -DECLARE_SOA_COLUMN(PiFromXiDCAz, piFromXiDCAz, float); -DECLARE_SOA_COLUMN(PiFromLaDCAz, piFromLaDCAz, float); -DECLARE_SOA_COLUMN(PrFromLaDCAz, prFromLaDCAz, float); +DECLARE_SOA_COLUMN(BachDCAxy, bachDCAxy, float); +DECLARE_SOA_COLUMN(BachDCAz, bachDCAz, float); +DECLARE_SOA_COLUMN(PosDCAxy, posDCAxy, float); +DECLARE_SOA_COLUMN(PosDCAz, posDCAz, float); +DECLARE_SOA_COLUMN(NegDCAxy, negDCAxy, float); +DECLARE_SOA_COLUMN(NegDCAz, negDCAz, float); DECLARE_SOA_COLUMN(Pi1cDCAxy, pi1cDCAxy, float); -DECLARE_SOA_COLUMN(Pi2cDCAxy, pi2cDCAxy, float); -DECLARE_SOA_COLUMN(PiccDCAxy, piccDCAxy, float); DECLARE_SOA_COLUMN(Pi1cDCAz, pi1cDCAz, float); +DECLARE_SOA_COLUMN(Pi2cDCAxy, pi2cDCAxy, float); DECLARE_SOA_COLUMN(Pi2cDCAz, pi2cDCAz, float); +DECLARE_SOA_COLUMN(PiccDCAxy, piccDCAxy, float); DECLARE_SOA_COLUMN(PiccDCAz, piccDCAz, float); // Lengths @@ -75,14 +77,25 @@ DECLARE_SOA_COLUMN(Pi1cTofDeltaInner, pi1cTofDeltaInner, float); DECLARE_SOA_COLUMN(Pi1cTofNSigmaInner, pi1cTofNSigmaInner, float); DECLARE_SOA_COLUMN(Pi1cTofDeltaOuter, pi1cTofDeltaOuter, float); DECLARE_SOA_COLUMN(Pi1cTofNSigmaOuter, pi1cTofNSigmaOuter, float); +DECLARE_SOA_COLUMN(Pi1cHasRichSignal, pi1cHasRichSignal, bool); +DECLARE_SOA_COLUMN(Pi1cRichNSigma, pi1cRichNSigma, float); +DECLARE_SOA_COLUMN(Pi1cPdgCode, pi1cPdgCode, int); + DECLARE_SOA_COLUMN(Pi2cTofDeltaInner, pi2cTofDeltaInner, float); DECLARE_SOA_COLUMN(Pi2cTofNSigmaInner, pi2cTofNSigmaInner, float); DECLARE_SOA_COLUMN(Pi2cTofDeltaOuter, pi2cTofDeltaOuter, float); DECLARE_SOA_COLUMN(Pi2cTofNSigmaOuter, pi2cTofNSigmaOuter, float); +DECLARE_SOA_COLUMN(Pi2cHasRichSignal, pi2cHasRichSignal, bool); +DECLARE_SOA_COLUMN(Pi2cRichNSigma, pi2cRichNSigma, float); +DECLARE_SOA_COLUMN(Pi2cPdgCode, pi2cPdgCode, int); + DECLARE_SOA_COLUMN(PiccTofDeltaInner, piccTofDeltaInner, float); DECLARE_SOA_COLUMN(PiccTofNSigmaInner, piccTofNSigmaInner, float); DECLARE_SOA_COLUMN(PiccTofDeltaOuter, piccTofDeltaOuter, float); DECLARE_SOA_COLUMN(PiccTofNSigmaOuter, piccTofNSigmaOuter, float); +DECLARE_SOA_COLUMN(PiccHasRichSignal, piccHasRichSignal, bool); +DECLARE_SOA_COLUMN(PiccRichNSigma, piccRichNSigma, float); +DECLARE_SOA_COLUMN(PiccPdgCode, piccPdgCode, int); // Daughter info DECLARE_SOA_COLUMN(PosPt, posPt, float); @@ -100,6 +113,7 @@ DECLARE_SOA_COLUMN(PiccPt, piccPt, float); DECLARE_SOA_COLUMN(PiccEta, piccEta, float); } // namespace otfmulticharm + DECLARE_SOA_TABLE(MCharmIndices, "AOD", "MCharmIndices", o2::soa::Index<>, otfmulticharm::CascadeId, @@ -112,8 +126,8 @@ DECLARE_SOA_TABLE(MCharmCores, "AOD", "MCharmCores", otfmulticharm::XiccDauDCA, otfmulticharm::XicMass, otfmulticharm::XiccMass, - otfmulticharm::Pt, - otfmulticharm::Eta, + otfmulticharm::XiccPt, + otfmulticharm::XiccEta, otfmulticharm::XiDCAxy, otfmulticharm::XiDCAz, @@ -122,13 +136,6 @@ DECLARE_SOA_TABLE(MCharmCores, "AOD", "MCharmCores", otfmulticharm::XiccDCAxy, otfmulticharm::XiccDCAz, - otfmulticharm::PiFromXiDCAxy, - otfmulticharm::PiFromXiDCAz, - otfmulticharm::PiFromLaDCAxy, - otfmulticharm::PiFromLaDCAz, - otfmulticharm::PrFromLaDCAxy, - otfmulticharm::PrFromLaDCAz, - otfmulticharm::Pi1cDCAxy, otfmulticharm::Pi1cDCAz, otfmulticharm::Pi2cDCAxy, @@ -141,38 +148,53 @@ DECLARE_SOA_TABLE(MCharmCores, "AOD", "MCharmCores", otfmulticharm::XicProperLength, otfmulticharm::XicDistanceFromPV, otfmulticharm::XiccProperLength, + otfmulticharm::Pi1cPt, + otfmulticharm::Pi2cPt, + otfmulticharm::PiccPt); +DECLARE_SOA_TABLE(MCharmPID, "AOD", "MCharmPID", otfmulticharm::Pi1cTofDeltaInner, otfmulticharm::Pi1cTofNSigmaInner, otfmulticharm::Pi1cTofDeltaOuter, otfmulticharm::Pi1cTofNSigmaOuter, + otfmulticharm::Pi1cHasRichSignal, + otfmulticharm::Pi1cRichNSigma, + otfmulticharm::Pi1cPdgCode, otfmulticharm::Pi2cTofDeltaInner, otfmulticharm::Pi2cTofNSigmaInner, otfmulticharm::Pi2cTofDeltaOuter, otfmulticharm::Pi2cTofNSigmaOuter, + otfmulticharm::Pi2cHasRichSignal, + otfmulticharm::Pi2cRichNSigma, + otfmulticharm::Pi2cPdgCode, otfmulticharm::PiccTofDeltaInner, otfmulticharm::PiccTofNSigmaInner, otfmulticharm::PiccTofDeltaOuter, otfmulticharm::PiccTofNSigmaOuter, + otfmulticharm::PiccHasRichSignal, + otfmulticharm::PiccRichNSigma, + otfmulticharm::PiccPdgCode); +DECLARE_SOA_TABLE(MCharmExtra, "AOD", "MCharmExtra", otfmulticharm::BachPt, otfmulticharm::BachEta, + otfmulticharm::BachDCAxy, + otfmulticharm::BachDCAz, otfmulticharm::PosPt, otfmulticharm::PosEta, + otfmulticharm::PosDCAxy, + otfmulticharm::PosDCAz, otfmulticharm::NegPt, otfmulticharm::NegEta, + otfmulticharm::NegDCAxy, + otfmulticharm::NegDCAz, - otfmulticharm::Pi1cPt, otfmulticharm::Pi1cEta, - - otfmulticharm::Pi2cPt, otfmulticharm::Pi2cEta, - - otfmulticharm::PiccPt, otfmulticharm::PiccEta); } // namespace o2::aod diff --git a/ALICE3/TableProducer/alice3-multicharmTable.cxx b/ALICE3/TableProducer/alice3-multicharmTable.cxx index 16b16c666d8..433b6d065a9 100644 --- a/ALICE3/TableProducer/alice3-multicharmTable.cxx +++ b/ALICE3/TableProducer/alice3-multicharmTable.cxx @@ -17,41 +17,43 @@ // HF decays. Work in progress: use at your own risk! // -#include -#include -#include -#include -#include -#include +#include "PWGLF/DataModel/LFParticleIdentification.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" -#include "Framework/runDataProcessing.h" -#include "Framework/RunningWorkflowInfo.h" -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoAHelpers.h" -#include "DCAFitter/DCAFitterN.h" -#include "ReconstructionDataFormats/Track.h" +#include "ALICE3/DataModel/A3DecayFinderTables.h" +#include "ALICE3/DataModel/OTFMulticharm.h" +#include "ALICE3/DataModel/OTFRICH.h" +#include "ALICE3/DataModel/OTFStrangeness.h" +#include "ALICE3/DataModel/OTFTOF.h" +#include "ALICE3/DataModel/tracksAlice3.h" #include "Common/Core/RecoDecay.h" -#include "Common/Core/trackUtilities.h" -#include "PWGLF/DataModel/LFStrangenessTables.h" -#include "PWGLF/DataModel/LFParticleIdentification.h" #include "Common/Core/TrackSelection.h" +#include "Common/Core/trackUtilities.h" #include "Common/DataModel/TrackSelectionTables.h" -#include "DetectorsBase/Propagator.h" -#include "DetectorsBase/GeometryManager.h" -#include "DataFormatsParameters/GRPObject.h" -#include "DataFormatsParameters/GRPMagField.h" + #include "CCDB/BasicCCDBManager.h" +#include "CommonConstants/PhysicsConstants.h" +#include "DCAFitter/DCAFitterN.h" #include "DataFormatsCalibration/MeanVertexObject.h" -#include "ALICE3/DataModel/OTFTOF.h" -#include "ALICE3/DataModel/RICH.h" -#include "ALICE3/DataModel/A3DecayFinderTables.h" -#include "ALICE3/DataModel/OTFStrangeness.h" -#include "ALICE3/DataModel/OTFMulticharm.h" -#include "ALICE3/DataModel/tracksAlice3.h" +#include "DataFormatsParameters/GRPMagField.h" +#include "DataFormatsParameters/GRPObject.h" +#include "DetectorsBase/GeometryManager.h" +#include "DetectorsBase/Propagator.h" #include "DetectorsVertexing/PVertexer.h" #include "DetectorsVertexing/PVertexerHelpers.h" -#include "CommonConstants/PhysicsConstants.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/RunningWorkflowInfo.h" +#include "Framework/runDataProcessing.h" +#include "ReconstructionDataFormats/Track.h" + +#include +#include +#include +#include +#include +#include using namespace o2; using namespace o2::framework; @@ -68,14 +70,16 @@ using FullTracksExt = soa::Join; // For MC association in pre-selection using labeledTracks = soa::Join; using tofTracks = soa::Join; -using richTracks = soa::Join; -using alice3tracks = soa::Join; +using richTracks = soa::Join; +using alice3tracks = soa::Join; struct alice3multicharmTable { SliceCache cache; Produces multiCharmIdx; Produces multiCharmCore; + Produces multiCharmPID; + Produces multiCharmExtra; // Operation and minimisation criteria Configurable fillDerivedTable{"fillDerivedTable", false, "fill MCharm[] tables (careful: memory)"}; @@ -321,6 +325,13 @@ struct alice3multicharmTable { return true; } + template + int getPdgCodeForTrack(TTrackType track) + { + auto mcParticle = track.template mcParticle_as(); + return mcParticle.pdgCode(); + } + /// function to check if tracks have the same mother in MC template bool checkSameMother(TTrackType1 const& track1, TTrackType2 const& track2) @@ -729,27 +740,43 @@ struct alice3multicharmTable { xi.dcaXY(), xi.dcaZ(), xicdcaXY, xicdcaZ, xiccdcaXY, xiccdcaZ, - piFromXi.dcaXY(), piFromXi.dcaZ(), - piFromLa.dcaXY(), piFromLa.dcaZ(), - prFromLa.dcaXY(), prFromLa.dcaZ(), pi1c.dcaXY(), pi1c.dcaZ(), pi2c.dcaXY(), pi2c.dcaZ(), picc.dcaXY(), picc.dcaZ(), xicDecayRadius2D, xiccDecayRadius2D, - xicProperLength, xicDecayDistanceFromPV, + xicProperLength, + xicDecayDistanceFromPV, xiccProperLength, + pi1c.pt(), + pi2c.pt(), + picc.pt()); + + multiCharmPID( pi1cTOFDiffInner, pi1c.nSigmaPionInnerTOF(), pi1cTOFDiffOuter, pi1c.nSigmaPionOuterTOF(), + pi1c.hasSigPi(), pi1c.nSigmaPionRich(), + getPdgCodeForTrack(pi1c), + pi2cTOFDiffInner, pi2c.nSigmaPionInnerTOF(), pi2cTOFDiffOuter, pi2c.nSigmaPionOuterTOF(), + pi2c.hasSigPi(), pi2c.nSigmaPionRich(), + getPdgCodeForTrack(pi2c), + piccTOFDiffInner, picc.nSigmaPionInnerTOF(), piccTOFDiffOuter, picc.nSigmaPionOuterTOF(), + picc.hasSigPi(), picc.nSigmaPionRich(), + getPdgCodeForTrack(picc)); + + multiCharmExtra( piFromXi.pt(), piFromXi.eta(), + piFromXi.dcaXY(), piFromXi.dcaZ(), prFromLa.pt(), prFromLa.eta(), + prFromLa.dcaXY(), prFromLa.dcaZ(), piFromLa.pt(), piFromLa.eta(), - pi1c.pt(), pi1c.eta(), - pi2c.pt(), pi2c.eta(), - picc.pt(), picc.eta()); + piFromLa.dcaXY(), piFromLa.dcaZ(), + pi1c.eta(), + pi2c.eta(), + picc.eta()); } } histos.fill(HIST("hCombinationsXiCC"), nCombinationsCC); diff --git a/ALICE3/Tasks/alice3-multicharm.cxx b/ALICE3/Tasks/alice3-multicharm.cxx index 2b6ad804ddf..497038f724f 100644 --- a/ALICE3/Tasks/alice3-multicharm.cxx +++ b/ALICE3/Tasks/alice3-multicharm.cxx @@ -17,57 +17,62 @@ // HF decays. Work in progress: use at your own risk! // -#include -#include -#include -#include -#include -#include +#include "PWGLF/DataModel/LFParticleIdentification.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" -#include "Framework/runDataProcessing.h" -#include "Framework/RunningWorkflowInfo.h" -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoAHelpers.h" -#include "DCAFitter/DCAFitterN.h" -#include "ReconstructionDataFormats/Track.h" +#include "ALICE3/DataModel/A3DecayFinderTables.h" +#include "ALICE3/DataModel/OTFMulticharm.h" +#include "ALICE3/DataModel/OTFRICH.h" +#include "ALICE3/DataModel/OTFStrangeness.h" +#include "ALICE3/DataModel/OTFTOF.h" +#include "ALICE3/DataModel/tracksAlice3.h" #include "Common/Core/RecoDecay.h" -#include "Common/Core/trackUtilities.h" -#include "PWGLF/DataModel/LFStrangenessTables.h" -#include "PWGLF/DataModel/LFParticleIdentification.h" #include "Common/Core/TrackSelection.h" +#include "Common/Core/trackUtilities.h" #include "Common/DataModel/TrackSelectionTables.h" -#include "DetectorsBase/Propagator.h" -#include "DetectorsBase/GeometryManager.h" -#include "DataFormatsParameters/GRPObject.h" -#include "DataFormatsParameters/GRPMagField.h" + #include "CCDB/BasicCCDBManager.h" +#include "CommonConstants/PhysicsConstants.h" +#include "DCAFitter/DCAFitterN.h" #include "DataFormatsCalibration/MeanVertexObject.h" -#include "ALICE3/DataModel/OTFTOF.h" -#include "ALICE3/DataModel/RICH.h" -#include "ALICE3/DataModel/A3DecayFinderTables.h" -#include "ALICE3/DataModel/OTFStrangeness.h" -#include "ALICE3/DataModel/OTFMulticharm.h" -#include "ALICE3/DataModel/tracksAlice3.h" +#include "DataFormatsParameters/GRPMagField.h" +#include "DataFormatsParameters/GRPObject.h" +#include "DetectorsBase/GeometryManager.h" +#include "DetectorsBase/Propagator.h" #include "DetectorsVertexing/PVertexer.h" #include "DetectorsVertexing/PVertexerHelpers.h" -#include "CommonConstants/PhysicsConstants.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/RunningWorkflowInfo.h" +#include "Framework/runDataProcessing.h" +#include "ReconstructionDataFormats/Track.h" + +#include +#include +#include +#include +#include +#include using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; -// using multicharmtracks = soa::Join; +using multiCharmTracksPID = soa::Join; +using multiCharmTracksFull = soa::Join; struct alice3multicharm { - SliceCache cache; + HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + std::map pdgToBin; ConfigurableAxis axisEta{"axisEta", {80, -4.0f, +4.0f}, "#eta"}; ConfigurableAxis axisXiccMass{"axisXiccMass", {200, 3.521f, 3.721f}, "Xicc Inv Mass (GeV/c^{2})"}; ConfigurableAxis axisDCA{"axisDCA", {400, 0, 400}, "DCA (#mum)"}; ConfigurableAxis axisRadiusLarge{"axisRadiusLarge", {1000, 0, 20}, "Decay radius (cm)"}; ConfigurableAxis axisRadius{"axisRadius", {10000, 0, 10000}, "Decay radius (#mum)"}; - ConfigurableAxis axisTofTrackDelta{"axisTofTrackDelta", {1000, 0, 5000}, "TOF track time"}; + ConfigurableAxis axisTofTrackDelta{"axisTofTrackDelta", {200, 0, 1000}, "TOF track time"}; + ConfigurableAxis axisNSigma{"axisNSigma", {21, -10, 10}, "nsigma"}; ConfigurableAxis axisDecayLength{"axisDecayLength", {2000, 0, 2000}, "Decay lenght (#mum)"}; ConfigurableAxis axisDcaDaughters{"axisDcaDaughters", {200, 0, 100}, "DCA (mum)"}; ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.2f, 2.4f, 2.6f, 2.8f, 3.0f, 3.2f, 3.4f, 3.6f, 3.8f, 4.0f, 4.4f, 4.8f, 5.2f, 5.6f, 6.0f, 6.5f, 7.0f, 7.5f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 30.0f, 35.0f, 40.0f, 50.0f}, "pt axis for QA histograms"}; @@ -101,8 +106,6 @@ struct alice3multicharm { Configurable xiccMinProperLength{"xiccMinProperLength", -1, "Minimum proper length for Xicc decay (cm)"}; Configurable xiccMaxProperLength{"xiccMaxProperLength", 1e+4, "Minimum proper length for Xicc decay (cm)"}; - HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; - void init(InitContext&) { histos.add("SelectionQA/hDCAXicDaughters", "hDCAXicDaughters; DCA between Xic daughters (#mum)", kTH1D, {axisDcaDaughters}); @@ -113,88 +116,174 @@ struct alice3multicharm { histos.add("SelectionQA/hDCAzXic", "hDCAzXic; Xic DCAz to PV (#mum)", kTH1D, {axisDCA}); histos.add("SelectionQA/hDCAxyXicc", "hDCAxyXicc; Xicc DCAxy to PV (#mum)", kTH1D, {axisDCA}); histos.add("SelectionQA/hDCAzXicc", "hDCAzXicc; Xicc DCAz to PV (#mum)", kTH1D, {axisDCA}); + histos.add("SelectionQA/hDecayRadiusXic", "hDecayRadiusXic; Distance (#mum)", kTH1D, {axisRadius}); + histos.add("SelectionQA/hDecayRadiusXicc", "hDecayRadiusXicc; Distance (#mum)", kTH1D, {axisRadius}); + histos.add("SelectionQA/hDecayDistanceFromPVXic", "hDecayDistanceFromPVXic; Distance (#mum)", kTH1D, {axisDecayLength}); + histos.add("SelectionQA/hProperLengthXic", "hProperLengthXic; Distance (#mum)", kTH1D, {axisDecayLength}); + histos.add("SelectionQA/hProperLengthXicc", "hProperLengthXicc; Distance (#mum)", kTH1D, {axisDecayLength}); histos.add("SelectionQA/hPi1cPt", "hPi1cPt; Pi1c pT (Gev/#it(c))", kTH1D, {axisPt}); histos.add("SelectionQA/hPi2cPt", "hPi2cPt; Pi2c pT (Gev/#it(c))", kTH1D, {axisPt}); histos.add("SelectionQA/hPiccPt", "hPiccPt; Picc pT (Gev/#it(c))", kTH1D, {axisPt}); - histos.add("SelectionQA/hXicDecayRadius", "hXicDecayRadius; Distance (#mum)", kTH1D, {axisRadius}); - histos.add("SelectionQA/hXiccDecayRadius", "hXiccDecayRadius; Distance (#mum)", kTH1D, {axisRadius}); - histos.add("SelectionQA/hXicDecayDistanceFromPV", "hXicDecayDistanceFromPV; Distance (#mum)", kTH1D, {axisDecayLength}); - histos.add("SelectionQA/hProperLengthXic", "hProperLengthXic; Distance (#mum)", kTH1D, {axisDecayLength}); - histos.add("SelectionQA/hProperLengthXicc", "hProperLengthXicc; Distance (#mum)", kTH1D, {axisDecayLength}); - histos.add("SelectionQA/hInnerTofTimeDeltaPi1c", "hInnerTofTimeDeltaPi1c; Reco - expected pion (ps)", kTH1D, {axisTofTrackDelta}); - histos.add("SelectionQA/hInnerTofTimeDeltaPi2c", "hInnerTofTimeDeltaPi2c; Reco - expected pion (ps)", kTH1D, {axisTofTrackDelta}); - histos.add("SelectionQA/hInnerTofTimeDeltaPicc", "hInnerTofTimeDeltaPicc; Reco - expected pion (ps)", kTH1D, {axisTofTrackDelta}); - - histos.add("XiccProngs/h3dPos", "h3dPos; Xicc pT (GeV/#it(c)); Pos pT (GeV/#it(c)); Pos #eta", kTH3D, {axisPt, axisPt, axisEta}); - histos.add("XiccProngs/h3dNeg", "h3dNeg; Xicc pT (GeV/#it(c)); Neg pT (GeV/#it(c)); Neg #eta", kTH3D, {axisPt, axisPt, axisEta}); - histos.add("XiccProngs/h3dBach", "h3dBach; Xicc pT (GeV/#it(c)); Bach pT (GeV/#it(c)); Bach #eta", kTH3D, {axisPt, axisPt, axisEta}); - histos.add("XiccProngs/h3dPi1c", "h3dPi1c; Xicc pT (GeV/#it(c)); Pi1c pT (GeV/#it(c)); Pi1c #eta", kTH3D, {axisPt, axisPt, axisEta}); - histos.add("XiccProngs/h3dPi2c", "h3dPi2c; Xicc pT (GeV/#it(c)); Pi2c pT (GeV/#it(c)); Pi2c #eta", kTH3D, {axisPt, axisPt, axisEta}); - histos.add("XiccProngs/h3dPicc", "h3dPicc; Xicc pT (GeV/#it(c)); Picc pT (GeV/#it(c)); Picc #eta", kTH3D, {axisPt, axisPt, axisEta}); + + auto hMCharmBuilding = histos.add("hMCharmBuilding", "hMCharmBuilding", kTH1D, {{22, -0.5, 21.5}}); + hMCharmBuilding->GetXaxis()->SetBinLabel(1, "nTotalCandidates"); + hMCharmBuilding->GetXaxis()->SetBinLabel(2, "xicMaxDauDCA"); + hMCharmBuilding->GetXaxis()->SetBinLabel(3, "xiccMaxDauDCA"); + hMCharmBuilding->GetXaxis()->SetBinLabel(4, "xiMinDCAxy"); + hMCharmBuilding->GetXaxis()->SetBinLabel(5, "xiMinDCAz"); + hMCharmBuilding->GetXaxis()->SetBinLabel(6, "picMinDCAxy"); + hMCharmBuilding->GetXaxis()->SetBinLabel(7, "picMinDCAz"); + hMCharmBuilding->GetXaxis()->SetBinLabel(8, "picMinDCAxy"); + hMCharmBuilding->GetXaxis()->SetBinLabel(9, "picMinDCAz"); + hMCharmBuilding->GetXaxis()->SetBinLabel(10, "piccMinDCAxy"); + hMCharmBuilding->GetXaxis()->SetBinLabel(11, "piccMinDCAz"); + hMCharmBuilding->GetXaxis()->SetBinLabel(12, "xicMinDCAxy"); + hMCharmBuilding->GetXaxis()->SetBinLabel(13, "xicMinDCAz"); + hMCharmBuilding->GetXaxis()->SetBinLabel(14, "xiccMaxDCAxy"); + hMCharmBuilding->GetXaxis()->SetBinLabel(15, "xiccMaxDCAz"); + hMCharmBuilding->GetXaxis()->SetBinLabel(16, "xicMinRadius"); + hMCharmBuilding->GetXaxis()->SetBinLabel(17, "xiccMinRadius"); + hMCharmBuilding->GetXaxis()->SetBinLabel(18, "xicMinProperLength"); + hMCharmBuilding->GetXaxis()->SetBinLabel(19, "xicMaxProperLength"); + hMCharmBuilding->GetXaxis()->SetBinLabel(20, "xiccMinProperLength"); + hMCharmBuilding->GetXaxis()->SetBinLabel(21, "xiccMaxProperLength"); + hMCharmBuilding->GetXaxis()->SetBinLabel(22, "xicMinDecayDistanceFromPV"); + + if (doprocessXiccPID || doprocessXiccExtra) { + auto hPdgCodes = histos.add("PIDQA/hPdgCodes", "hPdgCodes", kTH2D, {{3, 0.5, 3.5}, {5, 0.5, 5.5}}); + hPdgCodes->GetXaxis()->SetBinLabel(1, "pi1c"); + hPdgCodes->GetXaxis()->SetBinLabel(2, "pi2c"); + hPdgCodes->GetXaxis()->SetBinLabel(3, "picc"); + hPdgCodes->GetYaxis()->SetBinLabel(1, "el"); + hPdgCodes->GetYaxis()->SetBinLabel(2, "mu"); + hPdgCodes->GetYaxis()->SetBinLabel(3, "pi"); + hPdgCodes->GetYaxis()->SetBinLabel(4, "ka"); + hPdgCodes->GetYaxis()->SetBinLabel(5, "pr"); + pdgToBin.insert({kElectron, 1}); + pdgToBin.insert({kMuonMinus, 2}); + pdgToBin.insert({kPiPlus, 3}); + pdgToBin.insert({kKPlus, 4}); + pdgToBin.insert({kProton, 5}); + + histos.add("PIDQA/hInnerTofTimeDeltaPi1c", "hInnerTofTimeDeltaPi1c; Reco - expected pion (ps)", kTH1D, {axisTofTrackDelta}); + histos.add("PIDQA/hInnerTofTimeDeltaPi2c", "hInnerTofTimeDeltaPi2c; Reco - expected pion (ps)", kTH1D, {axisTofTrackDelta}); + histos.add("PIDQA/hInnerTofTimeDeltaPicc", "hInnerTofTimeDeltaPicc; Reco - expected pion (ps)", kTH1D, {axisTofTrackDelta}); + histos.add("PIDQA/hOuterTofTimeDeltaPi1c", "hOuterTofTimeDeltaPi1c; Reco - expected pion (ps)", kTH1D, {axisTofTrackDelta}); + histos.add("PIDQA/hOuterTofTimeDeltaPi2c", "hOuterTofTimeDeltaPi2c; Reco - expected pion (ps)", kTH1D, {axisTofTrackDelta}); + histos.add("PIDQA/hOuterTofTimeDeltaPicc", "hOuterTofTimeDeltaPicc; Reco - expected pion (ps)", kTH1D, {axisTofTrackDelta}); + + histos.add("PIDQA/hInnerTofNSigmaPi1c", "hInnerTofNSigmaPi1c; TOF NSigma pion", kTH2D, {axisPt, axisNSigma}); + histos.add("PIDQA/hOuterTofNSigmaPi1c", "hOuterTofNSigmaPi1c; TOF NSigma pion", kTH2D, {axisPt, axisNSigma}); + histos.add("PIDQA/hInnerTofNSigmaPi2c", "hInnerTofNSigmaPi2c; TOF NSigma pion", kTH2D, {axisPt, axisNSigma}); + histos.add("PIDQA/hOuterTofNSigmaPi2c", "hOuterTofNSigmaPi2c; TOF NSigma pion", kTH2D, {axisPt, axisNSigma}); + histos.add("PIDQA/hInnerTofNSigmaPicc", "hInnerTofNSigmaPicc; TOF NSigma pion", kTH2D, {axisPt, axisNSigma}); + histos.add("PIDQA/hOuterTofNSigmaPicc", "hOuterTofNSigmaPicc; TOF NSigma pion", kTH2D, {axisPt, axisNSigma}); + histos.add("PIDQA/hRichNSigmaPi1c", "hRichNSigmaPi1c; RICH NSigma pion", kTH2D, {axisPt, axisNSigma}); + histos.add("PIDQA/hRichNSigmaPi2c", "hRichNSigmaPi2c; RICH NSigma pion", kTH2D, {axisPt, axisNSigma}); + histos.add("PIDQA/hRichNSigmaPicc", "hRichNSigmaPicc; RICH NSigma pion", kTH2D, {axisPt, axisNSigma}); + } + + if (doprocessXiccExtra) { + histos.add("XiccProngs/h3dPos", "h3dPos; Xicc pT (GeV/#it(c)); Pos pT (GeV/#it(c)); Pos #eta", kTH3D, {axisPt, axisPt, axisEta}); + histos.add("XiccProngs/h3dNeg", "h3dNeg; Xicc pT (GeV/#it(c)); Neg pT (GeV/#it(c)); Neg #eta", kTH3D, {axisPt, axisPt, axisEta}); + histos.add("XiccProngs/h3dBach", "h3dBach; Xicc pT (GeV/#it(c)); Bach pT (GeV/#it(c)); Bach #eta", kTH3D, {axisPt, axisPt, axisEta}); + histos.add("XiccProngs/h3dPi1c", "h3dPi1c; Xicc pT (GeV/#it(c)); Pi1c pT (GeV/#it(c)); Pi1c #eta", kTH3D, {axisPt, axisPt, axisEta}); + histos.add("XiccProngs/h3dPi2c", "h3dPi2c; Xicc pT (GeV/#it(c)); Pi2c pT (GeV/#it(c)); Pi2c #eta", kTH3D, {axisPt, axisPt, axisEta}); + histos.add("XiccProngs/h3dPicc", "h3dPicc; Xicc pT (GeV/#it(c)); Picc pT (GeV/#it(c)); Picc #eta", kTH3D, {axisPt, axisPt, axisEta}); + } histos.add("h3dXicc", "h3dXicc; Xicc pT (GeV/#it(c)); Xicc #eta; Xicc mass (GeV/#it(c)^{2})", kTH3D, {axisPt, axisEta, axisXiccMass}); } - void processXicc(aod::MCharmCores const& multiCharmTracks) + template + void genericProcessXicc(TMCharmCands xiccCands) { - for (const auto& xiccCand : multiCharmTracks) { - if (xiccCand.xicDauDCA() > xicMaxDauDCA || xiccCand.xiccDauDCA() > xiccMaxDauDCA) + for (const auto& xiccCand : xiccCands) { + + histos.fill(HIST("hMCharmBuilding"), 0); + if (xiccCand.xicDauDCA() > xicMaxDauDCA) continue; - if (std::fabs(xiccCand.xiDCAxy()) < xiMinDCAxy || std::fabs(xiccCand.xiDCAz()) < xiMinDCAz) + histos.fill(HIST("hMCharmBuilding"), 1); + if (xiccCand.xiccDauDCA() > xiccMaxDauDCA) continue; - if (std::fabs(xiccCand.pi1cDCAxy()) < picMinDCAxy || std::fabs(xiccCand.pi1cDCAz()) < picMinDCAz) + histos.fill(HIST("hMCharmBuilding"), 2); + if (std::fabs(xiccCand.xiDCAxy()) < xiMinDCAxy) continue; - if (std::fabs(xiccCand.pi2cDCAxy()) < picMinDCAxy || std::fabs(xiccCand.pi2cDCAz()) < picMinDCAz) + histos.fill(HIST("hMCharmBuilding"), 3); + if (std::fabs(xiccCand.xiDCAz()) < xiMinDCAz) continue; - if (std::fabs(xiccCand.piccDCAxy()) < piccMinDCAxy || std::fabs(xiccCand.piccDCAz()) < piccMinDCAz) + histos.fill(HIST("hMCharmBuilding"), 4); + if (std::fabs(xiccCand.pi1cDCAxy()) < picMinDCAxy) continue; - if (std::fabs(xiccCand.xicDCAxy()) < xicMinDCAxy || std::fabs(xiccCand.xicDCAz()) < xicMinDCAz) + histos.fill(HIST("hMCharmBuilding"), 5); + if (std::fabs(xiccCand.pi1cDCAz()) < picMinDCAz) continue; - if (std::fabs(xiccCand.pi1cDCAxy()) < picMinDCAxy || std::fabs(xiccCand.pi1cDCAz()) < picMinDCAz) + histos.fill(HIST("hMCharmBuilding"), 6); + if (std::fabs(xiccCand.pi2cDCAxy()) < picMinDCAxy) continue; - if (std::fabs(xiccCand.pi2cDCAxy()) < picMinDCAxy || std::fabs(xiccCand.pi2cDCAz()) < picMinDCAz) + histos.fill(HIST("hMCharmBuilding"), 7); + if (std::fabs(xiccCand.pi2cDCAz()) < picMinDCAz) continue; - if (std::fabs(xiccCand.xiccDCAxy()) > xiccMaxDCAxy || std::fabs(xiccCand.xiccDCAz()) > xiccMaxDCAz) + histos.fill(HIST("hMCharmBuilding"), 8); + if (std::fabs(xiccCand.piccDCAxy()) < piccMinDCAxy) continue; - // Cut on time delta as LoI for now - if (xiccCand.pi1cTofDeltaInner() > picMaxTofDiffInner) + histos.fill(HIST("hMCharmBuilding"), 9); + if (std::fabs(xiccCand.piccDCAz()) < piccMinDCAz) continue; - if (xiccCand.pi2cTofDeltaInner() > picMaxTofDiffInner) + histos.fill(HIST("hMCharmBuilding"), 10); + if (std::fabs(xiccCand.xicDCAxy()) < xicMinDCAxy) continue; - if (xiccCand.piccTofDeltaInner() > piccMaxTofDiffInner) + histos.fill(HIST("hMCharmBuilding"), 11); + if (std::fabs(xiccCand.xicDCAz()) < xicMinDCAz) continue; - if (xiccCand.pi1cPt() < picMinPt || xiccCand.pi2cPt() < picMinPt) + histos.fill(HIST("hMCharmBuilding"), 12); + if (std::fabs(xiccCand.xiccDCAxy()) > xiccMaxDCAxy) continue; - if (xiccCand.piccPt() < piccMinPt) + histos.fill(HIST("hMCharmBuilding"), 13); + if (std::fabs(xiccCand.xiccDCAz()) > xiccMaxDCAz) continue; + histos.fill(HIST("hMCharmBuilding"), 14); if (xiccCand.xicDecayRadius2D() < xicMinRadius) continue; + histos.fill(HIST("hMCharmBuilding"), 15); if (xiccCand.xiccDecayRadius2D() < xiccMinRadius) continue; - if (xiccCand.xicProperLength() < xicMinProperLength || xiccCand.xicProperLength() > xicMaxProperLength) + histos.fill(HIST("hMCharmBuilding"), 16); + if (xiccCand.xicProperLength() < xicMinProperLength) + continue; + + histos.fill(HIST("hMCharmBuilding"), 17); + if (xiccCand.xicProperLength() > xicMaxProperLength) + continue; + + histos.fill(HIST("hMCharmBuilding"), 18); + if (xiccCand.xiccProperLength() < xiccMinProperLength) continue; - if (xiccCand.xiccProperLength() < xiccMinProperLength || xiccCand.xiccProperLength() > xiccMaxProperLength) + histos.fill(HIST("hMCharmBuilding"), 19); + if (xiccCand.xiccProperLength() > xiccMaxProperLength) continue; + histos.fill(HIST("hMCharmBuilding"), 20); if (xiccCand.xicDistanceFromPV() < xicMinDecayDistanceFromPV) continue; + histos.fill(HIST("hMCharmBuilding"), 21); histos.fill(HIST("SelectionQA/hDCAXicDaughters"), xiccCand.xicDauDCA() * 1e+4); histos.fill(HIST("SelectionQA/hDCAXiccDaughters"), xiccCand.xiccDauDCA() * 1e+4); histos.fill(HIST("SelectionQA/hDCAxyXi"), std::fabs(xiccCand.xiDCAxy() * 1e+4)); @@ -203,29 +292,74 @@ struct alice3multicharm { histos.fill(HIST("SelectionQA/hDCAzXic"), std::fabs(xiccCand.xicDCAz() * 1e+4)); histos.fill(HIST("SelectionQA/hDCAxyXicc"), std::fabs(xiccCand.xiccDCAxy() * 1e+4)); histos.fill(HIST("SelectionQA/hDCAzXicc"), std::fabs(xiccCand.xiccDCAz() * 1e+4)); + histos.fill(HIST("SelectionQA/hDecayRadiusXic"), xiccCand.xicDecayRadius2D() * 1e+4); + histos.fill(HIST("SelectionQA/hDecayRadiusXicc"), xiccCand.xiccDecayRadius2D() * 1e+4); + histos.fill(HIST("SelectionQA/hDecayDistanceFromPVXic"), xiccCand.xicDistanceFromPV() * 1e+4); + histos.fill(HIST("SelectionQA/hProperLengthXic"), xiccCand.xicProperLength() * 1e+4); + histos.fill(HIST("SelectionQA/hProperLengthXicc"), xiccCand.xiccProperLength() * 1e+4); histos.fill(HIST("SelectionQA/hPi1cPt"), xiccCand.pi1cPt()); histos.fill(HIST("SelectionQA/hPi2cPt"), xiccCand.pi2cPt()); histos.fill(HIST("SelectionQA/hPiccPt"), xiccCand.piccPt()); - histos.fill(HIST("SelectionQA/hXicDecayRadius"), xiccCand.xicDecayRadius2D() * 1e+4); - histos.fill(HIST("SelectionQA/hXiccDecayRadius"), xiccCand.xiccDecayRadius2D() * 1e+4); - histos.fill(HIST("SelectionQA/hXicDecayDistanceFromPV"), xiccCand.xicDistanceFromPV() * 1e+4); - histos.fill(HIST("SelectionQA/hProperLengthXic"), xiccCand.xicProperLength() * 1e+4); - histos.fill(HIST("SelectionQA/hProperLengthXicc"), xiccCand.xiccProperLength() * 1e+4); - histos.fill(HIST("SelectionQA/hInnerTofTimeDeltaPi1c"), xiccCand.pi1cTofDeltaInner()); - histos.fill(HIST("SelectionQA/hInnerTofTimeDeltaPi2c"), xiccCand.pi2cTofDeltaInner()); - histos.fill(HIST("SelectionQA/hInnerTofTimeDeltaPicc"), xiccCand.piccTofDeltaInner()); - - histos.fill(HIST("XiccProngs/h3dNeg"), xiccCand.pt(), xiccCand.negPt(), xiccCand.negEta()); - histos.fill(HIST("XiccProngs/h3dPos"), xiccCand.pt(), xiccCand.posPt(), xiccCand.posEta()); - histos.fill(HIST("XiccProngs/h3dBach"), xiccCand.pt(), xiccCand.bachPt(), xiccCand.bachEta()); - histos.fill(HIST("XiccProngs/h3dPi1c"), xiccCand.pt(), xiccCand.pi1cPt(), xiccCand.pi1cEta()); - histos.fill(HIST("XiccProngs/h3dPi2c"), xiccCand.pt(), xiccCand.pi2cPt(), xiccCand.pi2cEta()); - histos.fill(HIST("XiccProngs/h3dPicc"), xiccCand.pt(), xiccCand.piccPt(), xiccCand.piccEta()); - histos.fill(HIST("h3dXicc"), xiccCand.pt(), xiccCand.eta(), xiccCand.xiccMass()); + + if constexpr (requires { xiccCand.pi1cTofDeltaInner(); }) { // if pid table + histos.fill(HIST("PIDQA/hInnerTofTimeDeltaPi1c"), xiccCand.pi1cTofDeltaInner()); + histos.fill(HIST("PIDQA/hInnerTofTimeDeltaPi2c"), xiccCand.pi2cTofDeltaInner()); + histos.fill(HIST("PIDQA/hInnerTofTimeDeltaPicc"), xiccCand.piccTofDeltaInner()); + histos.fill(HIST("PIDQA/hOuterTofTimeDeltaPi1c"), xiccCand.pi1cTofDeltaOuter()); + histos.fill(HIST("PIDQA/hOuterTofTimeDeltaPi2c"), xiccCand.pi2cTofDeltaOuter()); + histos.fill(HIST("PIDQA/hOuterTofTimeDeltaPicc"), xiccCand.piccTofDeltaOuter()); + histos.fill(HIST("PIDQA/hInnerTofNSigmaPi1c"), xiccCand.pi1cPt(), xiccCand.pi1cTofNSigmaInner()); + histos.fill(HIST("PIDQA/hOuterTofNSigmaPi1c"), xiccCand.pi1cPt(), xiccCand.pi1cTofNSigmaOuter()); + histos.fill(HIST("PIDQA/hInnerTofNSigmaPi2c"), xiccCand.pi2cPt(), xiccCand.pi2cTofNSigmaInner()); + histos.fill(HIST("PIDQA/hOuterTofNSigmaPi2c"), xiccCand.pi2cPt(), xiccCand.pi2cTofNSigmaOuter()); + histos.fill(HIST("PIDQA/hInnerTofNSigmaPicc"), xiccCand.piccPt(), xiccCand.piccTofNSigmaInner()); + histos.fill(HIST("PIDQA/hOuterTofNSigmaPicc"), xiccCand.piccPt(), xiccCand.piccTofNSigmaOuter()); + if (xiccCand.pi1cHasRichSignal()) { + histos.fill(HIST("PIDQA/hRichNSigmaPi1c"), xiccCand.pi1cPt(), xiccCand.pi1cRichNSigma()); + } + if (xiccCand.pi2cHasRichSignal()) { + histos.fill(HIST("PIDQA/hRichNSigmaPi2c"), xiccCand.pi2cPt(), xiccCand.pi2cRichNSigma()); + } + if (xiccCand.piccHasRichSignal()) { + histos.fill(HIST("PIDQA/hRichNSigmaPicc"), xiccCand.piccPt(), xiccCand.piccRichNSigma()); + } + + histos.fill(HIST("PIDQA/hPdgCodes"), 1, pdgToBin.at(std::abs(xiccCand.pi1cPdgCode()))); + histos.fill(HIST("PIDQA/hPdgCodes"), 2, pdgToBin.at(std::abs(xiccCand.pi2cPdgCode()))); + histos.fill(HIST("PIDQA/hPdgCodes"), 3, pdgToBin.at(std::abs(xiccCand.piccPdgCode()))); + } + + if constexpr (requires { xiccCand.negPt(); }) { // if extra table + histos.fill(HIST("XiccProngs/h3dNeg"), xiccCand.xiccPt(), xiccCand.negPt(), xiccCand.negEta()); + histos.fill(HIST("XiccProngs/h3dPos"), xiccCand.xiccPt(), xiccCand.posPt(), xiccCand.posEta()); + histos.fill(HIST("XiccProngs/h3dBach"), xiccCand.xiccPt(), xiccCand.bachPt(), xiccCand.bachEta()); + histos.fill(HIST("XiccProngs/h3dPi1c"), xiccCand.xiccPt(), xiccCand.pi1cPt(), xiccCand.pi1cEta()); + histos.fill(HIST("XiccProngs/h3dPi2c"), xiccCand.xiccPt(), xiccCand.pi2cPt(), xiccCand.pi2cEta()); + histos.fill(HIST("XiccProngs/h3dPicc"), xiccCand.xiccPt(), xiccCand.piccPt(), xiccCand.piccEta()); + } + + histos.fill(HIST("h3dXicc"), xiccCand.xiccPt(), xiccCand.xiccEta(), xiccCand.xiccMass()); } } + void processXicc(aod::MCharmCores const& multiCharmTracks) + { + genericProcessXicc(multiCharmTracks); + } + + void processXiccPID(multiCharmTracksPID const& multiCharmTracks) + { + genericProcessXicc(multiCharmTracks); + } + + void processXiccExtra(multiCharmTracksFull const& multiCharmTracks) + { + genericProcessXicc(multiCharmTracks); + } + PROCESS_SWITCH(alice3multicharm, processXicc, "find Xicc baryons", true); + PROCESS_SWITCH(alice3multicharm, processXiccPID, "find Xicc baryons with more QA from PID information", false); + PROCESS_SWITCH(alice3multicharm, processXiccExtra, "find Xicc baryons with all QA", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)