diff --git a/PWGCF/Femto/Core/closePairRejection.h b/PWGCF/Femto/Core/closePairRejection.h index 2c311b750e6..4430a093b06 100644 --- a/PWGCF/Femto/Core/closePairRejection.h +++ b/PWGCF/Femto/Core/closePairRejection.h @@ -88,6 +88,8 @@ constexpr const char PrefixCprTrackResonanceDaughter[] = "CprTrackResonanceDaugh constexpr const char PrefixCprTrackKinkDaughter[] = "CprTrackKinkDaughter"; constexpr const char PrefixCprV0DaughterV0DaughterPos[] = "CprV0DaughterV0DaughterPos"; constexpr const char PrefixCprV0DaughterV0DaughterNeg[] = "CprV0DaughterV0DaughterNeg"; +constexpr const char PrefixCprV0DaughterResoDaughterPos[] = "CprV0DaughterResoDaughterPos"; +constexpr const char PrefixCprV0DaughterResoDaughterNeg[] = "CprV0DaughterResoDaughterNeg"; constexpr const char PrefixCprTrackCascadeBachelor[] = "CprTrackCascadeBachelor"; // pairs @@ -97,6 +99,8 @@ using ConfCprTrackResonanceDaughter = ConfCpr; using ConfCprTrackKinkDaughter = ConfCpr; using ConfCprV0DaugherV0DaughterPos = ConfCpr; using ConfCprV0DaugherV0DaughterNeg = ConfCpr; +using ConfCprV0DaughterResoDaughterPos = ConfCpr; +using ConfCprV0DaughterResoDaughterNeg = ConfCpr; using ConfCprTrackCascadeBachelor = ConfCpr; // tpc radii for computing phistar @@ -112,6 +116,10 @@ constexpr char PrefixV0V0PosSe[] = "CPR_V0V0_PosDau/SE/"; constexpr char PrefixV0V0NegSe[] = "CPR_V0V0_NegDau/SE/"; constexpr char PrefixV0V0PosMe[] = "CPR_V0V0_PosDau/ME/"; constexpr char PrefixV0V0NegMe[] = "CPR_V0V0_NegDau/ME/"; +constexpr char PrefixV0TwoTrackResonancePosSe[] = "CPR_V0V0_PosDau/SE/"; +constexpr char PrefixV0TwoTrackResonanceNegSe[] = "CPR_V0Resonance_NegDau/SE/"; +constexpr char PrefixV0TwoTrackResonancePosMe[] = "CPR_V0Resonance_PosDau/ME/"; +constexpr char PrefixV0TwoTrackResonanceNegMe[] = "CPR_V0Resonance_NegDau/ME/"; constexpr char PrefixTrackTwoTrackResonanceSe[] = "CPR_TrackResonanceDau/SE/"; constexpr char PrefixTrackTwoTrackResonanceMe[] = "CPR_TrackResonanceDau/ME/"; constexpr char PrefixTrackCascadeBachelorSe[] = "CPR_TrackCascadeBachelor/SE/"; diff --git a/PWGCF/Femto/Core/pairBuilder.h b/PWGCF/Femto/Core/pairBuilder.h index 31fb57c6ff7..0342342f9f9 100644 --- a/PWGCF/Femto/Core/pairBuilder.h +++ b/PWGCF/Femto/Core/pairBuilder.h @@ -820,6 +820,130 @@ class PairTrackTwoTrackResonanceBuilder int mMixingDepth = 5; }; +template +class PairV0TwoTrackResonanceBuilder +{ + public: + PairV0TwoTrackResonanceBuilder() = default; + ~PairV0TwoTrackResonanceBuilder() = default; + + template + void init(o2::framework::HistogramRegistry* registry, + T1 const& confCollisionBinning, + T2 const& confV0Selection, + T3 const& confResonanceSelection, + T4 const& confCprPos, + T5 const& confCprNeg, + T6 const& confMixing, + T7 const& confPairBinning, + T8 const& confPairCuts, + std::map> const& colHistSpec, + std::map> const& v0HistSpec, + std::map> const& V0posDauHistSpec, + std::map> const& V0negDauHistSpec, + std::map> const& resonanceHistSpec, + std::map> const& ResonancePosDauHistSpec, + std::map> const& ResonanceNegDauHistSpec, + std::map> const& pairHistSpec, + std::map> const& cprHistSpecPos, + std::map> const& cprHistSpecNeg) + { + mColHistManager.template init(registry, colHistSpec, confCollisionBinning); + + mV0HistManager.template init(registry, v0HistSpec, confV0Selection, V0posDauHistSpec, V0negDauHistSpec); + mResonanceHistManager.template init(registry, resonanceHistSpec, confResonanceSelection, ResonancePosDauHistSpec, ResonanceNegDauHistSpec); + + mPairHistManagerSe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); + mPairHistManagerSe.setMass(confV0Selection.pdgCodeAbs.value, confResonanceSelection.pdgCodeAbs.value); + mPairHistManagerSe.setCharge(1, 1); // set charge to 1 + mCprSe.init(registry, cprHistSpecPos, cprHistSpecNeg, confCprPos, confCprNeg); + + mPairHistManagerMe.template init(registry, pairHistSpec, confPairBinning, confPairCuts, confMixing); + mPairHistManagerMe.setMass(confV0Selection.pdgCodeAbs.value, confResonanceSelection.pdgCodeAbs.value); + mPairHistManagerMe.setCharge(1, 1); // set charge to 1 + mCprMe.init(registry, cprHistSpecPos, cprHistSpecNeg, confCprPos, confCprNeg); + + // setup mixing + mMixingPolicy = static_cast(confMixing.policy.value); + mMixingDepth = confMixing.depth.value; + } + + template + void processSameEvent(T1 const& col, T2& trackTable, T3& v0Partition, T4& resonancePartition, T5& cache) + { + auto v0Slice = v0Partition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); + auto resonanaceSlice = resonancePartition->sliceByCached(o2::aod::femtobase::stored::fColId, col.globalIndex(), cache); + if (v0Slice.size() < nLimitPartitionParticles || resonanaceSlice.size() < nLimitPartitionParticles) { + return; + } + mColHistManager.template fill(col); + mCprSe.setMagField(col.magField()); + pairprocesshelpers::processSameEvent(v0Slice, resonanaceSlice, trackTable, col, mV0HistManager, mResonanceHistManager, mPairHistManagerSe, mCprSe, mPc); + } + + template + void processMixedEvent(T1 const& cols, T2& trackTable, T3& v0Partition, T4& resonancePartition, T5& cache, T6& binsVtxMult, T7& binsVtxCent, T8& binsVtxMultCent) + { + switch (mMixingPolicy) { + case static_cast(pairhistmanager::kVtxMult): + pairprocesshelpers::processMixedEvent(cols, v0Partition, resonancePartition, trackTable, cache, binsVtxMult, mMixingDepth, mPairHistManagerMe, mCprMe, mPc); + break; + case static_cast(pairhistmanager::kVtxCent): + pairprocesshelpers::processMixedEvent(cols, v0Partition, resonancePartition, trackTable, cache, binsVtxCent, mMixingDepth, mPairHistManagerMe, mCprMe, mPc); + break; + case static_cast(pairhistmanager::kVtxMultCent): + pairprocesshelpers::processMixedEvent(cols, v0Partition, resonancePartition, trackTable, cache, binsVtxMultCent, mMixingDepth, mPairHistManagerMe, mCprMe, mPc); + break; + default: + LOG(fatal) << "Invalid binning policiy specifed. Breaking..."; + } + } + + private: + colhistmanager::CollisionHistManager mColHistManager; + v0histmanager::V0HistManager mV0HistManager; + twotrackresonancehistmanager::TwoTrackResonanceHistManager mResonanceHistManager; + pairhistmanager::PairHistManager mPairHistManagerSe; + pairhistmanager::PairHistManager mPairHistManagerMe; + closepairrejection::ClosePairRejectionV0V0 mCprSe; // cpr for twotrackresonances and v0 work the same way + closepairrejection::ClosePairRejectionV0V0 mCprMe; // cpr for twotrackresonances and v0 work the same way + paircleaner::V0V0PairCleaner mPc; // pc for twotrackresonances and v0 work the same way + pairhistmanager::MixingPolicy mMixingPolicy = pairhistmanager::MixingPolicy::kVtxMult; + int mMixingDepth = 5; +}; + template isCleanTrackPair(posDaughter1, posDaughter2) && this->isCleanTrackPair(negDaughter1, negDaughter2); + // check all charge combinations + return this->isCleanTrackPair(posDaughter1, posDaughter2) && this->isCleanTrackPair(negDaughter1, negDaughter2) && + this->isCleanTrackPair(posDaughter1, negDaughter2) && this->isCleanTrackPair(negDaughter1, posDaughter2); } template diff --git a/PWGCF/Femto/Core/pairHistManager.h b/PWGCF/Femto/Core/pairHistManager.h index 68e8d2d01fd..2eba72cd057 100644 --- a/PWGCF/Femto/Core/pairHistManager.h +++ b/PWGCF/Femto/Core/pairHistManager.h @@ -351,6 +351,9 @@ constexpr char PrefixV0V0Me[] = "V0V0/ME/"; constexpr char PrefixTrackResonanceSe[] = "TrackResonance/SE/"; constexpr char PrefixTrackResonanceMe[] = "TrackResonance/ME/"; +constexpr char PrefixV0ResonanceSe[] = "V0Resonance/SE/"; +constexpr char PrefixV0ResonanceMe[] = "V0Resonance/ME/"; + constexpr char PrefixTrackCascadeSe[] = "TrackCascade/SE/"; constexpr char PrefixTrackCascadeMe[] = "TrackCascade/ME/"; diff --git a/PWGCF/Femto/Core/particleCleaner.h b/PWGCF/Femto/Core/particleCleaner.h index 045f3dea785..110cda597f5 100644 --- a/PWGCF/Femto/Core/particleCleaner.h +++ b/PWGCF/Femto/Core/particleCleaner.h @@ -209,8 +209,7 @@ class ParticleCleaner return hasRequiredPdgCode && !hasRejectedPdgCode && hasMotherWithRequiredPdgCode && !hasMotherWithRejectedPdgCode && - hasPartonicMotherWithRequiredPdgCode && - !hasPartonicMotherWithRejectedPdgCode; + hasPartonicMotherWithRequiredPdgCode && !hasPartonicMotherWithRejectedPdgCode; } private: @@ -218,8 +217,8 @@ class ParticleCleaner bool mRejectParticleWithoutMcParticle = true; bool mRejectParticleWithoutMcMother = true; bool mRejectParticleWithoutMcPartonicMother = true; - std::vector mRequiredPdgCodes = {}; - std::vector mRejectedPdgCodes = {}; + std::vector mRequiredPdgCodes{}; + std::vector mRejectedPdgCodes{}; std::vector mRequiredMotherPdgCodes{}; std::vector mRejectedMotherPdgCodes{}; std::vector mRequiredPartonicMotherPdgCodes{}; diff --git a/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx b/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx index 64a3ede4696..f64ae54b657 100644 --- a/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx +++ b/PWGCF/Femto/TableProducer/femtoProducerDerivedToDerived.cxx @@ -123,6 +123,16 @@ struct FemtoProducerDerivedToDerived { } PROCESS_SWITCH(FemtoProducerDerivedToDerived, processTracksLambdas, "Process lambdas and tracks", false); + void processLambdas(FilteredCollision const& col, Tracks const& tracks, Lambdas const& lambdas) + { + if (v0Builder.collisionHasTooFewLambdas(col, lambdas, lambdaPartition, cache)) { + return; + } + collisionBuilder.processCollision(col, collisionBuilderProducts); + v0Builder.processLambdas(col, lambdas, tracks, lambdaPartition, trackBuilder, cache, v0BuilderProducts, trackBuilderProducts, collisionBuilderProducts); + } + PROCESS_SWITCH(FemtoProducerDerivedToDerived, processLambdas, "Process lambdas", false); + void processTracksK0shorts(FilteredCollision const& col, Tracks const& tracks, K0shorts const& k0shorts) { if (trackBuilder.collisionHasTooFewTracks(col, tracks, trackPartition1, trackPartition2, cache) || v0Builder.collisionHasTooFewK0shorts(col, k0shorts, k0shortPartition, cache)) { diff --git a/PWGCF/Femto/Tasks/CMakeLists.txt b/PWGCF/Femto/Tasks/CMakeLists.txt index 9f213c0645b..ccfc8ee237e 100644 --- a/PWGCF/Femto/Tasks/CMakeLists.txt +++ b/PWGCF/Femto/Tasks/CMakeLists.txt @@ -49,6 +49,11 @@ o2physics_add_dpl_workflow(femto-pair-track-two-track-resonance PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(femto-pair-v0-two-track-resonance + SOURCES femtoPairV0TwoTrackResonance.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(femto-pair-track-cascade SOURCES femtoPairTrackCascade.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore diff --git a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx index 371e2fa0aaf..9c70d80614a 100644 --- a/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx +++ b/PWGCF/Femto/Tasks/femtoPairTrackTwoTrackResonance.cxx @@ -40,39 +40,34 @@ #include #include -using namespace o2; -using namespace o2::aod; -using namespace o2::soa; -using namespace o2::framework; -using namespace o2::framework::expressions; using namespace o2::analysis::femto; struct FemtoPairTrackTwoTrackResonance { // setup tables - using Collisions = Join; + using Collisions = o2::soa::Join; using Collision = Collisions::iterator; using FilteredCollisions = o2::soa::Filtered; using FilteredCollision = FilteredCollisions::iterator; - using Tracks = o2::soa::Join; - using Phis = o2::soa::Join; - using Kstar0s = o2::soa::Join; - using Rho0s = o2::soa::Join; + using FemtoTracks = o2::soa::Join; + using FemtoPhis = o2::soa::Join; + using FemtoKstar0s = o2::soa::Join; + using FemtoRho0s = o2::soa::Join; - SliceCache cache; + o2::framework::SliceCache cache; // setup collisions collisionbuilder::ConfCollisionSelection collisionSelection; - Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection); + o2::framework::expressions::Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection); colhistmanager::ConfCollisionBinning confCollisionBinning; // setup tracks trackbuilder::ConfTrackSelection1 trackSelection; trackhistmanager::ConfTrackBinning1 confTrackBinning; - Partition trackPartition = MAKE_TRACK_PARTITION(trackSelection); - Preslice perColTracks = aod::femtobase::stored::fColId; + o2::framework::Partition trackPartition = MAKE_TRACK_PARTITION(trackSelection); + o2::framework::Preslice perColTracks = o2::aod::femtobase::stored::fColId; // setup for daughters trackhistmanager::ConfResonancePosDauBinning confPosDauBinning; @@ -81,20 +76,20 @@ struct FemtoPairTrackTwoTrackResonance { // setup phis twotrackresonancebuilder::ConfPhiSelection phiSelection; twotrackresonancehistmanager::ConfPhiBinning confPhiBinning; - Partition phiPartition = MAKE_RESONANCE_0_PARTITON(phiSelection); - Preslice perColPhis = aod::femtobase::stored::fColId; + o2::framework::Partition phiPartition = MAKE_RESONANCE_0_PARTITON(phiSelection); + o2::framework::Preslice perColPhis = o2::aod::femtobase::stored::fColId; // setup kstar0 twotrackresonancebuilder::ConfKstar0Selection kstar0Selection; twotrackresonancehistmanager::ConfKstar0Binning confKstar0Binning; - Partition kstar0Partition = MAKE_RESONANCE_1_PARTITON(kstar0Selection); - Preslice perColKstar0s = aod::femtobase::stored::fColId; + o2::framework::Partition kstar0Partition = MAKE_RESONANCE_1_PARTITON(kstar0Selection); + o2::framework::Preslice perColKstar0s = o2::aod::femtobase::stored::fColId; // rho0s twotrackresonancebuilder::ConfRho0Selection rho0Selection; twotrackresonancehistmanager::ConfRho0Binning confRho0Binning; - Partition rho0Partition = MAKE_RESONANCE_0_PARTITON(rho0Selection); - Preslice perColRho0s = aod::femtobase::stored::fColId; + o2::framework::Partition rho0Partition = MAKE_RESONANCE_0_PARTITON(rho0Selection); + o2::framework::Preslice perColRho0s = o2::aod::femtobase::stored::fColId; // setup pairs pairhistmanager::ConfPairBinning confPairBinning; @@ -143,17 +138,17 @@ struct FemtoPairTrackTwoTrackResonance { std::vector defaultVtxBins{10, -10, 10}; std::vector defaultMultBins{50, 0, 200}; std::vector defaultCentBins{10, 0, 100}; - ColumnBinningPolicy mixBinsVtxMult{{defaultVtxBins, defaultMultBins}, true}; - ColumnBinningPolicy mixBinsVtxCent{{defaultVtxBins, defaultCentBins}, true}; - ColumnBinningPolicy mixBinsVtxMultCent{{defaultVtxBins, defaultMultBins, defaultCentBins}, true}; + o2::framework::ColumnBinningPolicy mixBinsVtxMult{{defaultVtxBins, defaultMultBins}, true}; + o2::framework::ColumnBinningPolicy mixBinsVtxCent{{defaultVtxBins, defaultCentBins}, true}; + o2::framework::ColumnBinningPolicy mixBinsVtxMultCent{{defaultVtxBins, defaultMultBins, defaultCentBins}, true}; pairhistmanager::ConfMixing confMixing; - HistogramRegistry hRegistry{"FemtoTrackTwoTrackResonance", {}, OutputObjHandlingPolicy::AnalysisObject}; + o2::framework::HistogramRegistry hRegistry{"FemtoTrackTwoTrackResonance", {}, o2::framework::OutputObjHandlingPolicy::AnalysisObject}; // setup cpr closepairrejection::ConfCprTrackResonanceDaughter confCpr; - void init(InitContext&) + void init(o2::framework::InitContext&) { if (((doprocessPhiSameEvent || doprocessPhiMixedEvent) + (doprocessKstar0SameEvent || doprocessKstar0MixedEvent)) + (doprocessRho0SameEvent || doprocessRho0MixedEvent) > 1) { @@ -195,46 +190,46 @@ struct FemtoPairTrackTwoTrackResonance { } }; - void processPhiSameEvent(FilteredCollision const& col, Tracks const& tracks, Phis const& phis) + void processPhiSameEvent(FilteredCollision const& col, FemtoTracks const& tracks, FemtoPhis const& phis) { pairTrackPhiBuilder.processSameEvent(col, tracks, trackPartition, phis, phiPartition, cache); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processPhiSameEvent, "Enable processing same event processing for tracks and phis", true); - void processPhiMixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Phis const& /*phis*/) + void processPhiMixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoPhis const& /*phis*/) { pairTrackPhiBuilder.processMixedEvent(cols, tracks, trackPartition, phiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processPhiMixedEvent, "Enable processing mixed event processing for tracks and phis", true); - void processKstar0SameEvent(FilteredCollision const& col, Tracks const& tracks, Kstar0s const& kstar0s) + void processKstar0SameEvent(FilteredCollision const& col, FemtoTracks const& tracks, FemtoKstar0s const& kstar0s) { pairTrackKstar0Builder.processSameEvent(col, tracks, trackPartition, kstar0s, kstar0Partition, cache); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processKstar0SameEvent, "Enable processing same event processing for tracks and kstar0s", false); - void processKstar0MixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Kstar0s const& /*kstar0s*/) + void processKstar0MixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoKstar0s const& /*kstar0s*/) { pairTrackKstar0Builder.processMixedEvent(cols, tracks, trackPartition, kstar0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processKstar0MixedEvent, "Enable processing mixed event processing for tracks and kstar0s", false); - void processRho0SameEvent(FilteredCollision const& col, Tracks const& tracks, Rho0s const& rho0s) + void processRho0SameEvent(FilteredCollision const& col, FemtoTracks const& tracks, FemtoRho0s const& rho0s) { pairTrackRho0Builder.processSameEvent(col, tracks, trackPartition, rho0s, rho0Partition, cache); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processRho0SameEvent, "Enable processing same event processing for tracks and rho0s", false); - void processRho0MixedEvent(FilteredCollisions const& cols, Tracks const& tracks, Rho0s const& /*rho0s*/) + void processRho0MixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoRho0s const& /*rho0s*/) { pairTrackRho0Builder.processMixedEvent(cols, tracks, trackPartition, rho0Partition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); } PROCESS_SWITCH(FemtoPairTrackTwoTrackResonance, processRho0MixedEvent, "Enable processing mixed event processing for tracks and rho0s", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& cfgc) { - WorkflowSpec workflow{ + o2::framework::WorkflowSpec workflow{ adaptAnalysisTask(cfgc), }; return workflow; diff --git a/PWGCF/Femto/Tasks/femtoPairV0TwoTrackResonance.cxx b/PWGCF/Femto/Tasks/femtoPairV0TwoTrackResonance.cxx new file mode 100644 index 00000000000..5622d735fa6 --- /dev/null +++ b/PWGCF/Femto/Tasks/femtoPairV0TwoTrackResonance.cxx @@ -0,0 +1,199 @@ +// Copyright 2019-2025 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 femtoPairV0TwoTrackResonance.cxx +/// \brief Tasks that computes correlation between tracks and resonances decaying into two tracks +/// \author Anton Riedel, TU München, anton.riedel@cern.ch + +#include "PWGCF/Femto/Core/closePairRejection.h" +#include "PWGCF/Femto/Core/collisionBuilder.h" +#include "PWGCF/Femto/Core/collisionHistManager.h" +#include "PWGCF/Femto/Core/modes.h" +#include "PWGCF/Femto/Core/pairBuilder.h" +#include "PWGCF/Femto/Core/pairHistManager.h" +#include "PWGCF/Femto/Core/partitions.h" +#include "PWGCF/Femto/Core/trackBuilder.h" +#include "PWGCF/Femto/Core/trackHistManager.h" +#include "PWGCF/Femto/Core/twoTrackResonanceBuilder.h" +#include "PWGCF/Femto/Core/twoTrackResonanceHistManager.h" +#include "PWGCF/Femto/Core/v0Builder.h" +#include "PWGCF/Femto/Core/v0HistManager.h" +#include "PWGCF/Femto/DataModel/FemtoTables.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +using namespace o2::analysis::femto; + +struct FemtoPairV0TwoTrackResonance { + + // setup tables + using Collisions = o2::soa::Join; + using Collision = Collisions::iterator; + + using FilteredCollisions = o2::soa::Filtered; + using FilteredCollision = FilteredCollisions::iterator; + + using FemtoTracks = o2::soa::Join; + + using FemtoLambdas = o2::soa::Join; + using FemtoK0shorts = o2::soa::Join; + + using FemtoPhis = o2::soa::Join; + using FemtoKstar0s = o2::soa::Join; + using FemtoRho0s = o2::soa::Join; + + o2::framework::SliceCache cache; + + // setup collisions + collisionbuilder::ConfCollisionSelection collisionSelection; + o2::framework::expressions::Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection); + colhistmanager::ConfCollisionBinning confCollisionBinning; + + // setup for daughters for v0s + trackhistmanager::ConfV0PosDauBinning confV0PosDauBinning; + trackhistmanager::ConfV0NegDauBinning confV0NegDauBinning; + + // setup lambdas + v0builder::ConfLambdaSelection1 lambdaSelection; + v0histmanager::ConfLambdaBinning1 confLambdaBinning; + particlecleaner::ConfLambdaCleaner1 confLambdaCleaner; + + o2::framework::Partition lambdaPartition = MAKE_LAMBDA_PARTITION(lambdaSelection); + o2::framework::Preslice perColLambdas = o2::aod::femtobase::stored::fColId; + + // setup k0shorts + v0builder::ConfK0shortSelection1 k0shortSelection; + v0histmanager::ConfK0shortBinning1 confK0shortBinning; + particlecleaner::ConfK0shortCleaner1 confK0shortCleaner; + + o2::framework::Partition k0shortPartition = MAKE_K0SHORT_PARTITION(k0shortSelection); + o2::framework::Preslice perColk0shorts = o2::aod::femtobase::stored::fColId; + + // setup for daughters for resonances + trackhistmanager::ConfResonancePosDauBinning confResoPosDauBinning; + trackhistmanager::ConfResonanceNegDauBinning confResoNegDauBinning; + + // setup phis + twotrackresonancebuilder::ConfPhiSelection phiSelection; + twotrackresonancehistmanager::ConfPhiBinning confPhiBinning; + o2::framework::Partition phiPartition = MAKE_RESONANCE_0_PARTITON(phiSelection); + o2::framework::Preslice perColPhis = o2::aod::femtobase::stored::fColId; + + // setup kstar0 + twotrackresonancebuilder::ConfKstar0Selection kstar0Selection; + twotrackresonancehistmanager::ConfKstar0Binning confKstar0Binning; + o2::framework::Partition kstar0Partition = MAKE_RESONANCE_1_PARTITON(kstar0Selection); + o2::framework::Preslice perColKstar0s = o2::aod::femtobase::stored::fColId; + + // rho0s + twotrackresonancebuilder::ConfRho0Selection rho0Selection; + twotrackresonancehistmanager::ConfRho0Binning confRho0Binning; + o2::framework::Partition rho0Partition = MAKE_RESONANCE_0_PARTITON(rho0Selection); + o2::framework::Preslice perColRho0s = o2::aod::femtobase::stored::fColId; + + // setup pairs + pairhistmanager::ConfPairBinning confPairBinning; + pairhistmanager::ConfPairCuts confPairCuts; + + // setup for lambda-phi pairs + pairbuilder::PairV0TwoTrackResonanceBuilder< + v0histmanager::PrefixLambda1, + trackhistmanager::PrefixV01PosDaughter, + trackhistmanager::PrefixV01NegDaughter, + twotrackresonancehistmanager::PrefixPhi, + trackhistmanager::PrefixResonancePosDaughter, + trackhistmanager::PrefixResonanceNegDaughter, + pairhistmanager::PrefixV0ResonanceSe, + pairhistmanager::PrefixV0ResonanceMe, + closepairrejection::PrefixV0TwoTrackResonancePosSe, + closepairrejection::PrefixV0TwoTrackResonanceNegSe, + closepairrejection::PrefixV0TwoTrackResonancePosMe, + closepairrejection::PrefixV0TwoTrackResonanceNegMe, + modes::V0::kLambda, + modes::TwoTrackResonance::kPhi> + pairLambdaPhiBuilder; + + // setup mixing + std::vector defaultVtxBins{10, -10, 10}; + std::vector defaultMultBins{50, 0, 200}; + std::vector defaultCentBins{10, 0, 100}; + o2::framework::ColumnBinningPolicy mixBinsVtxMult{{defaultVtxBins, defaultMultBins}, true}; + o2::framework::ColumnBinningPolicy mixBinsVtxCent{{defaultVtxBins, defaultCentBins}, true}; + o2::framework::ColumnBinningPolicy mixBinsVtxMultCent{{defaultVtxBins, defaultMultBins, defaultCentBins}, true}; + + pairhistmanager::ConfMixing confMixing; + + // setup cpr + closepairrejection::ConfCprV0DaughterResoDaughterPos confCprPos; + closepairrejection::ConfCprV0DaughterResoDaughterNeg confCprNeg; + + o2::framework::HistogramRegistry hRegistry{"FemtoV0TwoTrackResonance", {}, o2::framework::OutputObjHandlingPolicy::AnalysisObject}; + + void init(o2::framework::InitContext&) + { + + // setup columnpolicy for binning + // default values are used during instantiation, so we need to explicity update them here + mixBinsVtxMult = {{confMixing.vtxBins, confMixing.multBins.value}, true}; + mixBinsVtxCent = {{confMixing.vtxBins.value, confMixing.centBins.value}, true}; + mixBinsVtxMultCent = {{confMixing.vtxBins.value, confMixing.multBins.value, confMixing.centBins.value}, true}; + + // setup histograms + auto colHistSpec = colhistmanager::makeColHistSpecMap(confCollisionBinning); + + auto lambdaHistSpec = v0histmanager::makeV0HistSpecMap(confLambdaBinning); + auto v0PosDauSpec = trackhistmanager::makeTrackHistSpecMap(confV0PosDauBinning); + auto v0NegDauSpec = trackhistmanager::makeTrackHistSpecMap(confV0NegDauBinning); + + auto phiHistSpec = twotrackresonancehistmanager::makeTwoTrackResonanceHistSpecMap(confPhiBinning); + auto resoPosDauSpec = trackhistmanager::makeTrackHistSpecMap(confResoPosDauBinning); + auto resov0NegDauSpec = trackhistmanager::makeTrackHistSpecMap(confResoNegDauBinning); + + auto cprHistSpecPos = closepairrejection::makeCprHistSpecMap(confCprPos); + auto cprHistSpecNeg = closepairrejection::makeCprHistSpecMap(confCprNeg); + + auto pairV0TwoTrackResonanceHistSpec = pairhistmanager::makePairHistSpecMap(confPairBinning, confMixing); + + pairLambdaPhiBuilder.init(&hRegistry, confCollisionBinning, lambdaSelection, phiSelection, confCprPos, confCprNeg, confMixing, confPairBinning, confPairCuts, colHistSpec, lambdaHistSpec, v0PosDauSpec, v0NegDauSpec, phiHistSpec, resoPosDauSpec, resov0NegDauSpec, pairV0TwoTrackResonanceHistSpec, cprHistSpecPos, cprHistSpecNeg); + }; + + void processLambdaPhiSameEvent(FilteredCollision const& col, FemtoTracks const& tracks, FemtoLambdas const& /*lambdas*/, FemtoPhis const& /*phis*/) + { + pairLambdaPhiBuilder.processSameEvent(col, tracks, lambdaPartition, phiPartition, cache); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processLambdaPhiSameEvent, "Enable processing same event processing for lambdas and phis", true); + + void processLambdaPhiMixedEvent(FilteredCollisions const& cols, FemtoTracks const& tracks, FemtoLambdas const& /*lambda*/, FemtoPhis const& /*phis*/) + { + pairLambdaPhiBuilder.processMixedEvent(cols, tracks, lambdaPartition, phiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent); + } + PROCESS_SWITCH(FemtoPairV0TwoTrackResonance, processLambdaPhiMixedEvent, "Enable processing mixed event processing for lambdas and phis", true); +}; + +o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& cfgc) +{ + o2::framework::WorkflowSpec workflow{ + adaptAnalysisTask(cfgc), + }; + return workflow; +}