diff --git a/ALICE3/DataModel/OTFMulticharm.h b/ALICE3/DataModel/OTFMulticharm.h index 7dbde7bdc9a..c04ad88b4bf 100644 --- a/ALICE3/DataModel/OTFMulticharm.h +++ b/ALICE3/DataModel/OTFMulticharm.h @@ -10,10 +10,11 @@ // or submit itself to any jurisdiction. /// -/// \file OTFStrangeness.h +/// \file OTFMulticharm.h /// \author David Dobrigkeit Chinellato +/// \author Jesper Karlsson Gumprecht /// \since 05/08/2024 -/// \brief Set of tables for the ALICE3 strangeness information +/// \brief Set of tables for the ALICE3 multi-charm information /// #ifndef ALICE3_DATAMODEL_OTFMULTICHARM_H_ @@ -31,45 +32,72 @@ DECLARE_SOA_INDEX_COLUMN_FULL(XiCPion1, xiCPion1, int, Tracks, "_Pi1XiC"); DECLARE_SOA_INDEX_COLUMN_FULL(XiCPion2, xiCPion2, int, Tracks, "_Pi2XiC"); DECLARE_SOA_INDEX_COLUMN_FULL(XiCCPion, xiCCPion, int, Tracks, "_PiXiCC"); -// topo vars -DECLARE_SOA_COLUMN(DCAXiCDaughters, dcaXiCDaughters, float); -DECLARE_SOA_COLUMN(DCAXiCCDaughters, dcaXiCCDaughters, float); - -DECLARE_SOA_COLUMN(MXiC, mXiC, float); -DECLARE_SOA_COLUMN(MXiCC, mXiCC, float); +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); -// tracking counters -DECLARE_SOA_COLUMN(NSiliconHitsXi, nSiliconHitsXi, int); -DECLARE_SOA_COLUMN(NSiliconHitsPiFromXi, nSiliconHitsPiFromXi, int); -DECLARE_SOA_COLUMN(NSiliconHitsPiFromLa, nSiliconHitsPiFromLa, int); -DECLARE_SOA_COLUMN(NSiliconHitsPrFromLa, nSiliconHitsPrFromLa, int); -DECLARE_SOA_COLUMN(NSiliconHitsPiC1, nSiliconHitsPiC1, int); -DECLARE_SOA_COLUMN(NSiliconHitsPiC2, nSiliconHitsPiC2, int); -DECLARE_SOA_COLUMN(NSiliconHitsPiCC, nSiliconHitsPiCC, int); - -DECLARE_SOA_COLUMN(NTPCHitsPiFromXi, nTPCHitsPiFromXi, int); -DECLARE_SOA_COLUMN(NTPCHitsPiFromLa, nTPCHitsPiFromLa, int); -DECLARE_SOA_COLUMN(NTPCHitsPrFromLa, nTPCHitsPrFromLa, int); -DECLARE_SOA_COLUMN(NTPCHitsPiC1, nTPCHitsPiC1, int); -DECLARE_SOA_COLUMN(NTPCHitsPiC2, nTPCHitsPiC2, int); -DECLARE_SOA_COLUMN(NTPCHitsPiCC, nTPCHitsPiCC, int); - -// DCA to PV variables -DECLARE_SOA_COLUMN(DCAToPVXi, dcaToPVXi, float); -DECLARE_SOA_COLUMN(DCAToPVXiC, dcaToPVXiC, float); -DECLARE_SOA_COLUMN(DCAToPVXiCC, dcaToPVXiCC, float); - -DECLARE_SOA_COLUMN(DCAToPVPiFromXi, dcaToPVPiFromXi, float); -DECLARE_SOA_COLUMN(DCAToPVPiFromLa, dcaToPVPiFromLa, float); -DECLARE_SOA_COLUMN(DCAToPVPrFromLa, dcaToPVPrFromLa, float); - -DECLARE_SOA_COLUMN(DCAToPVPiC1, dcaToPVPiC1, float); -DECLARE_SOA_COLUMN(DCAToPVPiC2, dcaToPVPiC2, float); -DECLARE_SOA_COLUMN(DCAToPVPiCC, dcaToPVPiCC, float); +// topo vars +DECLARE_SOA_COLUMN(XiDCAz, xiDCAz, float); +DECLARE_SOA_COLUMN(XiDCAxy, xiDCAxy, float); +DECLARE_SOA_COLUMN(XicDauDCA, xicDauDCA, float); +DECLARE_SOA_COLUMN(XicDCAxy, xicDCAxy, float); +DECLARE_SOA_COLUMN(XicDCAz, xicDCAz, float); +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(Pi1cDCAxy, pi1cDCAxy, float); +DECLARE_SOA_COLUMN(Pi2cDCAxy, pi2cDCAxy, float); +DECLARE_SOA_COLUMN(PiccDCAxy, piccDCAxy, float); +DECLARE_SOA_COLUMN(Pi1cDCAz, pi1cDCAz, float); +DECLARE_SOA_COLUMN(Pi2cDCAz, pi2cDCAz, float); +DECLARE_SOA_COLUMN(PiccDCAz, piccDCAz, float); + +// Lengths +DECLARE_SOA_COLUMN(XicDecayRadius2D, xicDecayRadius2D, float); +DECLARE_SOA_COLUMN(XiccDecayRadius2D, xiccDecayRadius2D, float); +DECLARE_SOA_COLUMN(XicProperLength, xicProperLength, float); +DECLARE_SOA_COLUMN(XicDistanceFromPV, xicDistanceFromPV, float); +DECLARE_SOA_COLUMN(XiccProperLength, xiccProperLength, float); + +// PID +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(Pi2cTofDeltaInner, pi2cTofDeltaInner, float); +DECLARE_SOA_COLUMN(Pi2cTofNSigmaInner, pi2cTofNSigmaInner, float); +DECLARE_SOA_COLUMN(Pi2cTofDeltaOuter, pi2cTofDeltaOuter, float); +DECLARE_SOA_COLUMN(Pi2cTofNSigmaOuter, pi2cTofNSigmaOuter, float); +DECLARE_SOA_COLUMN(PiccTofDeltaInner, piccTofDeltaInner, float); +DECLARE_SOA_COLUMN(PiccTofNSigmaInner, piccTofNSigmaInner, float); +DECLARE_SOA_COLUMN(PiccTofDeltaOuter, piccTofDeltaOuter, float); +DECLARE_SOA_COLUMN(PiccTofNSigmaOuter, piccTofNSigmaOuter, float); + +// Daughter info +DECLARE_SOA_COLUMN(PosPt, posPt, float); +DECLARE_SOA_COLUMN(PosEta, posEta, float); +DECLARE_SOA_COLUMN(NegPt, negPt, float); +DECLARE_SOA_COLUMN(NegEta, negEta, float); +DECLARE_SOA_COLUMN(BachPt, bachPt, float); +DECLARE_SOA_COLUMN(BachEta, bachEta, float); +DECLARE_SOA_COLUMN(BachPhi, bachPhi, float); +DECLARE_SOA_COLUMN(Pi1cPt, pi1cPt, float); +DECLARE_SOA_COLUMN(Pi1cEta, pi1cEta, float); +DECLARE_SOA_COLUMN(Pi2cPt, pi2cPt, float); +DECLARE_SOA_COLUMN(Pi2cEta, pi2cEta, float); +DECLARE_SOA_COLUMN(PiccPt, piccPt, float); +DECLARE_SOA_COLUMN(PiccEta, piccEta, float); } // namespace otfmulticharm DECLARE_SOA_TABLE(MCharmIndices, "AOD", "MCharmIndices", @@ -80,36 +108,72 @@ DECLARE_SOA_TABLE(MCharmIndices, "AOD", "MCharmIndices", otfmulticharm::XiCCPionId); DECLARE_SOA_TABLE(MCharmCores, "AOD", "MCharmCores", - otfmulticharm::DCAXiCDaughters, - otfmulticharm::DCAXiCCDaughters, - otfmulticharm::MXiC, - otfmulticharm::MXiCC, + otfmulticharm::XicDauDCA, + otfmulticharm::XiccDauDCA, + otfmulticharm::XicMass, + otfmulticharm::XiccMass, otfmulticharm::Pt, otfmulticharm::Eta, - otfmulticharm::NSiliconHitsXi, - otfmulticharm::NSiliconHitsPiFromXi, - otfmulticharm::NSiliconHitsPiFromLa, - otfmulticharm::NSiliconHitsPrFromLa, - otfmulticharm::NSiliconHitsPiC1, - otfmulticharm::NSiliconHitsPiC2, - otfmulticharm::NSiliconHitsPiCC, - otfmulticharm::NTPCHitsPiFromXi, - otfmulticharm::NTPCHitsPiFromLa, - otfmulticharm::NTPCHitsPrFromLa, - otfmulticharm::NTPCHitsPiC1, - otfmulticharm::NTPCHitsPiC2, - otfmulticharm::NTPCHitsPiCC, - - otfmulticharm::DCAToPVXi, - otfmulticharm::DCAToPVXiC, - otfmulticharm::DCAToPVXiCC, - otfmulticharm::DCAToPVPiFromXi, - otfmulticharm::DCAToPVPiFromLa, - otfmulticharm::DCAToPVPrFromLa, - otfmulticharm::DCAToPVPiC1, - otfmulticharm::DCAToPVPiC2, - otfmulticharm::DCAToPVPiCC); + otfmulticharm::XiDCAxy, + otfmulticharm::XicDCAxy, + otfmulticharm::XiccDCAxy, + otfmulticharm::XiDCAz, + otfmulticharm::XicDCAz, + otfmulticharm::XiccDCAz, + + otfmulticharm::PiFromXiDCAxy, + otfmulticharm::PiFromLaDCAxy, + otfmulticharm::PrFromLaDCAxy, + otfmulticharm::PiFromXiDCAz, + otfmulticharm::PiFromLaDCAz, + otfmulticharm::PrFromLaDCAz, + + otfmulticharm::Pi1cDCAxy, + otfmulticharm::Pi2cDCAxy, + otfmulticharm::PiccDCAxy, + otfmulticharm::Pi1cDCAz, + otfmulticharm::Pi2cDCAz, + otfmulticharm::PiccDCAz, + + otfmulticharm::XicDecayRadius2D, + otfmulticharm::XiccDecayRadius2D, + otfmulticharm::XicProperLength, + otfmulticharm::XicDistanceFromPV, + otfmulticharm::XiccProperLength, + + otfmulticharm::Pi1cTofDeltaInner, + otfmulticharm::Pi1cTofNSigmaInner, + otfmulticharm::Pi1cTofDeltaOuter, + otfmulticharm::Pi1cTofNSigmaOuter, + + otfmulticharm::Pi2cTofDeltaInner, + otfmulticharm::Pi2cTofNSigmaInner, + otfmulticharm::Pi2cTofDeltaOuter, + otfmulticharm::Pi2cTofNSigmaOuter, + + otfmulticharm::PiccTofDeltaInner, + otfmulticharm::PiccTofNSigmaInner, + otfmulticharm::PiccTofDeltaOuter, + otfmulticharm::PiccTofNSigmaOuter, + + otfmulticharm::BachPt, + otfmulticharm::BachEta, + + otfmulticharm::PosPt, + otfmulticharm::PosEta, + + otfmulticharm::NegPt, + otfmulticharm::NegEta, + + otfmulticharm::Pi1cPt, + otfmulticharm::Pi1cEta, + + otfmulticharm::Pi2cPt, + otfmulticharm::Pi2cEta, + + otfmulticharm::PiccPt, + otfmulticharm::PiccEta); } // namespace o2::aod diff --git a/ALICE3/TableProducer/CMakeLists.txt b/ALICE3/TableProducer/CMakeLists.txt index 8548ecd9897..d0b7afce076 100644 --- a/ALICE3/TableProducer/CMakeLists.txt +++ b/ALICE3/TableProducer/CMakeLists.txt @@ -41,8 +41,8 @@ o2physics_add_dpl_workflow(alice3-decayfinder PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DCAFitter COMPONENT_NAME Analysis) -o2physics_add_dpl_workflow(alice3-multicharm - SOURCES alice3-multicharm.cxx +o2physics_add_dpl_workflow(alice3-multicharm-table + SOURCES alice3-multicharmTable.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DCAFitter COMPONENT_NAME Analysis) diff --git a/ALICE3/TableProducer/alice3-multicharm.cxx b/ALICE3/TableProducer/alice3-multicharmTable.cxx similarity index 90% rename from ALICE3/TableProducer/alice3-multicharm.cxx rename to ALICE3/TableProducer/alice3-multicharmTable.cxx index 74948cfdf11..16b16c666d8 100644 --- a/ALICE3/TableProducer/alice3-multicharm.cxx +++ b/ALICE3/TableProducer/alice3-multicharmTable.cxx @@ -71,7 +71,7 @@ using tofTracks = soa::Join; using richTracks = soa::Join; using alice3tracks = soa::Join; -struct alice3multicharm { +struct alice3multicharmTable { SliceCache cache; Produces multiCharmIdx; @@ -131,8 +131,6 @@ struct alice3multicharm { ConfigurableAxis axisDecayLength{"axisDecayLength", {2000, 0, 2000}, "Decay lenght (#mum)"}; ConfigurableAxis axisTOFTrack{"axisTOFTrack", {1000, 0, 5000}, "TOF track time"}; - ConfigurableAxis axisPiMass{"axisPiMass", {200, 0.089f, 0.189f}, "Pi Inv Mass (GeV/c^{2})"}; - ConfigurableAxis axisPrMass{"axisPrMass", {200, 0.838f, 1.038f}, "Pr Inv Mass (GeV/c^{2})"}; ConfigurableAxis axisXiMass{"axisXiMass", {200, 1.221f, 1.421f}, "Xi Inv Mass (GeV/c^{2})"}; ConfigurableAxis axisXiCMass{"axisXiCMass", {200, 2.368f, 2.568f}, "XiC Inv Mass (GeV/c^{2})"}; ConfigurableAxis axisXiCCMass{"axisXiCCMass", {200, 3.521f, 3.721f}, "XiCC Inv Mass (GeV/c^{2})"}; @@ -414,15 +412,7 @@ struct alice3multicharm { histos.add("hEtaXiCC", "hEtaXiCC", kTH1D, {axisEta}); histos.add("hPtXiCC", "hPtXiCC", kTH1D, {axisPt}); - histos.add("h3dXicc", "h3dXicc", kTH3D, {axisPt, axisEta, axisXiCCMass}); - histos.add("h3dXic", "h3dXic", kTH3D, {axisPt, axisEta, axisXiCMass}); - histos.add("h3dXi", "h3dXi", kTH3D, {axisPt, axisEta, axisXiMass}); - histos.add("h3dPicc", "h3dPicc", kTH3D, {axisPt, axisEta, axisPiMass}); - histos.add("h3dPi1c", "h3dPi1c", kTH3D, {axisPt, axisEta, axisPiMass}); - histos.add("h3dPi2c", "h3dPi2c", kTH3D, {axisPt, axisEta, axisPiMass}); - histos.add("h3dBach", "h3dBach", kTH3D, {axisPt, axisEta, axisPiMass}); - histos.add("h3dPos", "h3dPos", kTH3D, {axisPt, axisEta, axisPrMass}); - histos.add("h3dNeg", "h3dNeg", kTH3D, {axisPt, axisEta, axisPiMass}); + histos.add("h3dMassXiCC", "h3dMassXiCC", kTH3D, {axisPt, axisEta, axisXiCCMass}); histos.add("hDCAXiCDaughters", "hDCAXiCDaughters", kTH1D, {axisDCAXiCDaughters}); histos.add("hDCAXiCCDaughters", "hDCAXiCCDaughters", kTH1D, {axisDCAXiCCDaughters}); @@ -526,11 +516,6 @@ struct alice3multicharm { auto piFromLa = xiCand.negTrack_as(); // de-reference neg track auto prFromLa = xiCand.posTrack_as(); // de-reference pos track - histos.fill(HIST("h3dXi"), xi.pt(), xi.eta(), xiCand.mXi()); - histos.fill(HIST("h3dBach"), piFromXi.pt(), piFromXi.eta(), o2::constants::physics::MassPionCharged); - histos.fill(HIST("h3dNeg"), piFromLa.pt(), piFromLa.eta(), o2::constants::physics::MassPionCharged); - histos.fill(HIST("h3dPos"), prFromLa.pt(), prFromLa.eta(), o2::constants::physics::MassProton); - if (!bitcheck(xi.decayMap(), kTrueXiFromXiC)) continue; @@ -554,11 +539,11 @@ struct alice3multicharm { continue; // too low momentum histos.fill(HIST("hPi1cPt"), pi1c.pt()); - double pi1cTOFDiffInner = std::fabs(pi1c.innerTOFTrackTimeReco() - pi1c.innerTOFExpectedTimePi()); + float pi1cTOFDiffInner = std::fabs(pi1c.innerTOFTrackTimeReco() - pi1c.innerTOFExpectedTimePi()); + float pi1cTOFDiffOuter = std::fabs(pi1c.outerTOFTrackTimeReco() - pi1c.outerTOFExpectedTimePi()); if (pi1cTOFDiffInner > piFromXiC_tofDiffInner) continue; // did not arrive at expected time - histos.fill(HIST("h3dPi1c"), pi1c.pt(), pi1c.eta(), o2::constants::physics::MassPionCharged); histos.fill(HIST("hInnerTOFTrackTimeRecoPi1c"), pi1cTOFDiffInner); // second pion from XiC decay for starts here for (auto const& pi2c : tracksPiFromXiCgrouped) { @@ -575,13 +560,12 @@ struct alice3multicharm { continue; // too low momentum histos.fill(HIST("hPi2cPt"), pi2c.pt()); - double pi2cTOFDiffInner = std::fabs(pi2c.innerTOFTrackTimeReco() - pi2c.innerTOFExpectedTimePi()); + float pi2cTOFDiffInner = std::fabs(pi2c.innerTOFTrackTimeReco() - pi2c.innerTOFExpectedTimePi()); + float pi2cTOFDiffOuter = std::fabs(pi2c.outerTOFTrackTimeReco() - pi2c.outerTOFExpectedTimePi()); if (pi2cTOFDiffInner > piFromXiC_tofDiffInner) continue; // did not arrive at expected time histos.fill(HIST("hInnerTOFTrackTimeRecoPi2c"), pi2cTOFDiffInner); - histos.fill(HIST("h3dPi2c"), pi2c.pt(), pi2c.eta(), o2::constants::physics::MassPionCharged); - // if I am here, it means this is a triplet to be considered for XiC vertexing. // will now attempt to build a three-body decay candidate with these three track rows. @@ -603,7 +587,7 @@ struct alice3multicharm { thisXiCcandidate.prong0mom[2] + thisXiCcandidate.prong1mom[2] + thisXiCcandidate.prong2mom[2]}; o2::track::TrackParCov xicTrack(thisXiCcandidate.xyz, momentumC, thisXiCcandidate.parentTrackCovMatrix, +1); - double xicDecayRadius2D = std::hypot(thisXiCcandidate.xyz[0], thisXiCcandidate.xyz[1]); + float xicDecayRadius2D = std::hypot(thisXiCcandidate.xyz[0], thisXiCcandidate.xyz[1]); if (xicDecayRadius2D < minXiCRadius) continue; // do not take if radius too small, likely a primary combination @@ -631,7 +615,7 @@ struct alice3multicharm { histos.fill(HIST("hDCAxyXiC"), std::fabs(xicdcaXY * 1e+4)); histos.fill(HIST("hDCAzXiC"), std::fabs(xicdcaZ * 1e+4)); histos.fill(HIST("hMassXiC"), thisXiCcandidate.mass); - histos.fill(HIST("h3dXic"), thisXiCcandidate.pt, thisXiCcandidate.eta, thisXiCcandidate.mass); + // attempt XiCC finding uint32_t nCombinationsCC = 0; for (auto const& picc : tracksPiFromXiCCgrouped) { @@ -646,12 +630,12 @@ struct alice3multicharm { histos.fill(HIST("hPiccPt"), picc.pt()); - double piccTOFDiffInner = std::fabs(picc.innerTOFTrackTimeReco() - picc.innerTOFExpectedTimePi()); + float piccTOFDiffInner = std::fabs(picc.innerTOFTrackTimeReco() - picc.innerTOFExpectedTimePi()); + float piccTOFDiffOuter = std::fabs(picc.outerTOFTrackTimeReco() - picc.outerTOFExpectedTimePi()); if (piccTOFDiffInner > piFromXiCC_tofDiffInner) continue; // did not arrive at expected time histos.fill(HIST("hInnerTOFTrackTimeRecoPicc"), piccTOFDiffInner); - histos.fill(HIST("h3dPicc"), picc.pt(), picc.eta(), o2::constants::physics::MassPionCharged); o2::track::TrackParCov piccTrack = getTrackParCov(picc); nCombinationsCC++; @@ -667,40 +651,40 @@ struct alice3multicharm { thisXiCCcandidate.prong0mom[2] + thisXiCCcandidate.prong1mom[2]}; o2::track::TrackParCov xiccTrack(thisXiCCcandidate.xyz, momentumCC, thisXiCCcandidate.parentTrackCovMatrix, +2); - double xiccDecayRadius2D = std::hypot(thisXiCCcandidate.xyz[0], thisXiCCcandidate.xyz[1]); + float xiccDecayRadius2D = std::hypot(thisXiCCcandidate.xyz[0], thisXiCCcandidate.xyz[1]); if (xiccDecayRadius2D < minXiCCRadius) continue; // do not take if radius too small, likely a primary combination histos.fill(HIST("hMinXiCCDecayRadius"), xiccDecayRadius2D * 1e+4); - double totalMomentumC = std::hypot(momentumC[0], momentumC[1], momentumC[2]); - double decayLengthXiC = std::hypot( + float totalMomentumC = std::hypot(momentumC[0], momentumC[1], momentumC[2]); + float decayLengthXiC = std::hypot( thisXiCcandidate.xyz[0] - thisXiCCcandidate.xyz[0], thisXiCcandidate.xyz[1] - thisXiCCcandidate.xyz[1], thisXiCcandidate.xyz[2] - thisXiCCcandidate.xyz[2]); - double xicProperLength = decayLengthXiC * thisXiCcandidate.mass / totalMomentumC; + float xicProperLength = decayLengthXiC * thisXiCcandidate.mass / totalMomentumC; if (xicProperLength < xicMinProperLength || xicProperLength > xicMaxProperLength) continue; // likely background histos.fill(HIST("hProperLengthXiC"), xicProperLength * 1e+4); - double xicDistanceFromPV = std::hypot( + float xicDistanceFromPV = std::hypot( thisXiCcandidate.xyz[0] - collision.posX(), thisXiCcandidate.xyz[1] - collision.posY(), thisXiCcandidate.xyz[2] - collision.posZ()); - double xicDecayDistanceFromPV = xicDistanceFromPV * thisXiCcandidate.mass / totalMomentumC; + float xicDecayDistanceFromPV = xicDistanceFromPV * thisXiCcandidate.mass / totalMomentumC; if (xicDecayDistanceFromPV < xicMinDecayDistanceFromPV) continue; // too close to PV histos.fill(HIST("hMinxicDecayDistanceFromPV"), xicDecayDistanceFromPV * 1e+4); - double totalMomentumCC = std::hypot(momentumCC[0], momentumCC[1], momentumCC[2]); - double decayLengthXiCC = std::hypot( + float totalMomentumCC = std::hypot(momentumCC[0], momentumCC[1], momentumCC[2]); + float decayLengthXiCC = std::hypot( thisXiCCcandidate.xyz[0] - collision.posX(), thisXiCCcandidate.xyz[1] - collision.posY(), thisXiCCcandidate.xyz[2] - collision.posZ()); - double xiccProperLength = decayLengthXiCC * thisXiCCcandidate.mass / totalMomentumCC; + float xiccProperLength = decayLengthXiCC * thisXiCCcandidate.mass / totalMomentumCC; if (xiccProperLength < xiccMinProperLength || xiccProperLength > xicMaxProperLength) continue; // likely background @@ -729,22 +713,43 @@ struct alice3multicharm { histos.fill(HIST("hMassXiCC"), thisXiCCcandidate.mass); histos.fill(HIST("hPtXiCC"), thisXiCCcandidate.pt); histos.fill(HIST("hEtaXiCC"), thisXiCCcandidate.eta); - histos.fill(HIST("h3dXicc"), thisXiCCcandidate.pt, thisXiCCcandidate.eta, thisXiCCcandidate.mass); + histos.fill(HIST("h3dMassXiCC"), thisXiCCcandidate.pt, thisXiCCcandidate.eta, thisXiCCcandidate.mass); // produce multi-charm table for posterior analysis if (fillDerivedTable) { + multiCharmIdx( + xiCand.globalIndex(), + pi1c.globalIndex(), pi2c.globalIndex(), + picc.globalIndex()); + multiCharmCore( thisXiCcandidate.dca, thisXiCCcandidate.dca, thisXiCcandidate.mass, thisXiCCcandidate.mass, thisXiCCcandidate.pt, thisXiCCcandidate.eta, - xi.nSiliconHits(), piFromXi.nSiliconHits(), - piFromLa.nSiliconHits(), prFromLa.nSiliconHits(), - pi1c.nSiliconHits(), pi2c.nSiliconHits(), picc.nSiliconHits(), - piFromXi.nTPCHits(), piFromLa.nTPCHits(), prFromLa.nTPCHits(), - pi1c.nTPCHits(), pi2c.nTPCHits(), picc.nTPCHits(), - xi.dcaXY(), xicdcaXY, xiccdcaXY, - piFromXi.dcaXY(), piFromLa.dcaXY(), prFromLa.dcaXY(), - pi1c.dcaXY(), pi2c.dcaXY(), picc.dcaXY()); + 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, + xiccProperLength, + pi1cTOFDiffInner, pi1c.nSigmaPionInnerTOF(), + pi1cTOFDiffOuter, pi1c.nSigmaPionOuterTOF(), + pi2cTOFDiffInner, pi2c.nSigmaPionInnerTOF(), + pi2cTOFDiffOuter, pi2c.nSigmaPionOuterTOF(), + piccTOFDiffInner, picc.nSigmaPionInnerTOF(), + piccTOFDiffOuter, picc.nSigmaPionOuterTOF(), + piFromXi.pt(), piFromXi.eta(), + prFromLa.pt(), prFromLa.eta(), + piFromLa.pt(), piFromLa.eta(), + pi1c.pt(), pi1c.eta(), + pi2c.pt(), pi2c.eta(), + picc.pt(), picc.eta()); } } histos.fill(HIST("hCombinationsXiCC"), nCombinationsCC); @@ -756,13 +761,13 @@ struct alice3multicharm { //*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* //*>-~-<*>-~-<*>-~-<*>-~-<*>-~-<*>-~-<*>-~-<*>-~-<* - PROCESS_SWITCH(alice3multicharm, processGenerated, "fill MC-only histograms", true); - PROCESS_SWITCH(alice3multicharm, processFindXiCC, "find XiCC baryons", true); + PROCESS_SWITCH(alice3multicharmTable, processGenerated, "fill MC-only histograms", true); + PROCESS_SWITCH(alice3multicharmTable, processFindXiCC, "find XiCC baryons", true); //*>-~-<*>-~-<*>-~-<*>-~-<*>-~-<*>-~-<*>-~-<*>-~-<* }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{ - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(cfgc)}; } diff --git a/ALICE3/Tasks/CMakeLists.txt b/ALICE3/Tasks/CMakeLists.txt index ddf9008e667..8fb4c79ea12 100644 --- a/ALICE3/Tasks/CMakeLists.txt +++ b/ALICE3/Tasks/CMakeLists.txt @@ -59,6 +59,11 @@ o2physics_add_dpl_workflow(alice3-taskcorrelationddbar PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(alice3-multicharm + SOURCES alice3-multicharm.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(alice3-efficiency SOURCES alice3Efficiency.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore diff --git a/ALICE3/Tasks/alice3-multicharm.cxx b/ALICE3/Tasks/alice3-multicharm.cxx new file mode 100644 index 00000000000..34276a800b3 --- /dev/null +++ b/ALICE3/Tasks/alice3-multicharm.cxx @@ -0,0 +1,235 @@ +// 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. +// +// *+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* +// Decay finder task for ALICE 3 +// *+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* +// +// Uses specific ALICE 3 PID and performance for studying +// HF decays. Work in progress: use at your own risk! +// + +#include +#include +#include +#include +#include +#include + +#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 "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/DataModel/TrackSelectionTables.h" +#include "DetectorsBase/Propagator.h" +#include "DetectorsBase/GeometryManager.h" +#include "DataFormatsParameters/GRPObject.h" +#include "DataFormatsParameters/GRPMagField.h" +#include "CCDB/BasicCCDBManager.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 "DetectorsVertexing/PVertexer.h" +#include "DetectorsVertexing/PVertexerHelpers.h" +#include "CommonConstants/PhysicsConstants.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +using multicharmtracks = soa::Join; + +struct alice3multicharm { + SliceCache cache; + + 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 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"}; + + Configurable xiMinDCAxy{"xiMinDCAxy", -1, "[0] in |DCAxy| > [0]+[1]/pT"}; + Configurable xiMinDCAz{"xiMinDCAz", -1, "[0] in |DCAz| > [0]+[1]/pT"}; + Configurable xiMinRadius{"xiMinRadius", -1, "Minimum R2D for Xic decay (cm)"}; + + Configurable picMinDCAxy{"picMinDCAxy", -1, "[0] in |DCAz| > [0]+[1]/pT"}; + Configurable picMinDCAz{"picMinDCAz", -1, "[0] in |DCAxy| > [0]+[1]/pT"}; + Configurable picMaxTofDiffInner{"picTofDiffInner", 1e+4, "|signal - expected| (ps)"}; + Configurable picMinPt{"picMinPt", -1, "Minimum pT for Xic pions"}; + + Configurable piccMinDCAxy{"piccMinDCAxy", -1, "[0] in |DCAxy| > [0]+[1]/pT"}; + Configurable piccMinDCAz{"piccMinDCAz", -1, "[0] in |DCAz| > [0]+[1]/pT"}; + Configurable piccMaxTofDiffInner{"piccMaxTofDiffInner", 1e+4, "|signal - expected| (ps)"}; + Configurable piccMinPt{"piccMinPt", -1, "Minimum pT for Xicc pions"}; + + Configurable xicMaxDauDCA{"xicMaxDauDCA", 1e+4, "DCA between Xic daughters (cm)"}; + Configurable xicMinDCAxy{"xicMinDCAxy", -1, "[0] in |DCAz| > [0]+[1]/pT"}; + Configurable xicMinDCAz{"xicMinDCAz", -1, "[0] in |DCAxy| > [0]+[1]/pT"}; + Configurable xiccMaxDCAxy{"xiccMaxDCAxy", 1e+4, "Maximum DCAxy"}; + Configurable xiccMaxDCAz{"xiccMaxDCAz", 1e+4, "Maximum DCAz"}; + Configurable xicMinRadius{"xicMinRadius", -1, "Minimum R2D for Xic decay (cm)"}; + Configurable xicMinDecayDistanceFromPV{"xicMinDecayDistanceFromPV", -1, "Minimum distance for Xic decay from PV (cm)"}; + Configurable xicMinProperLength{"xicMinProperLength", -1, "Minimum proper length for Xic decay (cm)"}; + Configurable xicMaxProperLength{"xicMaxProperLength", 1e+4, "Minimum proper length for Xic decay (cm)"}; + + Configurable xiccMaxDauDCA{"xiccMaxDauDCA", 1e+4, "DCA between Xicc daughters (cm)"}; + Configurable xiccMinRadius{"xiccMinRadius", -1, "Minimum R2D for Xicc decay (cm)"}; + 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}); + histos.add("SelectionQA/hDCAXiccDaughters", "hDCAXiccDaughters; DCA between Xicc daughters (#mum)", kTH1D, {axisDcaDaughters}); + histos.add("SelectionQA/hDCAxyXi", "hDCAxyXi; Xi DCAxy to PV (#mum)", kTH1D, {axisDCA}); + histos.add("SelectionQA/hDCAzXi", "hDCAzXi; Xi DCAz to PV (#mum)", kTH1D, {axisDCA}); + histos.add("SelectionQA/hDCAxyXic", "hDCAxyXic; Xic DCAxy to PV (#mum)", kTH1D, {axisDCA}); + 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/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}); + histos.add("h3dXicc", "h3dXicc; Xicc pT (GeV/#it(c)); Xicc #eta; Xicc mass (GeV/#it(c)^{2})", kTH3D, {axisPt, axisEta, axisXiccMass}); + } + + void processXicc(multicharmtracks const& multiCharmTracks) + { + for (const auto& xiccCand : multiCharmTracks) { + if (xiccCand.xicDauDCA() > xicMaxDauDCA || xiccCand.xiccDauDCA() > xiccMaxDauDCA) + continue; + + if (std::fabs(xiccCand.xiDCAxy()) < xiMinDCAxy || std::fabs(xiccCand.xiDCAz()) < xiMinDCAz) + continue; + + if (std::fabs(xiccCand.pi1cDCAxy()) < picMinDCAxy || std::fabs(xiccCand.pi1cDCAz()) < picMinDCAz) + continue; + + if (std::fabs(xiccCand.pi2cDCAxy()) < picMinDCAxy || std::fabs(xiccCand.pi2cDCAz()) < picMinDCAz) + continue; + + if (std::fabs(xiccCand.piccDCAxy()) < piccMinDCAxy || std::fabs(xiccCand.piccDCAz()) < piccMinDCAz) + continue; + + if (std::fabs(xiccCand.xicDCAxy()) < xicMinDCAxy || std::fabs(xiccCand.xicDCAz()) < xicMinDCAz) + continue; + + if (std::fabs(xiccCand.pi1cDCAxy()) < picMinDCAxy || std::fabs(xiccCand.pi1cDCAz()) < picMinDCAz) + continue; + + if (std::fabs(xiccCand.pi2cDCAxy()) < picMinDCAxy || std::fabs(xiccCand.pi2cDCAz()) < picMinDCAz) + continue; + + if (std::fabs(xiccCand.xiccDCAxy()) > xiccMaxDCAxy || std::fabs(xiccCand.xiccDCAz()) > xiccMaxDCAz) + continue; + + // Cut on time delta as LoI for now + if (xiccCand.pi1cTofDeltaInner() > picMaxTofDiffInner) + continue; + + if (xiccCand.pi2cTofDeltaInner() > picMaxTofDiffInner) + continue; + + if (xiccCand.piccTofDeltaInner() > piccMaxTofDiffInner) + continue; + + if (xiccCand.pi1cPt() < picMinPt || xiccCand.pi2cPt() < picMinPt) + continue; + + if (xiccCand.piccPt() < piccMinPt) + continue; + + if (xiccCand.xicDecayRadius2D() < xicMinRadius) + continue; + + if (xiccCand.xiccDecayRadius2D() < xiccMinRadius) + continue; + + if (xiccCand.xicProperLength() < xicMinProperLength || xiccCand.xicProperLength() > xicMaxProperLength) + continue; + + if (xiccCand.xiccProperLength() < xiccMinProperLength || xiccCand.xiccProperLength() > xiccMaxProperLength) + continue; + + if (xiccCand.xicDistanceFromPV() < xicMinDecayDistanceFromPV) + continue; + + 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)); + histos.fill(HIST("SelectionQA/hDCAzXi"), std::fabs(xiccCand.xiDCAz() * 1e+4)); + histos.fill(HIST("SelectionQA/hDCAxyXic"), std::fabs(xiccCand.xicDCAxy() * 1e+4)); + 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/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()); + } + } + + PROCESS_SWITCH(alice3multicharm, processXicc, "find Xicc baryons", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +}