From f429fdb2a3fa777f6052adc73c964e683368cbe2 Mon Sep 17 00:00:00 2001 From: Wioleta Rzesa Date: Sat, 30 Aug 2025 11:26:10 +0200 Subject: [PATCH 1/9] =?UTF-8?q?A=20correlation=20task=20for=20triplets=20(?= =?UTF-8?q?track-track-v0)=20in=20Pb=E2=80=93Pb=20collisions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- PWGCF/FemtoDream/Tasks/CMakeLists.txt | 12 +- .../Tasks/femtoDreamCollisionMasker.cxx | 2 +- .../femtoDreamTripletTaskTrackTrackV0PbPb.cxx | 775 ++++++++++++++++++ 3 files changed, 787 insertions(+), 2 deletions(-) create mode 100644 PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx diff --git a/PWGCF/FemtoDream/Tasks/CMakeLists.txt b/PWGCF/FemtoDream/Tasks/CMakeLists.txt index 95c4f8cdaa0..f108cb393a3 100644 --- a/PWGCF/FemtoDream/Tasks/CMakeLists.txt +++ b/PWGCF/FemtoDream/Tasks/CMakeLists.txt @@ -18,6 +18,11 @@ o2physics_add_dpl_workflow(femtodream-triplet-track-track-track SOURCES femtoDreamTripletTaskTrackTrackTrack.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(femtodream-triplet-track-track-track-pb-pb + SOURCES femtoDreamTripletTaskTrackTrackTrackPbPb.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(femtodream-pair-track-v0 SOURCES femtoDreamPairTaskTrackV0.cxx @@ -39,6 +44,11 @@ o2physics_add_dpl_workflow(femtodream-triplet-track-track-v0 PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(femtodream-triplet-track-track-v0-pb-pb + SOURCES femtoDreamTripletTaskTrackTrackV0PbPb.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(femtodream-debug-track SOURCES femtoDreamDebugTrack.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore @@ -67,4 +77,4 @@ o2physics_add_dpl_workflow(femtodream-hash o2physics_add_dpl_workflow(femtodream-pair-v0-v0 SOURCES femtoDreamPairTaskV0V0.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore - COMPONENT_NAME Analysis) \ No newline at end of file + COMPONENT_NAME Analysis) diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamCollisionMasker.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamCollisionMasker.cxx index fddbee16a88..1cb8c18caef 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamCollisionMasker.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamCollisionMasker.cxx @@ -268,7 +268,7 @@ struct femoDreamCollisionMasker { TrackDCACutPtDep.push_back(option.defaultValue.get()); } } - } else if (device.name.find("femto-dream-triplet-task-track-track-v0") != std::string::npos) { + } else if ((device.name.find("femto-dream-triplet-task-track-track-v0") != std::string::npos) || (device.name.find("femto-dream-triplet-task-track-track-v0-pb-pb") != std::string::npos)) { LOG(info) << "Matched workflow: " << device.name; TaskFinder = CollisionMasks::kTrackTrackV0; for (auto const& option : device.options) { diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx new file mode 100644 index 00000000000..b97b887deef --- /dev/null +++ b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx @@ -0,0 +1,775 @@ +// 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 femtoDreamTripletTaskTrackTrackV0.cxx +/// \brief Tasks that reads the track and V0 tables and creates triplets; only two identical tracks and a V0 can be used +/// \main author: Laura Serksnyte, laura.serksnyte@tum.de +/// \further modifications: Wioleta Rzęsa, wioleta.rzesa@cern.ch + + +#include +#include +#include +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/ASoAHelpers.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include "Framework/RunningWorkflowInfo.h" +#include "Framework/StepTHn.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include "TDatabasePDG.h" + +#include "PWGCF/DataModel/FemtoDerived.h" +#include "PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h" +#include "PWGCF/FemtoDream/Core/femtoDreamEventHisto.h" +#include "PWGCF/FemtoDream/Core/femtoDreamPairCleaner.h" +#include "PWGCF/FemtoDream/Core/femtoDreamContainerThreeBody.h" +#include "PWGCF/FemtoDream/Core/femtoDreamDetaDphiStar.h" +#include "PWGCF/FemtoDream/Core/femtoDreamUtils.h" + +using namespace o2; +using namespace o2::analysis::femtoDream; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::soa; + +struct femtoDreamTripletTaskTrackTrackV0PbPb { + SliceCache cache; + Preslice perCol = aod::femtodreamparticle::fdCollisionId; + Configurable ConfCentralityMin{"ConfCentralityMin", 0, "Event sel: Minimum Centrality Percentile"}; + Configurable ConfCentralityMax{"ConfCentralityMax", 10, "Event sel: Maximum Centrality Percentile"}; + Configurable ConfZVertexCut{"confZVertexCut", 10.f, "Event sel: Maximum z-Vertex (cm)"}; + Filter EventCentrality = aod::femtodreamcollision::multV0M >= ConfCentralityMin && aod::femtodreamcollision::multV0M <= ConfCentralityMax; + Filter EventVertex = (nabs(aod::collision::posZ) < ConfZVertexCut); + using FilteredFDCollisions = soa::Filtered; + using FilteredFDCollision = FilteredFDCollisions::iterator; + using MaskedCollisions = soa::Filtered>; + using MaskedCollision = MaskedCollisions::iterator; + + aod::femtodreamcollision::BitMaskType MaskBit = -1; + float mMassOne = -999, mMassTwo = -999, mMassThree = -999; + + //Pair/triplet cuts + Configurable ConfMixIfTripletPresent{"ConfMixIfTripletPresent", true, "Use for mixing only events which have a TTV0 triplet"}; + Configurable ConfMixIfTVOPairPresent{"ConfMixIfTVOPairPresent", false, "Use for mixing only events which have a TV0 pair (at least one track and one V0)"}; + Configurable ConfMixIfTOrVOPartsPresent{"ConfMixIfTOrVOPartsPresent", false, "Use for mixing only events which have at least one particle of interest"}; + + // which CPR to use, old is with a possible bug and new is fixed + Configurable ConfUseOLD_possiblyWrong_CPR{"ConfUseOLD_possiblyWrong_CPR", true, "Use for old CPR, which possibly has a bug. This is implemented only for debugging reasons to compare old and new code on hyperloop datasets."}; + Configurable ConfAtWhichRadiiToCut{"ConfAtWhichRadiiToCut", 1, "At which radii perform deta dphi selection: 0 - at PV, 1 - averaged phi, 2 - at given radii"}; + Configurable ConfAtWhichTPCRadii{"ConfAtWhichTPCRadii", 85., "If ConfAtWhichRadiiToCut = 2; this allows to select at which TPC radii to cut"}; + + /// First 2 tracks of the triplet + Configurable ConfPDGCodePart{"ConfPDGCodePart", 2212, "Particle PDG code"}; //proton + Configurable ConfCutPart{"ConfCutPart", 5542474, "Track - Selection bit from cutCulator"}; + Configurable ConfTPCPIDBit{"ConfTPCPIDBit", 16, "PID TPC bit from cutCulator "}; + Configurable ConfTPCTOFPIDBit{"ConfTPCTOFPIDBit", 8, "PID TPCTOF bit from cutCulator"}; + Configurable ConfMaxpT{"ConfMaxpT", 4.0f, "Maximum transverse momentum of the particles"}; + Configurable ConfMinpT{"ConfMinpT", 0.5f, "Minimum transverse momentum of the particles"}; + Configurable ConfMaxDCAxy{"ConfMaxDCAxy", 0.1f, "Maximum DCAxy of the particles"}; + Configurable ConfMinDCAxy{"ConfMinDCAxy", -0.1f, "Minimum DCAxy of the particles"}; + Configurable ConfPIDthrMom{"ConfPIDthrMom", 0.75f, "Momentum threshold from which TPC and TOF are required for PID"}; + Configurable ConfIsMC{"ConfIsMC", false, "Enable additional Histogramms in the case of a MonteCarlo Run"}; + Configurable ConfUse3D{"ConfUse3D", false, "Enable three dimensional histogramms (to be used only for analysis with high statistics): k* vs mT vs multiplicity"}; + Configurable ConfDCACutPtDep{"ConfDCACutPtDep", false, "Use pt dependent dca cut for tracks"}; + + /// Partition for selected particles + Partition SelectedParts = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kTrack)) && + ifnode(aod::femtodreamparticle::pt * (nexp(aod::femtodreamparticle::eta) + nexp(-1.f * aod::femtodreamparticle::eta)) / 2.f <= ConfPIDthrMom, ncheckbit(aod::femtodreamparticle::pidcut, ConfTPCPIDBit), ncheckbit(aod::femtodreamparticle::pidcut, ConfTPCTOFPIDBit)) && + (ncheckbit(aod::femtodreamparticle::cut, ConfCutPart)) && + (aod::femtodreamparticle::pt < ConfMaxpT) && + (aod::femtodreamparticle::pt > ConfMinpT) && + ifnode(ConfDCACutPtDep, (nabs(aod::femtodreamparticle::tempFitVar) <= 0.0105f + (0.035f / npow(aod::femtodreamparticle::pt, 1.1f))), + ((aod::femtodreamparticle::tempFitVar >= ConfMinDCAxy) && + (aod::femtodreamparticle::tempFitVar <= ConfMaxDCAxy))); + ; + + Partition> SelectedPartsMC = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kTrack)) && + ifnode(aod::femtodreamparticle::pt * (nexp(aod::femtodreamparticle::eta) + nexp(-1.f * aod::femtodreamparticle::eta)) / 2.f <= ConfPIDthrMom, ncheckbit(aod::femtodreamparticle::pidcut, ConfTPCPIDBit), ncheckbit(aod::femtodreamparticle::pidcut, ConfTPCTOFPIDBit)) && + (ncheckbit(aod::femtodreamparticle::cut, ConfCutPart)) && + (aod::femtodreamparticle::pt < ConfMaxpT) && + (aod::femtodreamparticle::pt > ConfMinpT) && + ifnode(ConfDCACutPtDep, (nabs(aod::femtodreamparticle::tempFitVar) <= 0.0105f + (0.035f / npow(aod::femtodreamparticle::pt, 1.1f))), + ((aod::femtodreamparticle::tempFitVar >= ConfMinDCAxy) && + (aod::femtodreamparticle::tempFitVar <= ConfMaxDCAxy))); + ; + + /// Histogramming of selected tracks + FemtoDreamParticleHisto trackHistoSelectedParts; + FemtoDreamParticleHisto trackHistoALLSelectedParts; + + /// V0 selection + Configurable ConfPDGCodeV0{"ConfPDGCodeV0", 3122, "V0 PDG code"}; + Configurable ConfCutV0{"ConfCutV0", 7484, "V0 - Selection bit from cutCulator"}; + Configurable Conf_ChildPos_CutV0{"Conf_ChildPos_CutV0", 8234, "Selection bit for positive child of V0"}; + Configurable Conf_ChildPos_TPCBitV0{"Conf_ChildPos_TPCBitV0", 1024, "PID TPC bit for positive child of V0"}; + Configurable Conf_ChildNeg_CutV0{"Conf_ChildNeg_CutV0", 8233, "Selection bit for negative child of V0"}; + Configurable Conf_ChildNeg_TPCBitV0{"Conf_ChildNeg_TPCBitV0", 4096, "PID TPC bit for negative child of V0"}; + + Configurable Conf_minInvMass_V0{"Conf_minInvMass_V0", 1.08, "Minimum invariant mass of V0 (particle)"}; + Configurable Conf_maxInvMass_V0{"Conf_maxInvMass_V0", 1.15, "Maximum invariant mass of V0 (particle)"}; + Configurable Conf_minInvMassAnti_V0{"Conf_minInvMassAnti_V0", 1.08, "Minimum invariant mass of V0 (antiparticle)"}; + Configurable Conf_maxInvMassAnti_V0{"Conf_maxInvMassAnti_V0", 1.15, "Maximum invariant mass of V0 (antiparticle)"}; + + Configurable Conf_minPt_V0{"Conf_minPt_V0", 0.0, "Minimum pT of V0"}; + Configurable Conf_maxPt_V0{"Conf_maxPt_V0", 999.0, "Maximum pT of V0"}; + + // Partition for selected particles + Partition SelectedV0s = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kV0)) && + (ncheckbit(aod::femtodreamparticle::cut, ConfCutV0)) && + (aod::femtodreamparticle::mLambda > Conf_minInvMass_V0) && + (aod::femtodreamparticle::mLambda < Conf_maxInvMass_V0) && + (aod::femtodreamparticle::mAntiLambda > Conf_minInvMassAnti_V0) && + (aod::femtodreamparticle::mAntiLambda < Conf_maxInvMassAnti_V0) && + (aod::femtodreamparticle::pt > Conf_minPt_V0) && + (aod::femtodreamparticle::pt < Conf_maxPt_V0); + Partition> SelectedV0sMC = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kV0)) && + (ncheckbit(aod::femtodreamparticle::cut, ConfCutV0)) && + (aod::femtodreamparticle::mLambda > Conf_minInvMass_V0) && + (aod::femtodreamparticle::mLambda < Conf_maxInvMass_V0) && + (aod::femtodreamparticle::mAntiLambda > Conf_minInvMassAnti_V0) && + (aod::femtodreamparticle::mAntiLambda < Conf_maxInvMassAnti_V0) && + (aod::femtodreamparticle::pt > Conf_minPt_V0) && + (aod::femtodreamparticle::pt < Conf_maxPt_V0); + + /// Histogramming of selected V0s + FemtoDreamParticleHisto particleHistoSelectedV0s; + FemtoDreamParticleHisto particleHistoPosChild; + FemtoDreamParticleHisto particleHistoNegChild; + FemtoDreamParticleHisto particleHistoALLSelectedV0s; + FemtoDreamParticleHisto particleHistoALLPosChild; + FemtoDreamParticleHisto particleHistoALLNegChild; + + /// Histogramming for Event + FemtoDreamEventHisto eventHisto; + + /// Particles + ConfigurableAxis ConfTempFitVarBinsTrack{"ConfTempFitVarBinsTrack", {300, -0.15, 0.15}, "binning of the TempFitVar in the pT vs. TempFitVar plot"}; + ConfigurableAxis ConfTempFitVarpTBins{"ConfTempFitVarpTBins", {20, 0.5, 4.05}, "pT binning of the pT vs. TempFitVar plot (track)"}; + ConfigurableAxis ConfTempFitVarBinsV0{"ConfTempFitVarBinsV0", {300, 0.9, 1}, "binning of the TempFitVar in the pT vs. TempFitVar plot (V0)"}; + ConfigurableAxis ConfTempFitVarBinsV0Child{"ConfTempFitVarBinsV0Child", {300, -0.15, 0.15}, "binning of the TempFitVar in the pT vs. TempFitVar plot (V0 child)"}; + ConfigurableAxis ConfTempFitVarpTV0Bins{"ConfTempFitVarpTV0Bins", {35, 0, 6}, "pT binning of the pT vs. TempFitVar plot (V0)"}; + ConfigurableAxis ConfTempFitVarpTV0Child{"ConfTempFitVarpTV0Child", {35, 0, 6}, "pT binning of the pT vs. TempFitVar plot (V0 child)"}; + ConfigurableAxis ConfInvMassBins{"ConfInvMassBins", {200, 1, 1.2}, "InvMass binning"}; + + /// Correlations + ConfigurableAxis ConfMultBins{"ConfMultBins", {VARIABLE_WIDTH, 0.0f, 23.0f, 38.0f, 53.0f, 81.0f, 110.0f, 157.0f, 205.0f, 278.0f, 351.0f, 455.0f, 559.0f, 703.0f, 848.0f, 1050.0f, 1253.0f, 1530.0f,1668.0f, 1857.0f, 2047.0f, 99999.f}, "Mixing bins - multiplicity"}; + ConfigurableAxis ConfVtxBins{"ConfVtxBins", {VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "Mixing bins - z-vertex"}; + + ColumnBinningPolicy colBinning{{ConfVtxBins, ConfMultBins}, true}; + + ConfigurableAxis ConfQ3Bins{"ConfQ3Bins", {2000, 0., 8.}, "binning Q3"}; + ConfigurableAxis ConfQ3BinsFor4D{"ConfQ3BinsFor4D", {500, 0., 2.}, "binning Q3 for 4D hist"}; + Configurable ConfNEventsMix{"ConfNEventsMix", 5, "Number of events for mixing"}; + Configurable ConfIsCPR{"ConfIsCPR", true, "Close Pair Rejection"}; + Configurable ConfFillCPRQA{"ConfFillCPRQA", false, "Fill Close Pair Rejection plots as a function of eta and phi"}; + Configurable ConfCPRPlotPerRadii{"ConfCPRPlotPerRadii", false, "Plot CPR per radii"}; + Configurable ConfCPRdeltaPhiMax_pp{"ConfCPRdeltaPhiMax_pp", 0.01, "Max. Delta Phi for Close Pair Rejection of pp"}; + Configurable ConfCPRdeltaEtaMax_pp{"ConfCPRdeltaEtaMax_pp", 0.01, "Max. Delta Eta for Close Pair Rejection of pp"}; + Configurable ConfCPRdeltaPhiMax_pL{"ConfCPRdeltaPhiMax_pL", 0.1, "Max. Delta Phi for Close Pair Rejection of p and Lambda daughter"}; + Configurable ConfCPRdeltaEtaMax_pL{"ConfCPRdeltaEtaMax_pL", 0.1, "Max. Delta Eta for Close Pair Rejection of p and Lambda daughter"}; + Configurable ConfMaxQ3IncludedInCPRPlots{"ConfMaxQ3IncludedInCPRPlots", 8., "Maximum Q3, for which the pair CPR is included in plots"}; + ConfigurableAxis ConfDummy{"ConfDummy", {1, 0, 1}, "Dummy axis"}; + + FemtoDreamContainerThreeBody sameEventCont; + FemtoDreamContainerThreeBody mixedEventCont; + FemtoDreamPairCleaner pairCleanerTrackTrack; + FemtoDreamPairCleaner pairCleanerTrackV0; + FemtoDreamDetaDphiStar pairCloseRejectionTrackTrackSE; + FemtoDreamDetaDphiStar pairCloseRejectionTrackV0SE; + FemtoDreamDetaDphiStar pairCloseRejectionTrackTrackME; + FemtoDreamDetaDphiStar pairCloseRejectionTrackV0ME; + /// Histogram output + HistogramRegistry qaRegistry{"TrackQA", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry resultRegistry{"Correlations", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry ThreeBodyQARegistry{"ThreeBodyQARegistry", {}, OutputObjHandlingPolicy::AnalysisObject}; + + void init(InitContext& context) + { + + eventHisto.init(&qaRegistry, false); + + colBinning = {{ConfVtxBins, ConfMultBins}, true}; + + trackHistoSelectedParts.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTBins, ConfDummy, ConfDummy, ConfTempFitVarBinsTrack, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, ConfPDGCodePart); + trackHistoALLSelectedParts.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTBins, ConfDummy, ConfDummy, ConfTempFitVarBinsTrack, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, ConfPDGCodePart); + particleHistoSelectedV0s.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Bins, ConfDummy, ConfDummy, ConfTempFitVarBinsV0, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfInvMassBins, ConfDummy, ConfIsMC, ConfPDGCodeV0); + particleHistoPosChild.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Child, ConfDummy, ConfDummy, ConfTempFitVarBinsV0Child, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, 0); + particleHistoNegChild.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Child, ConfDummy, ConfDummy, ConfTempFitVarBinsV0Child, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, 0); + particleHistoALLSelectedV0s.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Bins, ConfDummy, ConfDummy, ConfTempFitVarBinsV0, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfInvMassBins, ConfDummy, ConfIsMC, ConfPDGCodeV0); + particleHistoALLPosChild.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Child, ConfDummy, ConfDummy, ConfTempFitVarBinsV0Child, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, 0); + particleHistoALLNegChild.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Child, ConfDummy, ConfDummy, ConfTempFitVarBinsV0Child, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, 0); + + ThreeBodyQARegistry.add("TripletTaskQA/hSECollisionBins", ";bin;Entries", kTH1F, {{120, -0.5, 119.5}}); + ThreeBodyQARegistry.add("TripletTaskQA/hMECollisionBins", ";bin;Entries", kTH1F, {{120, -0.5, 119.5}}); + ThreeBodyQARegistry.add("TripletTaskQA/hMinvSE_Lambda", ";Q_{3};M_{inv}", kTH2F, {ConfQ3Bins, ConfInvMassBins}); + ThreeBodyQARegistry.add("TripletTaskQA/hMinvME_Lambda", ";Q_{3};M_{inv}", kTH2F, {ConfQ3Bins, ConfInvMassBins}); + ThreeBodyQARegistry.add("TripletTaskQA/hMinvSE_AntiLambda", ";Q_{3};M_{inv}", kTH2F, {ConfQ3Bins, ConfInvMassBins}); + ThreeBodyQARegistry.add("TripletTaskQA/hMinvME_AntiLambda", ";Q_{3};M_{inv}", kTH2F, {ConfQ3Bins, ConfInvMassBins}); + ThreeBodyQARegistry.add("TripletTaskQA/particle_pT_in_Triplet_SE", "; p_{T1} ; p_{T2} ; p_{T3} ; Q_{3}", kTHnSparseF, {ConfTempFitVarpTBins, ConfTempFitVarpTBins, ConfTempFitVarpTV0Bins, ConfQ3BinsFor4D}); + ThreeBodyQARegistry.add("TripletTaskQA/particle_pT_in_Triplet_ME", "; p_{T1} ; p_{T2} ; p_{T3} ; Q_{3}", kTHnSparseF, {ConfTempFitVarpTBins, ConfTempFitVarpTBins, ConfTempFitVarpTV0Bins, ConfQ3BinsFor4D}); + ThreeBodyQARegistry.add("TripletTaskQA/hCentrality", ";Centrality; Q3", kTH2F, {{100, 0, 100}, ConfQ3Bins}); + + std::vector tmpVecMult = ConfMultBins; + framework::AxisSpec multAxis = {tmpVecMult, "Multiplicity"}; + ThreeBodyQARegistry.add("TripletTaskQA/hSEMultVSGoodTracks", ";Mult;GoodT", kTH2F, {multAxis, {100, 0, 100}}); + ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleaner", ";posDaughtID; negDaughID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerPos", ";primaryTrack; posDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerNeg", ";primaryTrack; negDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerPosGlobal", ";primaryTrackGlobal; posDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerNegGlobal", ";primaryTrackGlobal; negDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerPosAfter", ";primaryTrack; posDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerNegAfter", ";primaryTrack; negDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + ThreeBodyQARegistry.add("TripletTaskQA/hCentralityME", ";Centrality;Entries", kTH1F, {{100, 0.0, 100.0}}); + sameEventCont.init(&resultRegistry, ConfQ3Bins, ConfMultBins, ConfIsMC); + mixedEventCont.init(&resultRegistry, ConfQ3Bins, ConfMultBins, ConfIsMC); + sameEventCont.setPDGCodes(ConfPDGCodePart, ConfPDGCodePart, ConfPDGCodeV0); + mixedEventCont.setPDGCodes(ConfPDGCodePart, ConfPDGCodePart, ConfPDGCodeV0); + + pairCleanerTrackTrack.init(&qaRegistry); + pairCleanerTrackV0.init(&qaRegistry); + if (ConfIsCPR.value) { + pairCloseRejectionTrackTrackSE.init(&resultRegistry, &qaRegistry, ConfCPRdeltaPhiMax_pp.value, ConfCPRdeltaEtaMax_pp.value, ConfCPRPlotPerRadii.value, 1, ConfUseOLD_possiblyWrong_CPR, ConfMaxQ3IncludedInCPRPlots, false, ConfAtWhichRadiiToCut, ConfAtWhichTPCRadii, ConfFillCPRQA); + pairCloseRejectionTrackV0SE.init(&resultRegistry, &qaRegistry, ConfCPRdeltaPhiMax_pL.value, ConfCPRdeltaEtaMax_pL.value, ConfCPRPlotPerRadii.value, 1, ConfUseOLD_possiblyWrong_CPR, ConfMaxQ3IncludedInCPRPlots, false, ConfAtWhichRadiiToCut, ConfAtWhichTPCRadii, ConfFillCPRQA); + pairCloseRejectionTrackTrackME.init(&resultRegistry, &qaRegistry, ConfCPRdeltaPhiMax_pp.value, ConfCPRdeltaEtaMax_pp.value, ConfCPRPlotPerRadii.value, 2, ConfUseOLD_possiblyWrong_CPR, ConfMaxQ3IncludedInCPRPlots, false, ConfAtWhichRadiiToCut, ConfAtWhichTPCRadii, ConfFillCPRQA); + pairCloseRejectionTrackV0ME.init(&resultRegistry, &qaRegistry, ConfCPRdeltaPhiMax_pL.value, ConfCPRdeltaEtaMax_pL.value, ConfCPRPlotPerRadii.value, 2, ConfUseOLD_possiblyWrong_CPR, ConfMaxQ3IncludedInCPRPlots, true, ConfAtWhichRadiiToCut, ConfAtWhichTPCRadii, ConfFillCPRQA); + } + + // get masses + mMassOne = TDatabasePDG::Instance()->GetParticle(ConfPDGCodePart)->Mass(); + mMassTwo = TDatabasePDG::Instance()->GetParticle(ConfPDGCodePart)->Mass(); + mMassThree = TDatabasePDG::Instance()->GetParticle(ConfPDGCodeV0)->Mass(); + + // get bit for the collision mask + std::bitset<8 * sizeof(aod::femtodreamcollision::BitMaskType)> mask; + int index = 0; + auto& workflows = context.services().get(); + for (DeviceSpec const& device : workflows.devices) { + if (device.name.find("femto-dream-triplet-task-track-track-v0-pb-pb") != std::string::npos) { + if (containsNameValuePair(device.options, "ConfCutPart", ConfCutPart.value) && + containsNameValuePair(device.options, "ConfTPCPIDBit", ConfTPCPIDBit.value) && + containsNameValuePair(device.options, "ConfTPCTOFPIDBit", ConfTPCTOFPIDBit.value) && + containsNameValuePair(device.options, "ConfPIDthrMom", ConfPIDthrMom.value) && + containsNameValuePair(device.options, "ConfMaxpT", ConfMaxpT.value) && + containsNameValuePair(device.options, "ConfMinpT", ConfMinpT.value) && + containsNameValuePair(device.options, "ConfCutV0", ConfCutV0.value) && + containsNameValuePair(device.options, "Conf_ChildPos_CutV0", Conf_ChildPos_CutV0.value) && + containsNameValuePair(device.options, "Conf_ChildPos_TPCBitV0", Conf_ChildPos_TPCBitV0.value) && + containsNameValuePair(device.options, "Conf_ChildNeg_CutV0", Conf_ChildNeg_CutV0.value) && + containsNameValuePair(device.options, "Conf_ChildNeg_TPCBitV0", Conf_ChildNeg_TPCBitV0.value) && + containsNameValuePair(device.options, "Conf_minInvMass_V0", Conf_minInvMass_V0.value) && + containsNameValuePair(device.options, "Conf_maxInvMass_V0", Conf_maxInvMass_V0.value) && + containsNameValuePair(device.options, "Conf_minInvMassAnti_V0", Conf_minInvMassAnti_V0.value) && + containsNameValuePair(device.options, "Conf_maxInvMassAnti_V0", Conf_maxInvMassAnti_V0.value) && + containsNameValuePair(device.options, "Conf_minPt_V0", Conf_minPt_V0.value) && + containsNameValuePair(device.options, "Conf_maxPt_V0", Conf_maxPt_V0.value)) { + mask.set(index); + MaskBit = static_cast(mask.to_ulong()); + LOG(info) << "Device name matched: " << device.name; + LOG(info) << "Bitmask for collisions: " << mask.to_string(); + break; + } else { + index++; + } + } + } + + if ((doprocessSameEvent && doprocessSameEventMasked) || + (doprocessMixedEvent && doprocessMixedEventMasked) || + (doprocessSameEventMC && doprocessSameEventMCMasked) || + (doprocessMixedEventMC && doprocessMixedEventMCMasked)) { + LOG(fatal) << "Normal and masked processing cannot be activated simultaneously!"; + } + + if ((ConfMixIfTripletPresent && ConfMixIfTVOPairPresent) || + (ConfMixIfTripletPresent && ConfMixIfTOrVOPartsPresent) || + (ConfMixIfTVOPairPresent && ConfMixIfTOrVOPartsPresent)) { + LOG(fatal) << "Only one method of mixing can be chosen!"; + } + } + + template + void fillCollision(CollisionType col) + { + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hSECollisionBins"), colBinning.getBin({col.posZ(), col.multNtr()})); + eventHisto.fillQA(col); + } + + /// This function processes the same event and takes care of all the histogramming + /// @tparam PartitionType + /// @tparam PartType + /// @tparam isMC: enables Monte Carlo truth specific histograms + /// @param groupSelectedTracks partition for the first particle passed by the process function + /// @param parts femtoDreamParticles table (in case of Monte Carlo joined with FemtoDreamMCLabels) + /// @param magFieldTesla magnetic field of the collision + /// @param multCol multiplicity of the collision + template + void doSameEvent(PartitionType groupSelectedTracks, PartitionType groupSelectedV0s, PartType parts, float magFieldTesla, int multCol, float centCol) + { + /// Histograming tracks + for (auto& part : groupSelectedTracks) { + trackHistoSelectedParts.fillQA(part, aod::femtodreamparticle::kPt, multCol, centCol); + } + /// Histograming V0s + for (auto& V0 : groupSelectedV0s) { + const auto& posChild = parts.iteratorAt(V0.index() - 2); + const auto& negChild = parts.iteratorAt(V0.index() - 1); + + if (((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && + (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && + (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && + (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { + particleHistoSelectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, multCol, centCol); + particleHistoPosChild.fillQA(posChild, aod::femtodreamparticle::kPt, multCol, centCol); + particleHistoNegChild.fillQA(negChild, aod::femtodreamparticle::kPt, multCol, centCol); + } + } + + /// Now build the combinations + for (auto& V0 : groupSelectedV0s) { + const auto& posChild = parts.iteratorAt(V0.index() - 2); + const auto& negChild = parts.iteratorAt(V0.index() - 1); + + const auto& childrenPos = posChild.childrenIds(); + const auto& childrenNeg = negChild.childrenIds(); + auto posID = childrenPos[0]; + auto negID = childrenNeg[1]; + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleaner"), posID, negID); + + if (!((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && + (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && + (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && + (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { + continue; + } + + for (auto& [T1, T2] : combinations(CombinationsStrictlyUpperIndexPolicy(groupSelectedTracks, groupSelectedTracks))) { + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPos"), T1.index(), posID); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNeg"), T1.index(), negID); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPos"), T2.index(), posID); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNeg"), T2.index(), negID); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosGlobal"), T1.globalIndex(), posID); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegGlobal"), T1.globalIndex(), negID); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosGlobal"), T2.globalIndex(), posID); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegGlobal"), T2.globalIndex(), negID); + auto Q3 = FemtoDreamMath::getQ3(T1, mMassOne, T2, mMassTwo, V0, mMassThree); + // Close pair rejection + if (ConfIsCPR.value) { + if (pairCloseRejectionTrackTrackSE.isClosePair(T1, T2, parts, magFieldTesla, Q3)) { + continue; + } + if (pairCloseRejectionTrackV0SE.isClosePair(T1, V0, parts, magFieldTesla, Q3)) { + continue; + } + if (pairCloseRejectionTrackV0SE.isClosePair(T2, V0, parts, magFieldTesla, Q3)) { + continue; + } + } + + // track cleaning + if (!pairCleanerTrackTrack.isCleanPair(T1, T2, parts)) { + continue; + } + if (!pairCleanerTrackV0.isCleanPair(T2, V0, parts)) { + continue; + } + if (!pairCleanerTrackV0.isCleanPair(T1, V0, parts)) { + continue; + } + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosAfter"), T1.index(), posID); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegAfter"), T1.index(), negID); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosAfter"), T2.index(), posID); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegAfter"), T2.index(), negID); + // fill inv Mass as a function of Q3 for purity fits + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvSE_Lambda"), Q3, V0.mLambda()); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvSE_AntiLambda"), Q3, V0.mAntiLambda()); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/particle_pT_in_Triplet_SE"), T1.pt(), T2.pt(), V0.pt(), Q3); + sameEventCont.setTriplet(T1, T2, V0, multCol, Q3); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentrality"), centCol, Q3); + } + } + } + + /// process function to call doSameEvent with Data + /// \param col subscribe to the collision table (Data) + /// \param parts subscribe to the femtoDreamParticleTable + void processSameEvent(FilteredFDCollision& col, + o2::aod::FDParticles& parts) + { + fillCollision(col); + auto thegroupSelectedTracks = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (auto& part : thegroupSelectedTracks) { + trackHistoALLSelectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + } + auto thegroupSelectedV0s = SelectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); /// Histograming V0s + for (auto& V0 : thegroupSelectedV0s) { + const auto& posChild = parts.iteratorAt(V0.index() - 2); + const auto& negChild = parts.iteratorAt(V0.index() - 1); + + if (((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && + (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && + (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && + (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { + particleHistoALLSelectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + particleHistoALLPosChild.fillQA(posChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + particleHistoALLNegChild.fillQA(negChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + } + } + if (thegroupSelectedTracks.size() < 2 || thegroupSelectedV0s.size() < 1) { + return; + } + doSameEvent(thegroupSelectedTracks, thegroupSelectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); + } + PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processSameEvent, "Enable processing same event", true); + + /// process function to call doSameEvent with Data which has a mask for containing particles or not + /// \param col subscribe to the collision table (Data) + /// \param parts subscribe to the femtoDreamParticleTable + void processSameEventMasked(MaskedCollision& col, o2::aod::FDParticles& parts) + { + fillCollision(col); + auto thegroupSelectedTracks = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (auto& part : thegroupSelectedTracks) { + trackHistoALLSelectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + } + auto thegroupSelectedV0s = SelectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (auto& V0 : thegroupSelectedV0s) { + const auto& posChild = parts.iteratorAt(V0.index() - 2); + const auto& negChild = parts.iteratorAt(V0.index() - 1); + + if (((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && + (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && + (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && + (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { + particleHistoALLSelectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + particleHistoALLPosChild.fillQA(posChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + particleHistoALLNegChild.fillQA(negChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + } + } + if (thegroupSelectedTracks.size() < 2 || thegroupSelectedV0s.size() < 1) { + return; + } + doSameEvent(thegroupSelectedTracks, thegroupSelectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); + } + PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processSameEventMasked, "Enable processing same event with masks", false); + + /// process function for to call doSameEvent with Monte Carlo + /// \param col subscribe to the collision table (Monte Carlo Reconstructed reconstructed) + /// \param parts subscribe to joined table FemtoDreamParticles and FemtoDreamMCLables to access Monte Carlo truth + /// \param FemtoDreamMCParticles subscribe to the Monte Carlo truth table + void processSameEventMC(o2::aod::FDCollision& col, + soa::Join& parts, + o2::aod::FDMCParticles&) + { + fillCollision(col); + auto thegroupSelectedTracks = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (auto& part : thegroupSelectedTracks) { + trackHistoALLSelectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + ThreeBodyQARegistry.fill(HIST("TrackMC_QA/hMazzachi"), part.fdMCParticle().pt(), (part.pt() - part.fdMCParticle().pt()) / part.fdMCParticle().pt()); + } + auto thegroupSelectedV0s = SelectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (auto& V0 : thegroupSelectedV0s) { + const auto& posChild = parts.iteratorAt(V0.index() - 2); + const auto& negChild = parts.iteratorAt(V0.index() - 1); + + if (((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && + (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && + (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && + (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { + particleHistoALLSelectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + particleHistoALLPosChild.fillQA(posChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + particleHistoALLNegChild.fillQA(negChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + } + } + if (thegroupSelectedTracks.size() < 2 || thegroupSelectedV0s.size() < 1) { + return; + } + doSameEvent(thegroupSelectedTracks, thegroupSelectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); + } + PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processSameEventMC, "Enable processing same event for Monte Carlo", false); + + /// process function for to call doSameEvent with Monte Carlo which has a mask for containing particles or not + /// \param col subscribe to the collision table (Monte Carlo Reconstructed reconstructed) + /// \param parts subscribe to joined table FemtoDreamParticles and FemtoDreamMCLables to access Monte Carlo truth + /// \param FemtoDreamMCParticles subscribe to the Monte Carlo truth table + void processSameEventMCMasked(MaskedCollision& col, + soa::Join& parts, + o2::aod::FDMCParticles&) + { + fillCollision(col); + auto thegroupSelectedTracks = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (auto& part : thegroupSelectedTracks) { + trackHistoALLSelectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + ThreeBodyQARegistry.fill(HIST("TrackMC_QA/hMazzachi"), part.fdMCParticle().pt(), (part.pt() - part.fdMCParticle().pt()) / part.fdMCParticle().pt()); + } + auto thegroupSelectedV0s = SelectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (auto& V0 : thegroupSelectedV0s) { + const auto& posChild = parts.iteratorAt(V0.index() - 2); + const auto& negChild = parts.iteratorAt(V0.index() - 1); + + if (((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && + (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && + (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && + (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { + particleHistoALLSelectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + particleHistoALLPosChild.fillQA(posChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + particleHistoALLNegChild.fillQA(negChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + } + } + if (thegroupSelectedTracks.size() < 2 || thegroupSelectedV0s.size() < 1) { + return; + } + doSameEvent(thegroupSelectedTracks, thegroupSelectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); + } + PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processSameEventMCMasked, "Enable processing same event for Monte Carlo", false); + + /// This function processes the mixed event + /// \tparam PartitionType + /// \tparam PartType + /// \tparam isMC: enables Monte Carlo truth specific histograms + /// \param groupPartsOne partition for the first particle passed by the process function + /// \param groupPartsTwo partition for the second particle passed by the process function + /// \param groupPartsThree partition for the third particle passed by the process function + /// \param parts femtoDreamParticles table (in case of Monte Carlo joined with FemtoDreamMCLabels) + /// \param magFieldTesla magnetic field of the collision + /// \param multCol multiplicity of the collision + template + void doMixedEvent(PartitionType groupPartsOne, PartitionType groupPartsTwo, PartitionType groupPartsThree, PartType parts, float magFieldTesla, int multCol) + { + for (auto& [T1, T2, V0] : combinations(CombinationsFullIndexPolicy(groupPartsOne, groupPartsTwo, groupPartsThree))) { + const auto& posChild = parts.iteratorAt(V0.globalIndex() - 2); + const auto& negChild = parts.iteratorAt(V0.globalIndex() - 1); + + if (!((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && + (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && + (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && + (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { + continue; + } + + auto Q3 = FemtoDreamMath::getQ3(T1, mMassOne, T2, mMassTwo, V0, mMassThree); + // Close pair rejection + if (ConfIsCPR.value) { + if (pairCloseRejectionTrackTrackME.isClosePair(T1, T2, parts, magFieldTesla, Q3)) { + continue; + } + if (pairCloseRejectionTrackV0ME.isClosePair(T1, V0, parts, magFieldTesla, Q3)) { + continue; + } + if (pairCloseRejectionTrackV0ME.isClosePair(T2, V0, parts, magFieldTesla, Q3)) { + continue; + } + } + + // fill inv Mass as a function of Q3 for purity fits + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvME_Lambda"), Q3, V0.mLambda()); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvME_AntiLambda"), Q3, V0.mAntiLambda()); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/particle_pT_in_Triplet_ME"), T1.pt(), T2.pt(), V0.pt(), Q3); + mixedEventCont.setTriplet(T1, T2, V0, multCol, Q3); + } + } + + /// process function for to call doMixedEvent with Data + /// @param cols subscribe to the collisions table (Data) + /// @param parts subscribe to the femtoDreamParticleTable + void processMixedEvent(FilteredFDCollisions& cols, + o2::aod::FDParticles& parts) + { + for (auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, ConfNEventsMix, -1, cols, cols, cols)) { + const int multiplicityCol = collision1.multNtr(); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision1.multV0M()); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision2.multV0M()); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision3.multV0M()); + + auto groupPartsOne = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); + auto groupPartsTwo = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); + auto groupPartsThree = SelectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); + + const auto& magFieldTesla1 = collision1.magField(); + const auto& magFieldTesla2 = collision2.magField(); + const auto& magFieldTesla3 = collision3.magField(); + if ((magFieldTesla1 != magFieldTesla2) || (magFieldTesla2 != magFieldTesla3) || (magFieldTesla1 != magFieldTesla3)) { + continue; + } + + doMixedEvent(groupPartsOne, groupPartsTwo, groupPartsThree, parts, magFieldTesla1, multiplicityCol); + } + } + PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processMixedEvent, "Enable processing mixed events", true); + + /// process function for to call doMixedEvent with Data which has a mask for containing particles or not + /// @param cols subscribe to the collisions table (Data) + /// @param parts subscribe to the femtoDreamParticleTable + void processMixedEventMasked(MaskedCollisions& cols, o2::aod::FDParticles& parts) + { + if (ConfMixIfTripletPresent || ConfMixIfTVOPairPresent) { + Partition PartitionMaskedCol1 = (ConfMixIfTripletPresent && (aod::femtodreamcollision::bitmaskTrackTwo & MaskBit) == MaskBit && (aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit) || + (ConfMixIfTVOPairPresent && (aod::femtodreamcollision::bitmaskTrackOne & MaskBit) == MaskBit && (aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit); + PartitionMaskedCol1.bindTable(cols); + + for (auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, ConfNEventsMix, -1, *PartitionMaskedCol1.mFiltered, *PartitionMaskedCol1.mFiltered, *PartitionMaskedCol1.mFiltered)) { + + const int multiplicityCol = collision1.multNtr(); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision1.multV0M()); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision2.multV0M()); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision3.multV0M()); + + auto groupPartsOne = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); + auto groupPartsTwo = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); + auto groupPartsThree = SelectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); + + const auto& magFieldTesla1 = collision1.magField(); + const auto& magFieldTesla2 = collision2.magField(); + const auto& magFieldTesla3 = collision3.magField(); + + if ((magFieldTesla1 != magFieldTesla2) || (magFieldTesla2 != magFieldTesla3) || (magFieldTesla1 != magFieldTesla3)) { + continue; + } + doMixedEvent(groupPartsOne, groupPartsTwo, groupPartsThree, parts, magFieldTesla1, multiplicityCol); + } + } else if (ConfMixIfTOrVOPartsPresent) { + Partition PartitionMaskedColT = ((aod::femtodreamcollision::bitmaskTrackOne & MaskBit) == MaskBit); + Partition PartitionMaskedColV0 = ((aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit); + PartitionMaskedColT.bindTable(cols); + PartitionMaskedColV0.bindTable(cols); + + for (auto& [ColWithTrack1, ColWithTrack2, ColWithV0] : soa::combinations(soa::CombinationsBlockFullIndexPolicy(colBinning, ConfNEventsMix, -1, *PartitionMaskedColT.mFiltered, *PartitionMaskedColT.mFiltered, *PartitionMaskedColV0.mFiltered))) { + if (ColWithTrack1.globalIndex() == ColWithTrack2.globalIndex() || ColWithTrack1.globalIndex() == ColWithV0.globalIndex() || ColWithTrack2.globalIndex() == ColWithV0.globalIndex()) { + continue; + } + if (ColWithTrack1.globalIndex() > ColWithTrack2.globalIndex()) { + continue; + } + const int multiplicityCol = ColWithTrack1.multNtr(); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({ColWithTrack1.posZ(), multiplicityCol})); + + auto groupPartsOne = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack1.globalIndex(), cache); + auto groupPartsTwo = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack2.globalIndex(), cache); + auto groupPartsThree = SelectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithV0.globalIndex(), cache); + + const auto& magFieldTesla1 = ColWithTrack1.magField(); + const auto& magFieldTesla2 = ColWithTrack2.magField(); + const auto& magFieldTesla3 = ColWithV0.magField(); + + if ((magFieldTesla1 != magFieldTesla2) || (magFieldTesla2 != magFieldTesla3) || (magFieldTesla1 != magFieldTesla3)) { + continue; + } + doMixedEvent(groupPartsOne, groupPartsTwo, groupPartsThree, parts, magFieldTesla1, multiplicityCol); + } + } + } + PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processMixedEventMasked, "Enable processing mixed events", false); + + /// brief process function for to call doMixedEvent with Monte Carlo + /// @param cols subscribe to the collisions table (Monte Carlo Reconstructed reconstructed) + /// @param parts subscribe to joined table FemtoDreamParticles and FemtoDreamMCLables to access Monte Carlo truth + /// @param FemtoDreamMCParticles subscribe to the Monte Carlo truth table + void processMixedEventMC(o2::aod::FDCollisions& cols, + soa::Join& parts, + o2::aod::FDMCParticles&) + { + for (auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, ConfNEventsMix, -1, cols, cols, cols)) { + + const int multiplicityCol = collision1.multNtr(); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); + + auto groupPartsOne = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); + auto groupPartsTwo = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); + auto groupPartsThree = SelectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); + + const auto& magFieldTesla1 = collision1.magField(); + const auto& magFieldTesla2 = collision2.magField(); + const auto& magFieldTesla3 = collision3.magField(); + + if ((magFieldTesla1 != magFieldTesla2) || (magFieldTesla2 != magFieldTesla3) || (magFieldTesla1 != magFieldTesla3)) { + continue; + } + // CONSIDER testing different strategies to which events to use + + doMixedEvent(groupPartsOne, groupPartsTwo, groupPartsThree, parts, magFieldTesla1, multiplicityCol); + } + } + PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processMixedEventMC, "Enable processing mixed events MC", false); + + /// brief process function for to call doMixedEvent with Monte Carlo which has a mask for containing particles or not + /// @param cols subscribe to the collisions table (Monte Carlo Reconstructed reconstructed) + /// @param parts subscribe to joined table FemtoDreamParticles and FemtoDreamMCLables to access Monte Carlo truth + /// @param FemtoDreamMCParticles subscribe to the Monte Carlo truth table + void processMixedEventMCMasked(MaskedCollisions& cols, + soa::Join& parts, + o2::aod::FDMCParticles&) + { + if (ConfMixIfTripletPresent || ConfMixIfTVOPairPresent) { + Partition PartitionMaskedCol1 = (ConfMixIfTripletPresent && (aod::femtodreamcollision::bitmaskTrackTwo & MaskBit) == MaskBit && (aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit) || + (ConfMixIfTVOPairPresent && (aod::femtodreamcollision::bitmaskTrackOne & MaskBit) == MaskBit && (aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit); + PartitionMaskedCol1.bindTable(cols); + + for (auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, ConfNEventsMix, -1, *PartitionMaskedCol1.mFiltered, *PartitionMaskedCol1.mFiltered, *PartitionMaskedCol1.mFiltered)) { + const int multiplicityCol = collision1.multNtr(); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); + + auto groupPartsOne = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); + auto groupPartsTwo = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); + auto groupPartsThree = SelectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); + + const auto& magFieldTesla1 = collision1.magField(); + const auto& magFieldTesla2 = collision2.magField(); + const auto& magFieldTesla3 = collision3.magField(); + + if ((magFieldTesla1 != magFieldTesla2) || (magFieldTesla2 != magFieldTesla3) || (magFieldTesla1 != magFieldTesla3)) { + continue; + } + doMixedEvent(groupPartsOne, groupPartsTwo, groupPartsThree, parts, magFieldTesla1, multiplicityCol); + } + } else if (ConfMixIfTOrVOPartsPresent) { + Partition PartitionMaskedColT = ((aod::femtodreamcollision::bitmaskTrackOne & MaskBit) == MaskBit); + Partition PartitionMaskedColV0 = ((aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit); + PartitionMaskedColT.bindTable(cols); + PartitionMaskedColV0.bindTable(cols); + + for (auto& [ColWithTrack1, ColWithTrack2, ColWithV0] : soa::combinations(soa::CombinationsBlockFullIndexPolicy(colBinning, ConfNEventsMix, -1, *PartitionMaskedColT.mFiltered, *PartitionMaskedColT.mFiltered, *PartitionMaskedColV0.mFiltered))) { + if (ColWithTrack1.globalIndex() == ColWithTrack2.globalIndex() || ColWithTrack1.globalIndex() == ColWithV0.globalIndex() || ColWithTrack2.globalIndex() == ColWithV0.globalIndex()) { + continue; + } + if (ColWithTrack1.globalIndex() > ColWithTrack2.globalIndex()) { + continue; + } + const int multiplicityCol = ColWithTrack1.multNtr(); + ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({ColWithTrack1.posZ(), multiplicityCol})); + + auto groupPartsOne = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack1.globalIndex(), cache); + auto groupPartsTwo = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack2.globalIndex(), cache); + auto groupPartsThree = SelectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithV0.globalIndex(), cache); + + const auto& magFieldTesla1 = ColWithTrack1.magField(); + const auto& magFieldTesla2 = ColWithTrack2.magField(); + const auto& magFieldTesla3 = ColWithV0.magField(); + + if ((magFieldTesla1 != magFieldTesla2) || (magFieldTesla2 != magFieldTesla3) || (magFieldTesla1 != magFieldTesla3)) { + continue; + } + doMixedEvent(groupPartsOne, groupPartsTwo, groupPartsThree, parts, magFieldTesla1, multiplicityCol); + } + } + } + PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processMixedEventMCMasked, "Enable processing mixed events MC", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + WorkflowSpec workflow{ + adaptAnalysisTask(cfgc), + }; + return workflow; +} From 4071b1f1739edef3cb6002bdf8c946d74d428ab5 Mon Sep 17 00:00:00 2001 From: Wioleta Rzesa Date: Sat, 30 Aug 2025 12:33:48 +0200 Subject: [PATCH 2/9] =?UTF-8?q?Fixing=20formating:=20A=20correlation=20tas?= =?UTF-8?q?k=20for=20triplets=20(track-track-v0)=20in=20Pb=E2=80=93Pb=20co?= =?UTF-8?q?llisions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- PWGCF/FemtoDream/Tasks/CMakeLists.txt | 8 ++++---- .../Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/PWGCF/FemtoDream/Tasks/CMakeLists.txt b/PWGCF/FemtoDream/Tasks/CMakeLists.txt index f108cb393a3..df9bb3f9146 100644 --- a/PWGCF/FemtoDream/Tasks/CMakeLists.txt +++ b/PWGCF/FemtoDream/Tasks/CMakeLists.txt @@ -18,11 +18,11 @@ o2physics_add_dpl_workflow(femtodream-triplet-track-track-track SOURCES femtoDreamTripletTaskTrackTrackTrack.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) - + o2physics_add_dpl_workflow(femtodream-triplet-track-track-track-pb-pb SOURCES femtoDreamTripletTaskTrackTrackTrackPbPb.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore - COMPONENT_NAME Analysis) + COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(femtodream-pair-track-v0 SOURCES femtoDreamPairTaskTrackV0.cxx @@ -47,8 +47,8 @@ o2physics_add_dpl_workflow(femtodream-triplet-track-track-v0 o2physics_add_dpl_workflow(femtodream-triplet-track-track-v0-pb-pb SOURCES femtoDreamTripletTaskTrackTrackV0PbPb.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(femtodream-debug-track SOURCES femtoDreamDebugTrack.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx index b97b887deef..95ded5438a3 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx @@ -48,8 +48,8 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { Configurable ConfCentralityMin{"ConfCentralityMin", 0, "Event sel: Minimum Centrality Percentile"}; Configurable ConfCentralityMax{"ConfCentralityMax", 10, "Event sel: Maximum Centrality Percentile"}; Configurable ConfZVertexCut{"confZVertexCut", 10.f, "Event sel: Maximum z-Vertex (cm)"}; - Filter EventCentrality = aod::femtodreamcollision::multV0M >= ConfCentralityMin && aod::femtodreamcollision::multV0M <= ConfCentralityMax; - Filter EventVertex = (nabs(aod::collision::posZ) < ConfZVertexCut); + Filter EventCentrality = aod::femtodreamcollision::multV0M >= ConfCentralityMin && aod::femtodreamcollision::multV0M <= ConfCentralityMax; + Filter EventVertex = (nabs(aod::collision::posZ) < ConfZVertexCut); using FilteredFDCollisions = soa::Filtered; using FilteredFDCollision = FilteredFDCollisions::iterator; using MaskedCollisions = soa::Filtered>; @@ -58,7 +58,7 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { aod::femtodreamcollision::BitMaskType MaskBit = -1; float mMassOne = -999, mMassTwo = -999, mMassThree = -999; - //Pair/triplet cuts + // Pair/triplet cuts Configurable ConfMixIfTripletPresent{"ConfMixIfTripletPresent", true, "Use for mixing only events which have a TTV0 triplet"}; Configurable ConfMixIfTVOPairPresent{"ConfMixIfTVOPairPresent", false, "Use for mixing only events which have a TV0 pair (at least one track and one V0)"}; Configurable ConfMixIfTOrVOPartsPresent{"ConfMixIfTOrVOPartsPresent", false, "Use for mixing only events which have at least one particle of interest"}; @@ -162,7 +162,7 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { ConfigurableAxis ConfInvMassBins{"ConfInvMassBins", {200, 1, 1.2}, "InvMass binning"}; /// Correlations - ConfigurableAxis ConfMultBins{"ConfMultBins", {VARIABLE_WIDTH, 0.0f, 23.0f, 38.0f, 53.0f, 81.0f, 110.0f, 157.0f, 205.0f, 278.0f, 351.0f, 455.0f, 559.0f, 703.0f, 848.0f, 1050.0f, 1253.0f, 1530.0f,1668.0f, 1857.0f, 2047.0f, 99999.f}, "Mixing bins - multiplicity"}; + ConfigurableAxis ConfMultBins{"ConfMultBins", {VARIABLE_WIDTH, 0.0f, 23.0f, 38.0f, 53.0f, 81.0f, 110.0f, 157.0f, 205.0f, 278.0f, 351.0f, 455.0f, 559.0f, 703.0f, 848.0f, 1050.0f, 1253.0f, 1530.0f, 1668.0f, 1857.0f, 2047.0f, 99999.f}, "Mixing bins - multiplicity"}; ConfigurableAxis ConfVtxBins{"ConfVtxBins", {VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "Mixing bins - z-vertex"}; ColumnBinningPolicy colBinning{{ConfVtxBins, ConfMultBins}, true}; From 31663fc3b94f85bba1d5889aa2735ca5c58fbaad Mon Sep 17 00:00:00 2001 From: Wioleta Rzesa Date: Sat, 30 Aug 2025 12:49:13 +0200 Subject: [PATCH 3/9] =?UTF-8?q?Fixing=20formating:=20A=20correlation=20tas?= =?UTF-8?q?k=20for=20triplets=20(track-track-v0)=20in=20Pb=E2=80=93Pb=20co?= =?UTF-8?q?llisions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../femtoDreamTripletTaskTrackTrackV0PbPb.cxx | 27 ++++++++++--------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx index 95ded5438a3..dbe124632fc 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx @@ -14,27 +14,28 @@ /// \main author: Laura Serksnyte, laura.serksnyte@tum.de /// \further modifications: Wioleta Rzęsa, wioleta.rzesa@cern.ch +#include "PWGCF/DataModel/FemtoDerived.h" +#include "PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h" +#include "PWGCF/FemtoDream/Core/femtoDreamEventHisto.h" +#include "PWGCF/FemtoDream/Core/femtoDreamPairCleaner.h" +#include "PWGCF/FemtoDream/Core/femtoDreamContainerThreeBody.h" +#include "PWGCF/FemtoDream/Core/femtoDreamDetaDphiStar.h" +#include "PWGCF/FemtoDream/Core/femtoDreamUtils.h" -#include -#include -#include +#include "Framework/ASoAHelpers.h" #include "Framework/AnalysisTask.h" -#include "Framework/runDataProcessing.h" #include "Framework/HistogramRegistry.h" -#include "Framework/ASoAHelpers.h" #include "Framework/O2DatabasePDGPlugin.h" #include "Framework/RunningWorkflowInfo.h" #include "Framework/StepTHn.h" +#include "Framework/runDataProcessing.h" #include "Framework/O2DatabasePDGPlugin.h" + #include "TDatabasePDG.h" -#include "PWGCF/DataModel/FemtoDerived.h" -#include "PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h" -#include "PWGCF/FemtoDream/Core/femtoDreamEventHisto.h" -#include "PWGCF/FemtoDream/Core/femtoDreamPairCleaner.h" -#include "PWGCF/FemtoDream/Core/femtoDreamContainerThreeBody.h" -#include "PWGCF/FemtoDream/Core/femtoDreamDetaDphiStar.h" -#include "PWGCF/FemtoDream/Core/femtoDreamUtils.h" +#include +#include +#include using namespace o2; using namespace o2::analysis::femtoDream; @@ -69,7 +70,7 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { Configurable ConfAtWhichTPCRadii{"ConfAtWhichTPCRadii", 85., "If ConfAtWhichRadiiToCut = 2; this allows to select at which TPC radii to cut"}; /// First 2 tracks of the triplet - Configurable ConfPDGCodePart{"ConfPDGCodePart", 2212, "Particle PDG code"}; //proton + Configurable ConfPDGCodePart{"ConfPDGCodePart", 2212, "Particle PDG code"}; // proton Configurable ConfCutPart{"ConfCutPart", 5542474, "Track - Selection bit from cutCulator"}; Configurable ConfTPCPIDBit{"ConfTPCPIDBit", 16, "PID TPC bit from cutCulator "}; Configurable ConfTPCTOFPIDBit{"ConfTPCTOFPIDBit", 8, "PID TPCTOF bit from cutCulator"}; From e8c736cc974d5e9ad11825827e09138246af26a0 Mon Sep 17 00:00:00 2001 From: Wioleta Rzesa Date: Sat, 30 Aug 2025 12:52:30 +0200 Subject: [PATCH 4/9] =?UTF-8?q?Fixing=20formating:=20A=20correlation=20tas?= =?UTF-8?q?k=20for=20triplets=20(track-track-v0)=20in=20Pb=E2=80=93Pb=20co?= =?UTF-8?q?llisions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx index dbe124632fc..e22bba07712 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx @@ -15,11 +15,11 @@ /// \further modifications: Wioleta Rzęsa, wioleta.rzesa@cern.ch #include "PWGCF/DataModel/FemtoDerived.h" -#include "PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h" -#include "PWGCF/FemtoDream/Core/femtoDreamEventHisto.h" -#include "PWGCF/FemtoDream/Core/femtoDreamPairCleaner.h" #include "PWGCF/FemtoDream/Core/femtoDreamContainerThreeBody.h" #include "PWGCF/FemtoDream/Core/femtoDreamDetaDphiStar.h" +#include "PWGCF/FemtoDream/Core/femtoDreamEventHisto.h" +#include "PWGCF/FemtoDream/Core/femtoDreamPairCleaner.h" +#include "PWGCF/FemtoDream/Core/femtoDreamParticleHisto.h" #include "PWGCF/FemtoDream/Core/femtoDreamUtils.h" #include "Framework/ASoAHelpers.h" @@ -29,13 +29,12 @@ #include "Framework/RunningWorkflowInfo.h" #include "Framework/StepTHn.h" #include "Framework/runDataProcessing.h" -#include "Framework/O2DatabasePDGPlugin.h" #include "TDatabasePDG.h" -#include #include #include +#include using namespace o2; using namespace o2::analysis::femtoDream; From 27ca2db6708ec2d47cab104d0b4fd2f003acdbea Mon Sep 17 00:00:00 2001 From: Wioleta Rzesa Date: Thu, 4 Sep 2025 19:55:38 +0200 Subject: [PATCH 5/9] =?UTF-8?q?Fixing=20formating:=20A=20correlation=20tas?= =?UTF-8?q?k=20for=20triplets=20(track-track-v0)=20in=20Pb=E2=80=93Pb=20co?= =?UTF-8?q?llisions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../femtoDreamTripletTaskTrackTrackV0PbPb.cxx | 702 +++++++++--------- 1 file changed, 352 insertions(+), 350 deletions(-) diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx index e22bba07712..8d97594d332 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx @@ -9,10 +9,10 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -/// \file femtoDreamTripletTaskTrackTrackV0.cxx +/// \file femtoDreamTripletTaskTrackTrackV0PbPb.cxx /// \brief Tasks that reads the track and V0 tables and creates triplets; only two identical tracks and a V0 can be used -/// \main author: Laura Serksnyte, laura.serksnyte@tum.de -/// \further modifications: Wioleta Rzęsa, wioleta.rzesa@cern.ch +/// \author Laura Serksnyte, CERN, laura.serksnyte@cern.ch +/// \author Wioleta Rzęsa, TU München, wioleta.rzesa@cern.ch #include "PWGCF/DataModel/FemtoDerived.h" #include "PWGCF/FemtoDream/Core/femtoDreamContainerThreeBody.h" @@ -30,8 +30,6 @@ #include "Framework/StepTHn.h" #include "Framework/runDataProcessing.h" -#include "TDatabasePDG.h" - #include #include #include @@ -42,110 +40,114 @@ using namespace o2::framework; using namespace o2::framework::expressions; using namespace o2::soa; -struct femtoDreamTripletTaskTrackTrackV0PbPb { +struct FemtoDreamTripletTaskTrackTrackV0PbPb { SliceCache cache; Preslice perCol = aod::femtodreamparticle::fdCollisionId; - Configurable ConfCentralityMin{"ConfCentralityMin", 0, "Event sel: Minimum Centrality Percentile"}; - Configurable ConfCentralityMax{"ConfCentralityMax", 10, "Event sel: Maximum Centrality Percentile"}; - Configurable ConfZVertexCut{"confZVertexCut", 10.f, "Event sel: Maximum z-Vertex (cm)"}; - Filter EventCentrality = aod::femtodreamcollision::multV0M >= ConfCentralityMin && aod::femtodreamcollision::multV0M <= ConfCentralityMax; - Filter EventVertex = (nabs(aod::collision::posZ) < ConfZVertexCut); + Configurable confCentralityMin{"confCentralityMin", 0, "Event sel: Minimum Centrality Percentile"}; + Configurable confCentralityMax{"confCentralityMax", 10, "Event sel: Maximum Centrality Percentile"}; + Configurable confZVertexCut{"confZVertexCut", 10.f, "Event sel: Maximum z-Vertex (cm)"}; + Filter eventCentrality = aod::femtodreamcollision::multV0M >= confCentralityMin && aod::femtodreamcollision::multV0M <= confCentralityMax; + Filter eventVertex = (nabs(aod::collision::posZ) < confZVertexCut); using FilteredFDCollisions = soa::Filtered; using FilteredFDCollision = FilteredFDCollisions::iterator; using MaskedCollisions = soa::Filtered>; using MaskedCollision = MaskedCollisions::iterator; - aod::femtodreamcollision::BitMaskType MaskBit = -1; + aod::femtodreamcollision::BitMaskType maskBit = -1; float mMassOne = -999, mMassTwo = -999, mMassThree = -999; // Pair/triplet cuts - Configurable ConfMixIfTripletPresent{"ConfMixIfTripletPresent", true, "Use for mixing only events which have a TTV0 triplet"}; - Configurable ConfMixIfTVOPairPresent{"ConfMixIfTVOPairPresent", false, "Use for mixing only events which have a TV0 pair (at least one track and one V0)"}; - Configurable ConfMixIfTOrVOPartsPresent{"ConfMixIfTOrVOPartsPresent", false, "Use for mixing only events which have at least one particle of interest"}; + Configurable confMixIfTripletPresent{"confMixIfTripletPresent", true, "Use for mixing only events which have a TTV0 triplet"}; + Configurable confMixIfTVOPairPresent{"confMixIfTVOPairPresent", false, "Use for mixing only events which have a TV0 pair (at least one track and one V0)"}; + Configurable confMixIfTOrVOPartsPresent{"confMixIfTOrVOPartsPresent", false, "Use for mixing only events which have at least one particle of interest"}; + Configurable confMinTrackNumber{"confMinTrackNumber", 2, "Minimum number of tracks in the event"}; + Configurable confMinV0Number{"confMinV0Number", 1, "Minimum number of V0 in the event"}; // which CPR to use, old is with a possible bug and new is fixed - Configurable ConfUseOLD_possiblyWrong_CPR{"ConfUseOLD_possiblyWrong_CPR", true, "Use for old CPR, which possibly has a bug. This is implemented only for debugging reasons to compare old and new code on hyperloop datasets."}; - Configurable ConfAtWhichRadiiToCut{"ConfAtWhichRadiiToCut", 1, "At which radii perform deta dphi selection: 0 - at PV, 1 - averaged phi, 2 - at given radii"}; - Configurable ConfAtWhichTPCRadii{"ConfAtWhichTPCRadii", 85., "If ConfAtWhichRadiiToCut = 2; this allows to select at which TPC radii to cut"}; + Configurable confUseOLDPossiblyWrongCPR{"confUseOLDPossiblyWrongCPR", true, "Use for old CPR, which possibly has a bug. This is implemented only for debugging reasons to compare old and new code on hyperloop datasets."}; + Configurable confAtWhichRadiiToCut{"confAtWhichRadiiToCut", 1, "At which radii perform deta dphi selection: 0 - at PV, 1 - averaged phi, 2 - at given radii"}; + Configurable confAtWhichTPCRadii{"confAtWhichTPCRadii", 85., "If confAtWhichRadiiToCut = 2; this allows to select at which TPC radii to cut"}; /// First 2 tracks of the triplet - Configurable ConfPDGCodePart{"ConfPDGCodePart", 2212, "Particle PDG code"}; // proton - Configurable ConfCutPart{"ConfCutPart", 5542474, "Track - Selection bit from cutCulator"}; - Configurable ConfTPCPIDBit{"ConfTPCPIDBit", 16, "PID TPC bit from cutCulator "}; - Configurable ConfTPCTOFPIDBit{"ConfTPCTOFPIDBit", 8, "PID TPCTOF bit from cutCulator"}; - Configurable ConfMaxpT{"ConfMaxpT", 4.0f, "Maximum transverse momentum of the particles"}; - Configurable ConfMinpT{"ConfMinpT", 0.5f, "Minimum transverse momentum of the particles"}; - Configurable ConfMaxDCAxy{"ConfMaxDCAxy", 0.1f, "Maximum DCAxy of the particles"}; - Configurable ConfMinDCAxy{"ConfMinDCAxy", -0.1f, "Minimum DCAxy of the particles"}; - Configurable ConfPIDthrMom{"ConfPIDthrMom", 0.75f, "Momentum threshold from which TPC and TOF are required for PID"}; - Configurable ConfIsMC{"ConfIsMC", false, "Enable additional Histogramms in the case of a MonteCarlo Run"}; - Configurable ConfUse3D{"ConfUse3D", false, "Enable three dimensional histogramms (to be used only for analysis with high statistics): k* vs mT vs multiplicity"}; - Configurable ConfDCACutPtDep{"ConfDCACutPtDep", false, "Use pt dependent dca cut for tracks"}; + Configurable confPDGCodePart{"confPDGCodePart", 2212, "Particle PDG code"}; // proton + Configurable confCutPart{"confCutPart", 5542474, "Track - Selection bit from cutCulator"}; + Configurable confTPCPIDBit{"confTPCPIDBit", 16, "PID TPC bit from cutCulator "}; + Configurable confTPCTOFPIDBit{"confTPCTOFPIDBit", 8, "PID TPCTOF bit from cutCulator"}; + Configurable confMaxpT{"confMaxpT", 4.0f, "Maximum transverse momentum of the particles"}; + Configurable confMinpT{"confMinpT", 0.5f, "Minimum transverse momentum of the particles"}; + Configurable confMaxDCAxy{"confMaxDCAxy", 0.1f, "Maximum DCAxy of the particles"}; + Configurable confMinDCAxy{"confMinDCAxy", -0.1f, "Minimum DCAxy of the particles"}; + Configurable confPIDthrMom{"confPIDthrMom", 0.75f, "Momentum threshold from which TPC and TOF are required for PID"}; + Configurable confIsMC{"confIsMC", false, "Enable additional Histogramms in the case of a MonteCarlo Run"}; + Configurable confUse3D{"confUse3D", false, "Enable three dimensional histogramms (to be used only for analysis with high statistics): k* vs mT vs multiplicity"}; + Configurable confDCACutPtDep{"confDCACutPtDep", false, "Use pt dependent dca cut for tracks"}; + Configurable confDCACutPtDepPar0{"confDCACutPtDepPar0", 0.0105, "Parameter par[0] of the pt dep cut, par[0] + par[1]/(pT/(GeV/c)−1.1) cm"}; + Configurable confDCACutPtDepPar1{"confDCACutPtDepPar1", 0.035, "Parameter par[1] of the pt dep cut, par[0] + par[1]/(pT/(GeV/c)−1.1) cm"}; /// Partition for selected particles - Partition SelectedParts = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kTrack)) && - ifnode(aod::femtodreamparticle::pt * (nexp(aod::femtodreamparticle::eta) + nexp(-1.f * aod::femtodreamparticle::eta)) / 2.f <= ConfPIDthrMom, ncheckbit(aod::femtodreamparticle::pidcut, ConfTPCPIDBit), ncheckbit(aod::femtodreamparticle::pidcut, ConfTPCTOFPIDBit)) && - (ncheckbit(aod::femtodreamparticle::cut, ConfCutPart)) && - (aod::femtodreamparticle::pt < ConfMaxpT) && - (aod::femtodreamparticle::pt > ConfMinpT) && - ifnode(ConfDCACutPtDep, (nabs(aod::femtodreamparticle::tempFitVar) <= 0.0105f + (0.035f / npow(aod::femtodreamparticle::pt, 1.1f))), - ((aod::femtodreamparticle::tempFitVar >= ConfMinDCAxy) && - (aod::femtodreamparticle::tempFitVar <= ConfMaxDCAxy))); + Partition selectedParts = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kTrack)) && + ifnode(aod::femtodreamparticle::pt * (0.5f * nexp(aod::femtodreamparticle::eta) + 0.5f * nexp(-1.f * aod::femtodreamparticle::eta)) <= confPIDthrMom, ncheckbit(aod::femtodreamparticle::pidcut, confTPCPIDBit), ncheckbit(aod::femtodreamparticle::pidcut, confTPCTOFPIDBit)) && + (ncheckbit(aod::femtodreamparticle::cut, confCutPart)) && + (aod::femtodreamparticle::pt < confMaxpT) && + (aod::femtodreamparticle::pt > confMinpT) && + ifnode(confDCACutPtDep, (nabs(aod::femtodreamparticle::tempFitVar) <= confDCACutPtDepPar0 + (confDCACutPtDepPar1 / npow(aod::femtodreamparticle::pt, 1.1f))), + ((aod::femtodreamparticle::tempFitVar >= confMinDCAxy) && + (aod::femtodreamparticle::tempFitVar <= confMaxDCAxy))); ; - Partition> SelectedPartsMC = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kTrack)) && - ifnode(aod::femtodreamparticle::pt * (nexp(aod::femtodreamparticle::eta) + nexp(-1.f * aod::femtodreamparticle::eta)) / 2.f <= ConfPIDthrMom, ncheckbit(aod::femtodreamparticle::pidcut, ConfTPCPIDBit), ncheckbit(aod::femtodreamparticle::pidcut, ConfTPCTOFPIDBit)) && - (ncheckbit(aod::femtodreamparticle::cut, ConfCutPart)) && - (aod::femtodreamparticle::pt < ConfMaxpT) && - (aod::femtodreamparticle::pt > ConfMinpT) && - ifnode(ConfDCACutPtDep, (nabs(aod::femtodreamparticle::tempFitVar) <= 0.0105f + (0.035f / npow(aod::femtodreamparticle::pt, 1.1f))), - ((aod::femtodreamparticle::tempFitVar >= ConfMinDCAxy) && - (aod::femtodreamparticle::tempFitVar <= ConfMaxDCAxy))); + Partition> selectedPartsMC = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kTrack)) && + ifnode(aod::femtodreamparticle::pt * (0.5f * nexp(aod::femtodreamparticle::eta) + 0.5f * nexp(-1.f * aod::femtodreamparticle::eta)) <= confPIDthrMom, ncheckbit(aod::femtodreamparticle::pidcut, confTPCPIDBit), ncheckbit(aod::femtodreamparticle::pidcut, confTPCTOFPIDBit)) && + (ncheckbit(aod::femtodreamparticle::cut, confCutPart)) && + (aod::femtodreamparticle::pt < confMaxpT) && + (aod::femtodreamparticle::pt > confMinpT) && + ifnode(confDCACutPtDep, (nabs(aod::femtodreamparticle::tempFitVar) <= confDCACutPtDepPar0 + (confDCACutPtDepPar1 / npow(aod::femtodreamparticle::pt, 1.1f))), + ((aod::femtodreamparticle::tempFitVar >= confMinDCAxy) && + (aod::femtodreamparticle::tempFitVar <= confMaxDCAxy))); ; /// Histogramming of selected tracks - FemtoDreamParticleHisto trackHistoSelectedParts; - FemtoDreamParticleHisto trackHistoALLSelectedParts; + FemtoDreamParticleHisto trackHistoselectedParts; + FemtoDreamParticleHisto trackHistoALLselectedParts; /// V0 selection - Configurable ConfPDGCodeV0{"ConfPDGCodeV0", 3122, "V0 PDG code"}; - Configurable ConfCutV0{"ConfCutV0", 7484, "V0 - Selection bit from cutCulator"}; - Configurable Conf_ChildPos_CutV0{"Conf_ChildPos_CutV0", 8234, "Selection bit for positive child of V0"}; - Configurable Conf_ChildPos_TPCBitV0{"Conf_ChildPos_TPCBitV0", 1024, "PID TPC bit for positive child of V0"}; - Configurable Conf_ChildNeg_CutV0{"Conf_ChildNeg_CutV0", 8233, "Selection bit for negative child of V0"}; - Configurable Conf_ChildNeg_TPCBitV0{"Conf_ChildNeg_TPCBitV0", 4096, "PID TPC bit for negative child of V0"}; + Configurable confPDGCodeV0{"confPDGCodeV0", 3122, "V0 PDG code"}; + Configurable confCutV0{"confCutV0", 7518, "V0 - Selection bit from cutCulator"}; + Configurable confChildPosCutV0{"confChildPosCutV0", 8234, "Selection bit for positive child of V0"}; + Configurable confChildPosTPCBitV0{"confChildPosTPCBitV0", 1024, "PID TPC bit for positive child of V0"}; + Configurable confChildNegCutV0{"confChildNegCutV0", 8233, "Selection bit for negative child of V0"}; + Configurable confChildNegTPCBitV0{"confChildNegTPCBitV0", 4096, "PID TPC bit for negative child of V0"}; - Configurable Conf_minInvMass_V0{"Conf_minInvMass_V0", 1.08, "Minimum invariant mass of V0 (particle)"}; - Configurable Conf_maxInvMass_V0{"Conf_maxInvMass_V0", 1.15, "Maximum invariant mass of V0 (particle)"}; - Configurable Conf_minInvMassAnti_V0{"Conf_minInvMassAnti_V0", 1.08, "Minimum invariant mass of V0 (antiparticle)"}; - Configurable Conf_maxInvMassAnti_V0{"Conf_maxInvMassAnti_V0", 1.15, "Maximum invariant mass of V0 (antiparticle)"}; + Configurable confMinInvMassV0{"confMinInvMassV0", 1.08, "Minimum invariant mass of V0 (particle)"}; + Configurable confMaxInvMassV0{"confMaxInvMassV0", 1.15, "Maximum invariant mass of V0 (particle)"}; + Configurable confMinInvMassAntiV0{"confMinInvMassAntiV0", 1.08, "Minimum invariant mass of V0 (antiparticle)"}; + Configurable confMaxInvMassAntiV0{"confMaxInvMassAntiV0", 1.15, "Maximum invariant mass of V0 (antiparticle)"}; - Configurable Conf_minPt_V0{"Conf_minPt_V0", 0.0, "Minimum pT of V0"}; - Configurable Conf_maxPt_V0{"Conf_maxPt_V0", 999.0, "Maximum pT of V0"}; + Configurable confMinPtV0{"confMinPtV0", 0.0, "Minimum pT of V0"}; + Configurable confMaxPtV0{"confMaxPtV0", 999.0, "Maximum pT of V0"}; // Partition for selected particles - Partition SelectedV0s = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kV0)) && - (ncheckbit(aod::femtodreamparticle::cut, ConfCutV0)) && - (aod::femtodreamparticle::mLambda > Conf_minInvMass_V0) && - (aod::femtodreamparticle::mLambda < Conf_maxInvMass_V0) && - (aod::femtodreamparticle::mAntiLambda > Conf_minInvMassAnti_V0) && - (aod::femtodreamparticle::mAntiLambda < Conf_maxInvMassAnti_V0) && - (aod::femtodreamparticle::pt > Conf_minPt_V0) && - (aod::femtodreamparticle::pt < Conf_maxPt_V0); - Partition> SelectedV0sMC = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kV0)) && - (ncheckbit(aod::femtodreamparticle::cut, ConfCutV0)) && - (aod::femtodreamparticle::mLambda > Conf_minInvMass_V0) && - (aod::femtodreamparticle::mLambda < Conf_maxInvMass_V0) && - (aod::femtodreamparticle::mAntiLambda > Conf_minInvMassAnti_V0) && - (aod::femtodreamparticle::mAntiLambda < Conf_maxInvMassAnti_V0) && - (aod::femtodreamparticle::pt > Conf_minPt_V0) && - (aod::femtodreamparticle::pt < Conf_maxPt_V0); + Partition selectedV0s = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kV0)) && + (ncheckbit(aod::femtodreamparticle::cut, confCutV0)) && + (aod::femtodreamparticle::mLambda > confMinInvMassV0) && + (aod::femtodreamparticle::mLambda < confMaxInvMassV0) && + (aod::femtodreamparticle::mAntiLambda > confMinInvMassAntiV0) && + (aod::femtodreamparticle::mAntiLambda < confMaxInvMassAntiV0) && + (aod::femtodreamparticle::pt > confMinPtV0) && + (aod::femtodreamparticle::pt < confMaxPtV0); + Partition> selectedV0sMC = (aod::femtodreamparticle::partType == uint8_t(aod::femtodreamparticle::ParticleType::kV0)) && + (ncheckbit(aod::femtodreamparticle::cut, confCutV0)) && + (aod::femtodreamparticle::mLambda > confMinInvMassV0) && + (aod::femtodreamparticle::mLambda < confMaxInvMassV0) && + (aod::femtodreamparticle::mAntiLambda > confMinInvMassAntiV0) && + (aod::femtodreamparticle::mAntiLambda < confMaxInvMassAntiV0) && + (aod::femtodreamparticle::pt > confMinPtV0) && + (aod::femtodreamparticle::pt < confMaxPtV0); /// Histogramming of selected V0s - FemtoDreamParticleHisto particleHistoSelectedV0s; + FemtoDreamParticleHisto particleHistoselectedV0s; FemtoDreamParticleHisto particleHistoPosChild; FemtoDreamParticleHisto particleHistoNegChild; - FemtoDreamParticleHisto particleHistoALLSelectedV0s; + FemtoDreamParticleHisto particleHistoALLselectedV0s; FemtoDreamParticleHisto particleHistoALLPosChild; FemtoDreamParticleHisto particleHistoALLNegChild; @@ -153,32 +155,32 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { FemtoDreamEventHisto eventHisto; /// Particles - ConfigurableAxis ConfTempFitVarBinsTrack{"ConfTempFitVarBinsTrack", {300, -0.15, 0.15}, "binning of the TempFitVar in the pT vs. TempFitVar plot"}; - ConfigurableAxis ConfTempFitVarpTBins{"ConfTempFitVarpTBins", {20, 0.5, 4.05}, "pT binning of the pT vs. TempFitVar plot (track)"}; - ConfigurableAxis ConfTempFitVarBinsV0{"ConfTempFitVarBinsV0", {300, 0.9, 1}, "binning of the TempFitVar in the pT vs. TempFitVar plot (V0)"}; - ConfigurableAxis ConfTempFitVarBinsV0Child{"ConfTempFitVarBinsV0Child", {300, -0.15, 0.15}, "binning of the TempFitVar in the pT vs. TempFitVar plot (V0 child)"}; - ConfigurableAxis ConfTempFitVarpTV0Bins{"ConfTempFitVarpTV0Bins", {35, 0, 6}, "pT binning of the pT vs. TempFitVar plot (V0)"}; - ConfigurableAxis ConfTempFitVarpTV0Child{"ConfTempFitVarpTV0Child", {35, 0, 6}, "pT binning of the pT vs. TempFitVar plot (V0 child)"}; - ConfigurableAxis ConfInvMassBins{"ConfInvMassBins", {200, 1, 1.2}, "InvMass binning"}; + ConfigurableAxis confTempFitVarBinsTrack{"confTempFitVarBinsTrack", {300, -0.15, 0.15}, "binning of the TempFitVar in the pT vs. TempFitVar plot"}; + ConfigurableAxis confTempFitVarpTBins{"confTempFitVarpTBins", {20, 0.5, 4.05}, "pT binning of the pT vs. TempFitVar plot (track)"}; + ConfigurableAxis confTempFitVarBinsV0{"confTempFitVarBinsV0", {300, 0.9, 1}, "binning of the TempFitVar in the pT vs. TempFitVar plot (V0)"}; + ConfigurableAxis confTempFitVarBinsV0Child{"confTempFitVarBinsV0Child", {300, -0.15, 0.15}, "binning of the TempFitVar in the pT vs. TempFitVar plot (V0 child)"}; + ConfigurableAxis confTempFitVarpTV0Bins{"confTempFitVarpTV0Bins", {35, 0, 6}, "pT binning of the pT vs. TempFitVar plot (V0)"}; + ConfigurableAxis confTempFitVarpTV0Child{"confTempFitVarpTV0Child", {35, 0, 6}, "pT binning of the pT vs. TempFitVar plot (V0 child)"}; + ConfigurableAxis confInvMassBins{"confInvMassBins", {200, 1, 1.2}, "InvMass binning"}; /// Correlations - ConfigurableAxis ConfMultBins{"ConfMultBins", {VARIABLE_WIDTH, 0.0f, 23.0f, 38.0f, 53.0f, 81.0f, 110.0f, 157.0f, 205.0f, 278.0f, 351.0f, 455.0f, 559.0f, 703.0f, 848.0f, 1050.0f, 1253.0f, 1530.0f, 1668.0f, 1857.0f, 2047.0f, 99999.f}, "Mixing bins - multiplicity"}; - ConfigurableAxis ConfVtxBins{"ConfVtxBins", {VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "Mixing bins - z-vertex"}; - - ColumnBinningPolicy colBinning{{ConfVtxBins, ConfMultBins}, true}; - - ConfigurableAxis ConfQ3Bins{"ConfQ3Bins", {2000, 0., 8.}, "binning Q3"}; - ConfigurableAxis ConfQ3BinsFor4D{"ConfQ3BinsFor4D", {500, 0., 2.}, "binning Q3 for 4D hist"}; - Configurable ConfNEventsMix{"ConfNEventsMix", 5, "Number of events for mixing"}; - Configurable ConfIsCPR{"ConfIsCPR", true, "Close Pair Rejection"}; - Configurable ConfFillCPRQA{"ConfFillCPRQA", false, "Fill Close Pair Rejection plots as a function of eta and phi"}; - Configurable ConfCPRPlotPerRadii{"ConfCPRPlotPerRadii", false, "Plot CPR per radii"}; - Configurable ConfCPRdeltaPhiMax_pp{"ConfCPRdeltaPhiMax_pp", 0.01, "Max. Delta Phi for Close Pair Rejection of pp"}; - Configurable ConfCPRdeltaEtaMax_pp{"ConfCPRdeltaEtaMax_pp", 0.01, "Max. Delta Eta for Close Pair Rejection of pp"}; - Configurable ConfCPRdeltaPhiMax_pL{"ConfCPRdeltaPhiMax_pL", 0.1, "Max. Delta Phi for Close Pair Rejection of p and Lambda daughter"}; - Configurable ConfCPRdeltaEtaMax_pL{"ConfCPRdeltaEtaMax_pL", 0.1, "Max. Delta Eta for Close Pair Rejection of p and Lambda daughter"}; - Configurable ConfMaxQ3IncludedInCPRPlots{"ConfMaxQ3IncludedInCPRPlots", 8., "Maximum Q3, for which the pair CPR is included in plots"}; - ConfigurableAxis ConfDummy{"ConfDummy", {1, 0, 1}, "Dummy axis"}; + ConfigurableAxis confMultBins{"confMultBins", {VARIABLE_WIDTH, 0.0f, 23.0f, 38.0f, 53.0f, 81.0f, 110.0f, 157.0f, 205.0f, 278.0f, 351.0f, 455.0f, 559.0f, 703.0f, 848.0f, 1050.0f, 1253.0f, 1530.0f, 1668.0f, 1857.0f, 2047.0f, 99999.f}, "Mixing bins - multiplicity"}; + ConfigurableAxis confVtxBins{"confVtxBins", {VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "Mixing bins - z-vertex"}; + + ColumnBinningPolicy colBinning{{confVtxBins, confMultBins}, true}; + + ConfigurableAxis confQ3Bins{"confQ3Bins", {2000, 0., 8.}, "binning Q3"}; + ConfigurableAxis confQ3BinsFor4D{"confQ3BinsFor4D", {500, 0., 2.}, "binning Q3 for 4D hist"}; + Configurable confNEventsMix{"confNEventsMix", 5, "Number of events for mixing"}; + Configurable confIsCPR{"confIsCPR", true, "Close Pair Rejection"}; + Configurable confFillCPRQA{"confFillCPRQA", false, "Fill Close Pair Rejection plots as a function of eta and phi"}; + Configurable confCPRPlotPerRadii{"confCPRPlotPerRadii", false, "Plot CPR per radii"}; + Configurable confCPRdeltaPhiMaxpp{"confCPRdeltaPhiMaxpp", 0.01, "Max. Delta Phi for Close Pair Rejection of pp"}; + Configurable confCPRdeltaEtaMaxpp{"confCPRdeltaEtaMaxpp", 0.01, "Max. Delta Eta for Close Pair Rejection of pp"}; + Configurable confCPRdeltaPhiMaxpL{"confCPRdeltaPhiMaxpL", 0.1, "Max. Delta Phi for Close Pair Rejection of p and Lambda daughter"}; + Configurable confCPRdeltaEtaMaxpL{"confCPRdeltaEtaMaxpL", 0.1, "Max. Delta Eta for Close Pair Rejection of p and Lambda daughter"}; + Configurable confMaxQ3IncludedInCPRPlots{"confMaxQ3IncludedInCPRPlots", 8., "Maximum Q3, for which the pair CPR is included in plots"}; + ConfigurableAxis confDummy{"confDummy", {1, 0, 1}, "Dummy axis"}; FemtoDreamContainerThreeBody sameEventCont; FemtoDreamContainerThreeBody mixedEventCont; @@ -191,63 +193,63 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { /// Histogram output HistogramRegistry qaRegistry{"TrackQA", {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry resultRegistry{"Correlations", {}, OutputObjHandlingPolicy::AnalysisObject}; - HistogramRegistry ThreeBodyQARegistry{"ThreeBodyQARegistry", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry threeBodyQARegistry{"threeBodyQARegistry", {}, OutputObjHandlingPolicy::AnalysisObject}; void init(InitContext& context) { eventHisto.init(&qaRegistry, false); - colBinning = {{ConfVtxBins, ConfMultBins}, true}; - - trackHistoSelectedParts.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTBins, ConfDummy, ConfDummy, ConfTempFitVarBinsTrack, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, ConfPDGCodePart); - trackHistoALLSelectedParts.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTBins, ConfDummy, ConfDummy, ConfTempFitVarBinsTrack, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, ConfPDGCodePart); - particleHistoSelectedV0s.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Bins, ConfDummy, ConfDummy, ConfTempFitVarBinsV0, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfInvMassBins, ConfDummy, ConfIsMC, ConfPDGCodeV0); - particleHistoPosChild.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Child, ConfDummy, ConfDummy, ConfTempFitVarBinsV0Child, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, 0); - particleHistoNegChild.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Child, ConfDummy, ConfDummy, ConfTempFitVarBinsV0Child, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, 0); - particleHistoALLSelectedV0s.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Bins, ConfDummy, ConfDummy, ConfTempFitVarBinsV0, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfInvMassBins, ConfDummy, ConfIsMC, ConfPDGCodeV0); - particleHistoALLPosChild.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Child, ConfDummy, ConfDummy, ConfTempFitVarBinsV0Child, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, 0); - particleHistoALLNegChild.init(&qaRegistry, ConfDummy, ConfDummy, ConfTempFitVarpTV0Child, ConfDummy, ConfDummy, ConfTempFitVarBinsV0Child, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfDummy, ConfIsMC, 0); - - ThreeBodyQARegistry.add("TripletTaskQA/hSECollisionBins", ";bin;Entries", kTH1F, {{120, -0.5, 119.5}}); - ThreeBodyQARegistry.add("TripletTaskQA/hMECollisionBins", ";bin;Entries", kTH1F, {{120, -0.5, 119.5}}); - ThreeBodyQARegistry.add("TripletTaskQA/hMinvSE_Lambda", ";Q_{3};M_{inv}", kTH2F, {ConfQ3Bins, ConfInvMassBins}); - ThreeBodyQARegistry.add("TripletTaskQA/hMinvME_Lambda", ";Q_{3};M_{inv}", kTH2F, {ConfQ3Bins, ConfInvMassBins}); - ThreeBodyQARegistry.add("TripletTaskQA/hMinvSE_AntiLambda", ";Q_{3};M_{inv}", kTH2F, {ConfQ3Bins, ConfInvMassBins}); - ThreeBodyQARegistry.add("TripletTaskQA/hMinvME_AntiLambda", ";Q_{3};M_{inv}", kTH2F, {ConfQ3Bins, ConfInvMassBins}); - ThreeBodyQARegistry.add("TripletTaskQA/particle_pT_in_Triplet_SE", "; p_{T1} ; p_{T2} ; p_{T3} ; Q_{3}", kTHnSparseF, {ConfTempFitVarpTBins, ConfTempFitVarpTBins, ConfTempFitVarpTV0Bins, ConfQ3BinsFor4D}); - ThreeBodyQARegistry.add("TripletTaskQA/particle_pT_in_Triplet_ME", "; p_{T1} ; p_{T2} ; p_{T3} ; Q_{3}", kTHnSparseF, {ConfTempFitVarpTBins, ConfTempFitVarpTBins, ConfTempFitVarpTV0Bins, ConfQ3BinsFor4D}); - ThreeBodyQARegistry.add("TripletTaskQA/hCentrality", ";Centrality; Q3", kTH2F, {{100, 0, 100}, ConfQ3Bins}); - - std::vector tmpVecMult = ConfMultBins; + colBinning = {{confVtxBins, confMultBins}, true}; + + trackHistoselectedParts.init(&qaRegistry, confDummy, confDummy, confTempFitVarpTBins, confDummy, confDummy, confTempFitVarBinsTrack, confDummy, confDummy, confDummy, confDummy, confDummy, confDummy, confIsMC, confPDGCodePart); + trackHistoALLselectedParts.init(&qaRegistry, confDummy, confDummy, confTempFitVarpTBins, confDummy, confDummy, confTempFitVarBinsTrack, confDummy, confDummy, confDummy, confDummy, confDummy, confDummy, confIsMC, confPDGCodePart); + particleHistoselectedV0s.init(&qaRegistry, confDummy, confDummy, confTempFitVarpTV0Bins, confDummy, confDummy, confTempFitVarBinsV0, confDummy, confDummy, confDummy, confDummy, confInvMassBins, confDummy, confIsMC, confPDGCodeV0); + particleHistoPosChild.init(&qaRegistry, confDummy, confDummy, confTempFitVarpTV0Child, confDummy, confDummy, confTempFitVarBinsV0Child, confDummy, confDummy, confDummy, confDummy, confDummy, confDummy, confIsMC, 0); + particleHistoNegChild.init(&qaRegistry, confDummy, confDummy, confTempFitVarpTV0Child, confDummy, confDummy, confTempFitVarBinsV0Child, confDummy, confDummy, confDummy, confDummy, confDummy, confDummy, confIsMC, 0); + particleHistoALLselectedV0s.init(&qaRegistry, confDummy, confDummy, confTempFitVarpTV0Bins, confDummy, confDummy, confTempFitVarBinsV0, confDummy, confDummy, confDummy, confDummy, confInvMassBins, confDummy, confIsMC, confPDGCodeV0); + particleHistoALLPosChild.init(&qaRegistry, confDummy, confDummy, confTempFitVarpTV0Child, confDummy, confDummy, confTempFitVarBinsV0Child, confDummy, confDummy, confDummy, confDummy, confDummy, confDummy, confIsMC, 0); + particleHistoALLNegChild.init(&qaRegistry, confDummy, confDummy, confTempFitVarpTV0Child, confDummy, confDummy, confTempFitVarBinsV0Child, confDummy, confDummy, confDummy, confDummy, confDummy, confDummy, confIsMC, 0); + + threeBodyQARegistry.add("TripletTaskQA/hSECollisionBins", ";bin;Entries", kTH1F, {{120, -0.5, 119.5}}); + threeBodyQARegistry.add("TripletTaskQA/hMECollisionBins", ";bin;Entries", kTH1F, {{120, -0.5, 119.5}}); + threeBodyQARegistry.add("TripletTaskQA/hMinvSE_Lambda", ";Q_{3};M_{inv}", kTH2F, {confQ3Bins, confInvMassBins}); + threeBodyQARegistry.add("TripletTaskQA/hMinvME_Lambda", ";Q_{3};M_{inv}", kTH2F, {confQ3Bins, confInvMassBins}); + threeBodyQARegistry.add("TripletTaskQA/hMinvSE_AntiLambda", ";Q_{3};M_{inv}", kTH2F, {confQ3Bins, confInvMassBins}); + threeBodyQARegistry.add("TripletTaskQA/hMinvME_AntiLambda", ";Q_{3};M_{inv}", kTH2F, {confQ3Bins, confInvMassBins}); + threeBodyQARegistry.add("TripletTaskQA/particle_pT_in_Triplet_SE", "; p_{T1} ; p_{T2} ; p_{T3} ; Q_{3}", kTHnSparseF, {confTempFitVarpTBins, confTempFitVarpTBins, confTempFitVarpTV0Bins, confQ3BinsFor4D}); + threeBodyQARegistry.add("TripletTaskQA/particle_pT_in_Triplet_ME", "; p_{T1} ; p_{T2} ; p_{T3} ; Q_{3}", kTHnSparseF, {confTempFitVarpTBins, confTempFitVarpTBins, confTempFitVarpTV0Bins, confQ3BinsFor4D}); + threeBodyQARegistry.add("TripletTaskQA/hCentrality", ";Centrality; Q3", kTH2F, {{100, 0, 100}, confQ3Bins}); + + std::vector tmpVecMult = confMultBins; framework::AxisSpec multAxis = {tmpVecMult, "Multiplicity"}; - ThreeBodyQARegistry.add("TripletTaskQA/hSEMultVSGoodTracks", ";Mult;GoodT", kTH2F, {multAxis, {100, 0, 100}}); - ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleaner", ";posDaughtID; negDaughID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); - ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerPos", ";primaryTrack; posDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); - ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerNeg", ";primaryTrack; negDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); - ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerPosGlobal", ";primaryTrackGlobal; posDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); - ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerNegGlobal", ";primaryTrackGlobal; negDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); - ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerPosAfter", ";primaryTrack; posDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); - ThreeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerNegAfter", ";primaryTrack; negDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); - ThreeBodyQARegistry.add("TripletTaskQA/hCentralityME", ";Centrality;Entries", kTH1F, {{100, 0.0, 100.0}}); - sameEventCont.init(&resultRegistry, ConfQ3Bins, ConfMultBins, ConfIsMC); - mixedEventCont.init(&resultRegistry, ConfQ3Bins, ConfMultBins, ConfIsMC); - sameEventCont.setPDGCodes(ConfPDGCodePart, ConfPDGCodePart, ConfPDGCodeV0); - mixedEventCont.setPDGCodes(ConfPDGCodePart, ConfPDGCodePart, ConfPDGCodeV0); + threeBodyQARegistry.add("TripletTaskQA/hSEMultVSGoodTracks", ";Mult;GoodT", kTH2F, {multAxis, {100, 0, 100}}); + threeBodyQARegistry.add("TripletTaskQA/hTestPairCleaner", ";posDaughtID; negDaughID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + threeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerPos", ";primaryTrack; posDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + threeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerNeg", ";primaryTrack; negDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + threeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerPosGlobal", ";primaryTrackGlobal; posDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + threeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerNegGlobal", ";primaryTrackGlobal; negDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + threeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerPosAfter", ";primaryTrack; posDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + threeBodyQARegistry.add("TripletTaskQA/hTestPairCleanerNegAfter", ";primaryTrack; negDaughtID", kTH2F, {{40, -20, 20}, {40, -20, 20}}); + threeBodyQARegistry.add("TripletTaskQA/hCentralityME", ";Centrality;Entries", kTH1F, {{100, 0.0, 100.0}}); + sameEventCont.init(&resultRegistry, confQ3Bins, confMultBins, confIsMC); + mixedEventCont.init(&resultRegistry, confQ3Bins, confMultBins, confIsMC); + sameEventCont.setPDGCodes(confPDGCodePart, confPDGCodePart, confPDGCodeV0); + mixedEventCont.setPDGCodes(confPDGCodePart, confPDGCodePart, confPDGCodeV0); pairCleanerTrackTrack.init(&qaRegistry); pairCleanerTrackV0.init(&qaRegistry); - if (ConfIsCPR.value) { - pairCloseRejectionTrackTrackSE.init(&resultRegistry, &qaRegistry, ConfCPRdeltaPhiMax_pp.value, ConfCPRdeltaEtaMax_pp.value, ConfCPRPlotPerRadii.value, 1, ConfUseOLD_possiblyWrong_CPR, ConfMaxQ3IncludedInCPRPlots, false, ConfAtWhichRadiiToCut, ConfAtWhichTPCRadii, ConfFillCPRQA); - pairCloseRejectionTrackV0SE.init(&resultRegistry, &qaRegistry, ConfCPRdeltaPhiMax_pL.value, ConfCPRdeltaEtaMax_pL.value, ConfCPRPlotPerRadii.value, 1, ConfUseOLD_possiblyWrong_CPR, ConfMaxQ3IncludedInCPRPlots, false, ConfAtWhichRadiiToCut, ConfAtWhichTPCRadii, ConfFillCPRQA); - pairCloseRejectionTrackTrackME.init(&resultRegistry, &qaRegistry, ConfCPRdeltaPhiMax_pp.value, ConfCPRdeltaEtaMax_pp.value, ConfCPRPlotPerRadii.value, 2, ConfUseOLD_possiblyWrong_CPR, ConfMaxQ3IncludedInCPRPlots, false, ConfAtWhichRadiiToCut, ConfAtWhichTPCRadii, ConfFillCPRQA); - pairCloseRejectionTrackV0ME.init(&resultRegistry, &qaRegistry, ConfCPRdeltaPhiMax_pL.value, ConfCPRdeltaEtaMax_pL.value, ConfCPRPlotPerRadii.value, 2, ConfUseOLD_possiblyWrong_CPR, ConfMaxQ3IncludedInCPRPlots, true, ConfAtWhichRadiiToCut, ConfAtWhichTPCRadii, ConfFillCPRQA); + if (confIsCPR.value) { + pairCloseRejectionTrackTrackSE.init(&resultRegistry, &qaRegistry, confCPRdeltaPhiMaxpp.value, confCPRdeltaEtaMaxpp.value, confCPRPlotPerRadii.value, 1, confUseOLDPossiblyWrongCPR, confMaxQ3IncludedInCPRPlots, false, confAtWhichRadiiToCut, confAtWhichTPCRadii, confFillCPRQA); + pairCloseRejectionTrackV0SE.init(&resultRegistry, &qaRegistry, confCPRdeltaPhiMaxpL.value, confCPRdeltaEtaMaxpL.value, confCPRPlotPerRadii.value, 1, confUseOLDPossiblyWrongCPR, confMaxQ3IncludedInCPRPlots, false, confAtWhichRadiiToCut, confAtWhichTPCRadii, confFillCPRQA); + pairCloseRejectionTrackTrackME.init(&resultRegistry, &qaRegistry, confCPRdeltaPhiMaxpp.value, confCPRdeltaEtaMaxpp.value, confCPRPlotPerRadii.value, 2, confUseOLDPossiblyWrongCPR, confMaxQ3IncludedInCPRPlots, false, confAtWhichRadiiToCut, confAtWhichTPCRadii, confFillCPRQA); + pairCloseRejectionTrackV0ME.init(&resultRegistry, &qaRegistry, confCPRdeltaPhiMaxpL.value, confCPRdeltaEtaMaxpL.value, confCPRPlotPerRadii.value, 2, confUseOLDPossiblyWrongCPR, confMaxQ3IncludedInCPRPlots, true, confAtWhichRadiiToCut, confAtWhichTPCRadii, confFillCPRQA); } // get masses - mMassOne = TDatabasePDG::Instance()->GetParticle(ConfPDGCodePart)->Mass(); - mMassTwo = TDatabasePDG::Instance()->GetParticle(ConfPDGCodePart)->Mass(); - mMassThree = TDatabasePDG::Instance()->GetParticle(ConfPDGCodeV0)->Mass(); + mMassOne = o2::constants::physics::MassProton; + mMassTwo = o2::constants::physics::MassProton; + mMassThree = o2::constants::physics::MassLambda; // get bit for the collision mask std::bitset<8 * sizeof(aod::femtodreamcollision::BitMaskType)> mask; @@ -255,25 +257,25 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { auto& workflows = context.services().get(); for (DeviceSpec const& device : workflows.devices) { if (device.name.find("femto-dream-triplet-task-track-track-v0-pb-pb") != std::string::npos) { - if (containsNameValuePair(device.options, "ConfCutPart", ConfCutPart.value) && - containsNameValuePair(device.options, "ConfTPCPIDBit", ConfTPCPIDBit.value) && - containsNameValuePair(device.options, "ConfTPCTOFPIDBit", ConfTPCTOFPIDBit.value) && - containsNameValuePair(device.options, "ConfPIDthrMom", ConfPIDthrMom.value) && - containsNameValuePair(device.options, "ConfMaxpT", ConfMaxpT.value) && - containsNameValuePair(device.options, "ConfMinpT", ConfMinpT.value) && - containsNameValuePair(device.options, "ConfCutV0", ConfCutV0.value) && - containsNameValuePair(device.options, "Conf_ChildPos_CutV0", Conf_ChildPos_CutV0.value) && - containsNameValuePair(device.options, "Conf_ChildPos_TPCBitV0", Conf_ChildPos_TPCBitV0.value) && - containsNameValuePair(device.options, "Conf_ChildNeg_CutV0", Conf_ChildNeg_CutV0.value) && - containsNameValuePair(device.options, "Conf_ChildNeg_TPCBitV0", Conf_ChildNeg_TPCBitV0.value) && - containsNameValuePair(device.options, "Conf_minInvMass_V0", Conf_minInvMass_V0.value) && - containsNameValuePair(device.options, "Conf_maxInvMass_V0", Conf_maxInvMass_V0.value) && - containsNameValuePair(device.options, "Conf_minInvMassAnti_V0", Conf_minInvMassAnti_V0.value) && - containsNameValuePair(device.options, "Conf_maxInvMassAnti_V0", Conf_maxInvMassAnti_V0.value) && - containsNameValuePair(device.options, "Conf_minPt_V0", Conf_minPt_V0.value) && - containsNameValuePair(device.options, "Conf_maxPt_V0", Conf_maxPt_V0.value)) { + if (containsNameValuePair(device.options, "confCutPart", confCutPart.value) && + containsNameValuePair(device.options, "confTPCPIDBit", confTPCPIDBit.value) && + containsNameValuePair(device.options, "confTPCTOFPIDBit", confTPCTOFPIDBit.value) && + containsNameValuePair(device.options, "confPIDthrMom", confPIDthrMom.value) && + containsNameValuePair(device.options, "confMaxpT", confMaxpT.value) && + containsNameValuePair(device.options, "confMinpT", confMinpT.value) && + containsNameValuePair(device.options, "confCutV0", confCutV0.value) && + containsNameValuePair(device.options, "confChildPosCutV0", confChildPosCutV0.value) && + containsNameValuePair(device.options, "confChildPosTPCBitV0", confChildPosTPCBitV0.value) && + containsNameValuePair(device.options, "confChildNegCutV0", confChildNegCutV0.value) && + containsNameValuePair(device.options, "confChildNegTPCBitV0", confChildNegTPCBitV0.value) && + containsNameValuePair(device.options, "confMinInvMassV0", confMinInvMassV0.value) && + containsNameValuePair(device.options, "confMaxInvMassV0", confMaxInvMassV0.value) && + containsNameValuePair(device.options, "confMinInvMassAntiV0", confMinInvMassAntiV0.value) && + containsNameValuePair(device.options, "confMaxInvMassAntiV0", confMaxInvMassAntiV0.value) && + containsNameValuePair(device.options, "confMinPtV0", confMinPtV0.value) && + containsNameValuePair(device.options, "confMaxPtV0", confMaxPtV0.value)) { mask.set(index); - MaskBit = static_cast(mask.to_ulong()); + maskBit = static_cast(mask.to_ulong()); LOG(info) << "Device name matched: " << device.name; LOG(info) << "Bitmask for collisions: " << mask.to_string(); break; @@ -290,9 +292,9 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { LOG(fatal) << "Normal and masked processing cannot be activated simultaneously!"; } - if ((ConfMixIfTripletPresent && ConfMixIfTVOPairPresent) || - (ConfMixIfTripletPresent && ConfMixIfTOrVOPartsPresent) || - (ConfMixIfTVOPairPresent && ConfMixIfTOrVOPartsPresent)) { + if ((confMixIfTripletPresent && confMixIfTVOPairPresent) || + (confMixIfTripletPresent && confMixIfTOrVOPartsPresent) || + (confMixIfTVOPairPresent && confMixIfTOrVOPartsPresent)) { LOG(fatal) << "Only one method of mixing can be chosen!"; } } @@ -300,7 +302,7 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { template void fillCollision(CollisionType col) { - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hSECollisionBins"), colBinning.getBin({col.posZ(), col.multNtr()})); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hSECollisionBins"), colBinning.getBin({col.posZ(), col.multNtr()})); eventHisto.fillQA(col); } @@ -313,29 +315,29 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { /// @param magFieldTesla magnetic field of the collision /// @param multCol multiplicity of the collision template - void doSameEvent(PartitionType groupSelectedTracks, PartitionType groupSelectedV0s, PartType parts, float magFieldTesla, int multCol, float centCol) + void doSameEvent(PartitionType groupSelectedTracks, PartitionType groupselectedV0s, PartType parts, float magFieldTesla, int multCol, float centCol) { /// Histograming tracks - for (auto& part : groupSelectedTracks) { - trackHistoSelectedParts.fillQA(part, aod::femtodreamparticle::kPt, multCol, centCol); + for (const auto& part : groupSelectedTracks) { + trackHistoselectedParts.fillQA(part, aod::femtodreamparticle::kPt, multCol, centCol); } /// Histograming V0s - for (auto& V0 : groupSelectedV0s) { + for (const auto& V0 : groupselectedV0s) { const auto& posChild = parts.iteratorAt(V0.index() - 2); const auto& negChild = parts.iteratorAt(V0.index() - 1); - if (((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && - (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && - (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && - (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { - particleHistoSelectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, multCol, centCol); + if (((posChild.cut() & confChildPosCutV0) == confChildPosCutV0 && + (posChild.pidcut() & confChildPosTPCBitV0) == confChildPosTPCBitV0 && + (negChild.cut() & confChildNegCutV0) == confChildNegCutV0 && + (negChild.pidcut() & confChildNegTPCBitV0) == confChildNegTPCBitV0)) { + particleHistoselectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, multCol, centCol); particleHistoPosChild.fillQA(posChild, aod::femtodreamparticle::kPt, multCol, centCol); particleHistoNegChild.fillQA(negChild, aod::femtodreamparticle::kPt, multCol, centCol); } } /// Now build the combinations - for (auto& V0 : groupSelectedV0s) { + for (const auto& V0 : groupselectedV0s) { const auto& posChild = parts.iteratorAt(V0.index() - 2); const auto& negChild = parts.iteratorAt(V0.index() - 1); @@ -343,34 +345,34 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { const auto& childrenNeg = negChild.childrenIds(); auto posID = childrenPos[0]; auto negID = childrenNeg[1]; - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleaner"), posID, negID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleaner"), posID, negID); - if (!((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && - (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && - (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && - (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { + if (!((posChild.cut() & confChildPosCutV0) == confChildPosCutV0 && + (posChild.pidcut() & confChildPosTPCBitV0) == confChildPosTPCBitV0 && + (negChild.cut() & confChildNegCutV0) == confChildNegCutV0 && + (negChild.pidcut() & confChildNegTPCBitV0) == confChildNegTPCBitV0)) { continue; } - for (auto& [T1, T2] : combinations(CombinationsStrictlyUpperIndexPolicy(groupSelectedTracks, groupSelectedTracks))) { - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPos"), T1.index(), posID); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNeg"), T1.index(), negID); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPos"), T2.index(), posID); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNeg"), T2.index(), negID); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosGlobal"), T1.globalIndex(), posID); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegGlobal"), T1.globalIndex(), negID); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosGlobal"), T2.globalIndex(), posID); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegGlobal"), T2.globalIndex(), negID); - auto Q3 = FemtoDreamMath::getQ3(T1, mMassOne, T2, mMassTwo, V0, mMassThree); + for (const auto& [T1, T2] : combinations(CombinationsStrictlyUpperIndexPolicy(groupSelectedTracks, groupSelectedTracks))) { + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPos"), T1.index(), posID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNeg"), T1.index(), negID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPos"), T2.index(), posID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNeg"), T2.index(), negID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosGlobal"), T1.globalIndex(), posID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegGlobal"), T1.globalIndex(), negID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosGlobal"), T2.globalIndex(), posID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegGlobal"), T2.globalIndex(), negID); + auto q3 = FemtoDreamMath::getQ3(T1, mMassOne, T2, mMassTwo, V0, mMassThree); // Close pair rejection - if (ConfIsCPR.value) { - if (pairCloseRejectionTrackTrackSE.isClosePair(T1, T2, parts, magFieldTesla, Q3)) { + if (confIsCPR.value) { + if (pairCloseRejectionTrackTrackSE.isClosePair(T1, T2, parts, magFieldTesla, q3)) { continue; } - if (pairCloseRejectionTrackV0SE.isClosePair(T1, V0, parts, magFieldTesla, Q3)) { + if (pairCloseRejectionTrackV0SE.isClosePair(T1, V0, parts, magFieldTesla, q3)) { continue; } - if (pairCloseRejectionTrackV0SE.isClosePair(T2, V0, parts, magFieldTesla, Q3)) { + if (pairCloseRejectionTrackV0SE.isClosePair(T2, V0, parts, magFieldTesla, q3)) { continue; } } @@ -385,16 +387,16 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { if (!pairCleanerTrackV0.isCleanPair(T1, V0, parts)) { continue; } - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosAfter"), T1.index(), posID); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegAfter"), T1.index(), negID); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosAfter"), T2.index(), posID); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegAfter"), T2.index(), negID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosAfter"), T1.index(), posID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegAfter"), T1.index(), negID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerPosAfter"), T2.index(), posID); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hTestPairCleanerNegAfter"), T2.index(), negID); // fill inv Mass as a function of Q3 for purity fits - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvSE_Lambda"), Q3, V0.mLambda()); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvSE_AntiLambda"), Q3, V0.mAntiLambda()); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/particle_pT_in_Triplet_SE"), T1.pt(), T2.pt(), V0.pt(), Q3); - sameEventCont.setTriplet(T1, T2, V0, multCol, Q3); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentrality"), centCol, Q3); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvSE_Lambda"), q3, V0.mLambda()); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvSE_AntiLambda"), q3, V0.mAntiLambda()); + threeBodyQARegistry.fill(HIST("TripletTaskQA/particle_pT_in_Triplet_SE"), T1.pt(), T2.pt(), V0.pt(), q3); + sameEventCont.setTriplet(T1, T2, V0, multCol, q3); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hCentrality"), centCol, q3); } } } @@ -402,135 +404,135 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { /// process function to call doSameEvent with Data /// \param col subscribe to the collision table (Data) /// \param parts subscribe to the femtoDreamParticleTable - void processSameEvent(FilteredFDCollision& col, + void processSameEvent(const FilteredFDCollision& col, const o2::aod::FDParticles& parts) { fillCollision(col); - auto thegroupSelectedTracks = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); - for (auto& part : thegroupSelectedTracks) { - trackHistoALLSelectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + auto thegroupSelectedTracks = selectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (const auto& part : thegroupSelectedTracks) { + trackHistoALLselectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); } - auto thegroupSelectedV0s = SelectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); /// Histograming V0s - for (auto& V0 : thegroupSelectedV0s) { + auto thegroupselectedV0s = selectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); /// Histograming V0s + for (const auto& V0 : thegroupselectedV0s) { const auto& posChild = parts.iteratorAt(V0.index() - 2); const auto& negChild = parts.iteratorAt(V0.index() - 1); - if (((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && - (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && - (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && - (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { - particleHistoALLSelectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + if (((posChild.cut() & confChildPosCutV0) == confChildPosCutV0 && + (posChild.pidcut() & confChildPosTPCBitV0) == confChildPosTPCBitV0 && + (negChild.cut() & confChildNegCutV0) == confChildNegCutV0 && + (negChild.pidcut() & confChildNegTPCBitV0) == confChildNegTPCBitV0)) { + particleHistoALLselectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); particleHistoALLPosChild.fillQA(posChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); particleHistoALLNegChild.fillQA(negChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); } } - if (thegroupSelectedTracks.size() < 2 || thegroupSelectedV0s.size() < 1) { + if (thegroupSelectedTracks.size() < confMinTrackNumber || thegroupselectedV0s.size() < confMinV0Number) { return; } - doSameEvent(thegroupSelectedTracks, thegroupSelectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); + doSameEvent(thegroupSelectedTracks, thegroupselectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); } - PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processSameEvent, "Enable processing same event", true); + PROCESS_SWITCH(FemtoDreamTripletTaskTrackTrackV0PbPb, processSameEvent, "Enable processing same event", true); /// process function to call doSameEvent with Data which has a mask for containing particles or not /// \param col subscribe to the collision table (Data) /// \param parts subscribe to the femtoDreamParticleTable - void processSameEventMasked(MaskedCollision& col, o2::aod::FDParticles& parts) + void processSameEventMasked(const MaskedCollision& col, const o2::aod::FDParticles& parts) { fillCollision(col); - auto thegroupSelectedTracks = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); - for (auto& part : thegroupSelectedTracks) { - trackHistoALLSelectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + auto thegroupSelectedTracks = selectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (const auto& part : thegroupSelectedTracks) { + trackHistoALLselectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); } - auto thegroupSelectedV0s = SelectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); - for (auto& V0 : thegroupSelectedV0s) { + auto thegroupselectedV0s = selectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (const auto& V0 : thegroupselectedV0s) { const auto& posChild = parts.iteratorAt(V0.index() - 2); const auto& negChild = parts.iteratorAt(V0.index() - 1); - if (((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && - (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && - (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && - (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { - particleHistoALLSelectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + if (((posChild.cut() & confChildPosCutV0) == confChildPosCutV0 && + (posChild.pidcut() & confChildPosTPCBitV0) == confChildPosTPCBitV0 && + (negChild.cut() & confChildNegCutV0) == confChildNegCutV0 && + (negChild.pidcut() & confChildNegTPCBitV0) == confChildNegTPCBitV0)) { + particleHistoALLselectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); particleHistoALLPosChild.fillQA(posChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); particleHistoALLNegChild.fillQA(negChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); } } - if (thegroupSelectedTracks.size() < 2 || thegroupSelectedV0s.size() < 1) { + if (thegroupSelectedTracks.size() < confMinTrackNumber || thegroupselectedV0s.size() < confMinV0Number) { return; } - doSameEvent(thegroupSelectedTracks, thegroupSelectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); + doSameEvent(thegroupSelectedTracks, thegroupselectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); } - PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processSameEventMasked, "Enable processing same event with masks", false); + PROCESS_SWITCH(FemtoDreamTripletTaskTrackTrackV0PbPb, processSameEventMasked, "Enable processing same event with masks", false); /// process function for to call doSameEvent with Monte Carlo /// \param col subscribe to the collision table (Monte Carlo Reconstructed reconstructed) /// \param parts subscribe to joined table FemtoDreamParticles and FemtoDreamMCLables to access Monte Carlo truth /// \param FemtoDreamMCParticles subscribe to the Monte Carlo truth table - void processSameEventMC(o2::aod::FDCollision& col, - soa::Join& parts, - o2::aod::FDMCParticles&) + void processSameEventMC(const o2::aod::FDCollision& col, + const soa::Join& parts, + const o2::aod::FDMCParticles&) { fillCollision(col); - auto thegroupSelectedTracks = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); - for (auto& part : thegroupSelectedTracks) { - trackHistoALLSelectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); - ThreeBodyQARegistry.fill(HIST("TrackMC_QA/hMazzachi"), part.fdMCParticle().pt(), (part.pt() - part.fdMCParticle().pt()) / part.fdMCParticle().pt()); + auto thegroupSelectedTracks = selectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (const auto& part : thegroupSelectedTracks) { + trackHistoALLselectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + threeBodyQARegistry.fill(HIST("TrackMC_QA/hMazzachi"), part.fdMCParticle().pt(), (part.pt() - part.fdMCParticle().pt()) / part.fdMCParticle().pt()); } - auto thegroupSelectedV0s = SelectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); - for (auto& V0 : thegroupSelectedV0s) { + auto thegroupselectedV0s = selectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (const auto& V0 : thegroupselectedV0s) { const auto& posChild = parts.iteratorAt(V0.index() - 2); const auto& negChild = parts.iteratorAt(V0.index() - 1); - if (((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && - (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && - (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && - (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { - particleHistoALLSelectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + if (((posChild.cut() & confChildPosCutV0) == confChildPosCutV0 && + (posChild.pidcut() & confChildPosTPCBitV0) == confChildPosTPCBitV0 && + (negChild.cut() & confChildNegCutV0) == confChildNegCutV0 && + (negChild.pidcut() & confChildNegTPCBitV0) == confChildNegTPCBitV0)) { + particleHistoALLselectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); particleHistoALLPosChild.fillQA(posChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); particleHistoALLNegChild.fillQA(negChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); } } - if (thegroupSelectedTracks.size() < 2 || thegroupSelectedV0s.size() < 1) { + if (thegroupSelectedTracks.size() < confMinTrackNumber || thegroupselectedV0s.size() < confMinV0Number) { return; } - doSameEvent(thegroupSelectedTracks, thegroupSelectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); + doSameEvent(thegroupSelectedTracks, thegroupselectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); } - PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processSameEventMC, "Enable processing same event for Monte Carlo", false); + PROCESS_SWITCH(FemtoDreamTripletTaskTrackTrackV0PbPb, processSameEventMC, "Enable processing same event for Monte Carlo", false); /// process function for to call doSameEvent with Monte Carlo which has a mask for containing particles or not /// \param col subscribe to the collision table (Monte Carlo Reconstructed reconstructed) /// \param parts subscribe to joined table FemtoDreamParticles and FemtoDreamMCLables to access Monte Carlo truth /// \param FemtoDreamMCParticles subscribe to the Monte Carlo truth table - void processSameEventMCMasked(MaskedCollision& col, - soa::Join& parts, - o2::aod::FDMCParticles&) + void processSameEventMCMasked(const MaskedCollision& col, + const soa::Join& parts, + const o2::aod::FDMCParticles&) { fillCollision(col); - auto thegroupSelectedTracks = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); - for (auto& part : thegroupSelectedTracks) { - trackHistoALLSelectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); - ThreeBodyQARegistry.fill(HIST("TrackMC_QA/hMazzachi"), part.fdMCParticle().pt(), (part.pt() - part.fdMCParticle().pt()) / part.fdMCParticle().pt()); + auto thegroupSelectedTracks = selectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (const auto& part : thegroupSelectedTracks) { + trackHistoALLselectedParts.fillQA(part, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + threeBodyQARegistry.fill(HIST("TrackMC_QA/hMazzachi"), part.fdMCParticle().pt(), (part.pt() - part.fdMCParticle().pt()) / part.fdMCParticle().pt()); } - auto thegroupSelectedV0s = SelectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); - for (auto& V0 : thegroupSelectedV0s) { + auto thegroupselectedV0s = selectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); + for (const auto& V0 : thegroupselectedV0s) { const auto& posChild = parts.iteratorAt(V0.index() - 2); const auto& negChild = parts.iteratorAt(V0.index() - 1); - if (((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && - (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && - (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && - (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { - particleHistoALLSelectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); + if (((posChild.cut() & confChildPosCutV0) == confChildPosCutV0 && + (posChild.pidcut() & confChildPosTPCBitV0) == confChildPosTPCBitV0 && + (negChild.cut() & confChildNegCutV0) == confChildNegCutV0 && + (negChild.pidcut() & confChildNegTPCBitV0) == confChildNegTPCBitV0)) { + particleHistoALLselectedV0s.fillQA(V0, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); particleHistoALLPosChild.fillQA(posChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); particleHistoALLNegChild.fillQA(negChild, aod::femtodreamparticle::kPt, col.multNtr(), col.multV0M()); } } - if (thegroupSelectedTracks.size() < 2 || thegroupSelectedV0s.size() < 1) { + if (thegroupSelectedTracks.size() < confMinTrackNumber || thegroupselectedV0s.size() < confMinV0Number) { return; } - doSameEvent(thegroupSelectedTracks, thegroupSelectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); + doSameEvent(thegroupSelectedTracks, thegroupselectedV0s, parts, col.magField(), col.multNtr(), col.multV0M()); } - PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processSameEventMCMasked, "Enable processing same event for Monte Carlo", false); + PROCESS_SWITCH(FemtoDreamTripletTaskTrackTrackV0PbPb, processSameEventMCMasked, "Enable processing same event for Monte Carlo", false); /// This function processes the mixed event /// \tparam PartitionType @@ -545,55 +547,55 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { template void doMixedEvent(PartitionType groupPartsOne, PartitionType groupPartsTwo, PartitionType groupPartsThree, PartType parts, float magFieldTesla, int multCol) { - for (auto& [T1, T2, V0] : combinations(CombinationsFullIndexPolicy(groupPartsOne, groupPartsTwo, groupPartsThree))) { + for (const auto& [T1, T2, V0] : combinations(CombinationsFullIndexPolicy(groupPartsOne, groupPartsTwo, groupPartsThree))) { const auto& posChild = parts.iteratorAt(V0.globalIndex() - 2); const auto& negChild = parts.iteratorAt(V0.globalIndex() - 1); - if (!((posChild.cut() & Conf_ChildPos_CutV0) == Conf_ChildPos_CutV0 && - (posChild.pidcut() & Conf_ChildPos_TPCBitV0) == Conf_ChildPos_TPCBitV0 && - (negChild.cut() & Conf_ChildNeg_CutV0) == Conf_ChildNeg_CutV0 && - (negChild.pidcut() & Conf_ChildNeg_TPCBitV0) == Conf_ChildNeg_TPCBitV0)) { + if (!((posChild.cut() & confChildPosCutV0) == confChildPosCutV0 && + (posChild.pidcut() & confChildPosTPCBitV0) == confChildPosTPCBitV0 && + (negChild.cut() & confChildNegCutV0) == confChildNegCutV0 && + (negChild.pidcut() & confChildNegTPCBitV0) == confChildNegTPCBitV0)) { continue; } - auto Q3 = FemtoDreamMath::getQ3(T1, mMassOne, T2, mMassTwo, V0, mMassThree); + auto q3 = FemtoDreamMath::getQ3(T1, mMassOne, T2, mMassTwo, V0, mMassThree); // Close pair rejection - if (ConfIsCPR.value) { - if (pairCloseRejectionTrackTrackME.isClosePair(T1, T2, parts, magFieldTesla, Q3)) { + if (confIsCPR.value) { + if (pairCloseRejectionTrackTrackME.isClosePair(T1, T2, parts, magFieldTesla, q3)) { continue; } - if (pairCloseRejectionTrackV0ME.isClosePair(T1, V0, parts, magFieldTesla, Q3)) { + if (pairCloseRejectionTrackV0ME.isClosePair(T1, V0, parts, magFieldTesla, q3)) { continue; } - if (pairCloseRejectionTrackV0ME.isClosePair(T2, V0, parts, magFieldTesla, Q3)) { + if (pairCloseRejectionTrackV0ME.isClosePair(T2, V0, parts, magFieldTesla, q3)) { continue; } } // fill inv Mass as a function of Q3 for purity fits - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvME_Lambda"), Q3, V0.mLambda()); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvME_AntiLambda"), Q3, V0.mAntiLambda()); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/particle_pT_in_Triplet_ME"), T1.pt(), T2.pt(), V0.pt(), Q3); - mixedEventCont.setTriplet(T1, T2, V0, multCol, Q3); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvME_Lambda"), q3, V0.mLambda()); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hMinvME_AntiLambda"), q3, V0.mAntiLambda()); + threeBodyQARegistry.fill(HIST("TripletTaskQA/particle_pT_in_Triplet_ME"), T1.pt(), T2.pt(), V0.pt(), q3); + mixedEventCont.setTriplet(T1, T2, V0, multCol, q3); } } /// process function for to call doMixedEvent with Data /// @param cols subscribe to the collisions table (Data) /// @param parts subscribe to the femtoDreamParticleTable - void processMixedEvent(FilteredFDCollisions& cols, - o2::aod::FDParticles& parts) + void processMixedEvent(const FilteredFDCollisions& cols, + const o2::aod::FDParticles& parts) { - for (auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, ConfNEventsMix, -1, cols, cols, cols)) { + for (const auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, confNEventsMix, -1, cols, cols, cols)) { const int multiplicityCol = collision1.multNtr(); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision1.multV0M()); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision2.multV0M()); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision3.multV0M()); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision1.multV0M()); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision2.multV0M()); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision3.multV0M()); - auto groupPartsOne = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); - auto groupPartsTwo = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); - auto groupPartsThree = SelectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); + auto groupPartsOne = selectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); + auto groupPartsTwo = selectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); + auto groupPartsThree = selectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); const auto& magFieldTesla1 = collision1.magField(); const auto& magFieldTesla2 = collision2.magField(); @@ -605,29 +607,29 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { doMixedEvent(groupPartsOne, groupPartsTwo, groupPartsThree, parts, magFieldTesla1, multiplicityCol); } } - PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processMixedEvent, "Enable processing mixed events", true); + PROCESS_SWITCH(FemtoDreamTripletTaskTrackTrackV0PbPb, processMixedEvent, "Enable processing mixed events", true); /// process function for to call doMixedEvent with Data which has a mask for containing particles or not /// @param cols subscribe to the collisions table (Data) /// @param parts subscribe to the femtoDreamParticleTable - void processMixedEventMasked(MaskedCollisions& cols, o2::aod::FDParticles& parts) + void processMixedEventMasked(const MaskedCollisions& cols, const o2::aod::FDParticles& parts) { - if (ConfMixIfTripletPresent || ConfMixIfTVOPairPresent) { - Partition PartitionMaskedCol1 = (ConfMixIfTripletPresent && (aod::femtodreamcollision::bitmaskTrackTwo & MaskBit) == MaskBit && (aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit) || - (ConfMixIfTVOPairPresent && (aod::femtodreamcollision::bitmaskTrackOne & MaskBit) == MaskBit && (aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit); - PartitionMaskedCol1.bindTable(cols); + if (confMixIfTripletPresent || confMixIfTVOPairPresent) { + Partition partitionMaskedCol1 = (confMixIfTripletPresent && (aod::femtodreamcollision::bitmaskTrackTwo & maskBit) == maskBit && (aod::femtodreamcollision::bitmaskTrackThree & maskBit) == maskBit) || + (confMixIfTVOPairPresent && (aod::femtodreamcollision::bitmaskTrackOne & maskBit) == maskBit && (aod::femtodreamcollision::bitmaskTrackThree & maskBit) == maskBit); + partitionMaskedCol1.bindTable(cols); - for (auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, ConfNEventsMix, -1, *PartitionMaskedCol1.mFiltered, *PartitionMaskedCol1.mFiltered, *PartitionMaskedCol1.mFiltered)) { + for (const auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, confNEventsMix, -1, *partitionMaskedCol1.mFiltered, *partitionMaskedCol1.mFiltered, *partitionMaskedCol1.mFiltered)) { const int multiplicityCol = collision1.multNtr(); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision1.multV0M()); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision2.multV0M()); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision3.multV0M()); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision1.multV0M()); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision2.multV0M()); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hCentralityME"), collision3.multV0M()); - auto groupPartsOne = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); - auto groupPartsTwo = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); - auto groupPartsThree = SelectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); + auto groupPartsOne = selectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); + auto groupPartsTwo = selectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); + auto groupPartsThree = selectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); const auto& magFieldTesla1 = collision1.magField(); const auto& magFieldTesla2 = collision2.magField(); @@ -638,13 +640,13 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { } doMixedEvent(groupPartsOne, groupPartsTwo, groupPartsThree, parts, magFieldTesla1, multiplicityCol); } - } else if (ConfMixIfTOrVOPartsPresent) { - Partition PartitionMaskedColT = ((aod::femtodreamcollision::bitmaskTrackOne & MaskBit) == MaskBit); - Partition PartitionMaskedColV0 = ((aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit); - PartitionMaskedColT.bindTable(cols); - PartitionMaskedColV0.bindTable(cols); + } else if (confMixIfTOrVOPartsPresent) { + Partition partitionMaskedColT = ((aod::femtodreamcollision::bitmaskTrackOne & maskBit) == maskBit); + Partition partitionMaskedColV0 = ((aod::femtodreamcollision::bitmaskTrackThree & maskBit) == maskBit); + partitionMaskedColT.bindTable(cols); + partitionMaskedColV0.bindTable(cols); - for (auto& [ColWithTrack1, ColWithTrack2, ColWithV0] : soa::combinations(soa::CombinationsBlockFullIndexPolicy(colBinning, ConfNEventsMix, -1, *PartitionMaskedColT.mFiltered, *PartitionMaskedColT.mFiltered, *PartitionMaskedColV0.mFiltered))) { + for (const auto& [ColWithTrack1, ColWithTrack2, ColWithV0] : soa::combinations(soa::CombinationsBlockFullIndexPolicy(colBinning, confNEventsMix, -1, *partitionMaskedColT.mFiltered, *partitionMaskedColT.mFiltered, *partitionMaskedColV0.mFiltered))) { if (ColWithTrack1.globalIndex() == ColWithTrack2.globalIndex() || ColWithTrack1.globalIndex() == ColWithV0.globalIndex() || ColWithTrack2.globalIndex() == ColWithV0.globalIndex()) { continue; } @@ -652,11 +654,11 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { continue; } const int multiplicityCol = ColWithTrack1.multNtr(); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({ColWithTrack1.posZ(), multiplicityCol})); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({ColWithTrack1.posZ(), multiplicityCol})); - auto groupPartsOne = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack1.globalIndex(), cache); - auto groupPartsTwo = SelectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack2.globalIndex(), cache); - auto groupPartsThree = SelectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithV0.globalIndex(), cache); + auto groupPartsOne = selectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack1.globalIndex(), cache); + auto groupPartsTwo = selectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack2.globalIndex(), cache); + auto groupPartsThree = selectedV0s->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithV0.globalIndex(), cache); const auto& magFieldTesla1 = ColWithTrack1.magField(); const auto& magFieldTesla2 = ColWithTrack2.magField(); @@ -669,24 +671,24 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { } } } - PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processMixedEventMasked, "Enable processing mixed events", false); + PROCESS_SWITCH(FemtoDreamTripletTaskTrackTrackV0PbPb, processMixedEventMasked, "Enable processing mixed events", false); /// brief process function for to call doMixedEvent with Monte Carlo /// @param cols subscribe to the collisions table (Monte Carlo Reconstructed reconstructed) /// @param parts subscribe to joined table FemtoDreamParticles and FemtoDreamMCLables to access Monte Carlo truth /// @param FemtoDreamMCParticles subscribe to the Monte Carlo truth table - void processMixedEventMC(o2::aod::FDCollisions& cols, - soa::Join& parts, - o2::aod::FDMCParticles&) + void processMixedEventMC(const o2::aod::FDCollisions& cols, + const soa::Join& parts, + const o2::aod::FDMCParticles&) { - for (auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, ConfNEventsMix, -1, cols, cols, cols)) { + for (const auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, confNEventsMix, -1, cols, cols, cols)) { const int multiplicityCol = collision1.multNtr(); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); - auto groupPartsOne = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); - auto groupPartsTwo = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); - auto groupPartsThree = SelectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); + auto groupPartsOne = selectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); + auto groupPartsTwo = selectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); + auto groupPartsThree = selectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); const auto& magFieldTesla1 = collision1.magField(); const auto& magFieldTesla2 = collision2.magField(); @@ -700,28 +702,28 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { doMixedEvent(groupPartsOne, groupPartsTwo, groupPartsThree, parts, magFieldTesla1, multiplicityCol); } } - PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processMixedEventMC, "Enable processing mixed events MC", false); + PROCESS_SWITCH(FemtoDreamTripletTaskTrackTrackV0PbPb, processMixedEventMC, "Enable processing mixed events MC", false); /// brief process function for to call doMixedEvent with Monte Carlo which has a mask for containing particles or not /// @param cols subscribe to the collisions table (Monte Carlo Reconstructed reconstructed) /// @param parts subscribe to joined table FemtoDreamParticles and FemtoDreamMCLables to access Monte Carlo truth /// @param FemtoDreamMCParticles subscribe to the Monte Carlo truth table - void processMixedEventMCMasked(MaskedCollisions& cols, - soa::Join& parts, - o2::aod::FDMCParticles&) + void processMixedEventMCMasked(const MaskedCollisions& cols, + const soa::Join& parts, + const o2::aod::FDMCParticles&) { - if (ConfMixIfTripletPresent || ConfMixIfTVOPairPresent) { - Partition PartitionMaskedCol1 = (ConfMixIfTripletPresent && (aod::femtodreamcollision::bitmaskTrackTwo & MaskBit) == MaskBit && (aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit) || - (ConfMixIfTVOPairPresent && (aod::femtodreamcollision::bitmaskTrackOne & MaskBit) == MaskBit && (aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit); - PartitionMaskedCol1.bindTable(cols); + if (confMixIfTripletPresent || confMixIfTVOPairPresent) { + Partition partitionMaskedCol1 = (confMixIfTripletPresent && (aod::femtodreamcollision::bitmaskTrackTwo & maskBit) == maskBit && (aod::femtodreamcollision::bitmaskTrackThree & maskBit) == maskBit) || + (confMixIfTVOPairPresent && (aod::femtodreamcollision::bitmaskTrackOne & maskBit) == maskBit && (aod::femtodreamcollision::bitmaskTrackThree & maskBit) == maskBit); + partitionMaskedCol1.bindTable(cols); - for (auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, ConfNEventsMix, -1, *PartitionMaskedCol1.mFiltered, *PartitionMaskedCol1.mFiltered, *PartitionMaskedCol1.mFiltered)) { + for (const auto& [collision1, collision2, collision3] : soa::selfCombinations(colBinning, confNEventsMix, -1, *partitionMaskedCol1.mFiltered, *partitionMaskedCol1.mFiltered, *partitionMaskedCol1.mFiltered)) { const int multiplicityCol = collision1.multNtr(); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({collision1.posZ(), multiplicityCol})); - auto groupPartsOne = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); - auto groupPartsTwo = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); - auto groupPartsThree = SelectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); + auto groupPartsOne = selectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision1.globalIndex(), cache); + auto groupPartsTwo = selectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision2.globalIndex(), cache); + auto groupPartsThree = selectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, collision3.globalIndex(), cache); const auto& magFieldTesla1 = collision1.magField(); const auto& magFieldTesla2 = collision2.magField(); @@ -732,13 +734,13 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { } doMixedEvent(groupPartsOne, groupPartsTwo, groupPartsThree, parts, magFieldTesla1, multiplicityCol); } - } else if (ConfMixIfTOrVOPartsPresent) { - Partition PartitionMaskedColT = ((aod::femtodreamcollision::bitmaskTrackOne & MaskBit) == MaskBit); - Partition PartitionMaskedColV0 = ((aod::femtodreamcollision::bitmaskTrackThree & MaskBit) == MaskBit); - PartitionMaskedColT.bindTable(cols); - PartitionMaskedColV0.bindTable(cols); + } else if (confMixIfTOrVOPartsPresent) { + Partition partitionMaskedColT = ((aod::femtodreamcollision::bitmaskTrackOne & maskBit) == maskBit); + Partition partitionMaskedColV0 = ((aod::femtodreamcollision::bitmaskTrackThree & maskBit) == maskBit); + partitionMaskedColT.bindTable(cols); + partitionMaskedColV0.bindTable(cols); - for (auto& [ColWithTrack1, ColWithTrack2, ColWithV0] : soa::combinations(soa::CombinationsBlockFullIndexPolicy(colBinning, ConfNEventsMix, -1, *PartitionMaskedColT.mFiltered, *PartitionMaskedColT.mFiltered, *PartitionMaskedColV0.mFiltered))) { + for (const auto& [ColWithTrack1, ColWithTrack2, ColWithV0] : soa::combinations(soa::CombinationsBlockFullIndexPolicy(colBinning, confNEventsMix, -1, *partitionMaskedColT.mFiltered, *partitionMaskedColT.mFiltered, *partitionMaskedColV0.mFiltered))) { if (ColWithTrack1.globalIndex() == ColWithTrack2.globalIndex() || ColWithTrack1.globalIndex() == ColWithV0.globalIndex() || ColWithTrack2.globalIndex() == ColWithV0.globalIndex()) { continue; } @@ -746,11 +748,11 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { continue; } const int multiplicityCol = ColWithTrack1.multNtr(); - ThreeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({ColWithTrack1.posZ(), multiplicityCol})); + threeBodyQARegistry.fill(HIST("TripletTaskQA/hMECollisionBins"), colBinning.getBin({ColWithTrack1.posZ(), multiplicityCol})); - auto groupPartsOne = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack1.globalIndex(), cache); - auto groupPartsTwo = SelectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack2.globalIndex(), cache); - auto groupPartsThree = SelectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithV0.globalIndex(), cache); + auto groupPartsOne = selectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack1.globalIndex(), cache); + auto groupPartsTwo = selectedPartsMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithTrack2.globalIndex(), cache); + auto groupPartsThree = selectedV0sMC->sliceByCached(aod::femtodreamparticle::fdCollisionId, ColWithV0.globalIndex(), cache); const auto& magFieldTesla1 = ColWithTrack1.magField(); const auto& magFieldTesla2 = ColWithTrack2.magField(); @@ -763,13 +765,13 @@ struct femtoDreamTripletTaskTrackTrackV0PbPb { } } } - PROCESS_SWITCH(femtoDreamTripletTaskTrackTrackV0PbPb, processMixedEventMCMasked, "Enable processing mixed events MC", false); + PROCESS_SWITCH(FemtoDreamTripletTaskTrackTrackV0PbPb, processMixedEventMCMasked, "Enable processing mixed events MC", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { WorkflowSpec workflow{ - adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc), }; return workflow; } From 680bf8f2e6d93cc34967ec2588e8b60b61c41ccd Mon Sep 17 00:00:00 2001 From: Wioleta Rzesa Date: Thu, 4 Sep 2025 20:04:12 +0200 Subject: [PATCH 6/9] =?UTF-8?q?Fixing=20formating:=20A=20correlation=20tas?= =?UTF-8?q?k=20for=20triplets=20(track-track-v0)=20in=20Pb=E2=80=93Pb=20co?= =?UTF-8?q?llisions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx index 8d97594d332..84ec7dc9cd8 100644 --- a/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx +++ b/PWGCF/FemtoDream/Tasks/femtoDreamTripletTaskTrackTrackV0PbPb.cxx @@ -61,7 +61,7 @@ struct FemtoDreamTripletTaskTrackTrackV0PbPb { Configurable confMixIfTVOPairPresent{"confMixIfTVOPairPresent", false, "Use for mixing only events which have a TV0 pair (at least one track and one V0)"}; Configurable confMixIfTOrVOPartsPresent{"confMixIfTOrVOPartsPresent", false, "Use for mixing only events which have at least one particle of interest"}; Configurable confMinTrackNumber{"confMinTrackNumber", 2, "Minimum number of tracks in the event"}; - Configurable confMinV0Number{"confMinV0Number", 1, "Minimum number of V0 in the event"}; + Configurable confMinV0Number{"confMinV0Number", 1, "Minimum number of V0 in the event"}; // which CPR to use, old is with a possible bug and new is fixed Configurable confUseOLDPossiblyWrongCPR{"confUseOLDPossiblyWrongCPR", true, "Use for old CPR, which possibly has a bug. This is implemented only for debugging reasons to compare old and new code on hyperloop datasets."}; @@ -404,8 +404,7 @@ struct FemtoDreamTripletTaskTrackTrackV0PbPb { /// process function to call doSameEvent with Data /// \param col subscribe to the collision table (Data) /// \param parts subscribe to the femtoDreamParticleTable - void processSameEvent(const FilteredFDCollision& col, const - o2::aod::FDParticles& parts) + void processSameEvent(const FilteredFDCollision& col, const o2::aod::FDParticles& parts) { fillCollision(col); auto thegroupSelectedTracks = selectedParts->sliceByCached(aod::femtodreamparticle::fdCollisionId, col.globalIndex(), cache); From 72a496fe6b1aa3cbb428c5f5a218131eaa8c0bfc Mon Sep 17 00:00:00 2001 From: Wioleta Rzesa Date: Tue, 9 Sep 2025 11:00:45 +0200 Subject: [PATCH 7/9] =?UTF-8?q?Fixing=20formating:=20A=20correlation=20tas?= =?UTF-8?q?k=20for=20triplets=20(track-track-v0)=20in=20Pb=E2=80=93Pb=20co?= =?UTF-8?q?llisions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- PWGCF/FemtoDream/Tasks/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGCF/FemtoDream/Tasks/CMakeLists.txt b/PWGCF/FemtoDream/Tasks/CMakeLists.txt index df9bb3f9146..e4d87ff7b0f 100644 --- a/PWGCF/FemtoDream/Tasks/CMakeLists.txt +++ b/PWGCF/FemtoDream/Tasks/CMakeLists.txt @@ -44,7 +44,7 @@ o2physics_add_dpl_workflow(femtodream-triplet-track-track-v0 PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) -o2physics_add_dpl_workflow(femtodream-triplet-track-track-v0-pb-pb +o2physics_add_dpl_workflow(femto-dream-triplet-task-track-track-v0-pb-pb SOURCES femtoDreamTripletTaskTrackTrackV0PbPb.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) From 08c16f0419a758ce6604336718c6e1269fc617c2 Mon Sep 17 00:00:00 2001 From: Wioleta Rzesa Date: Tue, 9 Sep 2025 14:06:24 +0200 Subject: [PATCH 8/9] =?UTF-8?q?Fixing=20formating:=20A=20correlation=20tas?= =?UTF-8?q?k=20for=20triplets=20(track-track-v0)=20in=20Pb=E2=80=93Pb=20co?= =?UTF-8?q?llisions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- PWGCF/FemtoDream/Tasks/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGCF/FemtoDream/Tasks/CMakeLists.txt b/PWGCF/FemtoDream/Tasks/CMakeLists.txt index e4d87ff7b0f..a6a2aa2ed8e 100644 --- a/PWGCF/FemtoDream/Tasks/CMakeLists.txt +++ b/PWGCF/FemtoDream/Tasks/CMakeLists.txt @@ -19,7 +19,7 @@ o2physics_add_dpl_workflow(femtodream-triplet-track-track-track PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) -o2physics_add_dpl_workflow(femtodream-triplet-track-track-track-pb-pb +o2physics_add_dpl_workflow(femto-dream-triplet-task-track-track-track-pb-pb SOURCES femtoDreamTripletTaskTrackTrackTrackPbPb.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) From 07a2d30b5d16013687de51c9fc123291d8580fe9 Mon Sep 17 00:00:00 2001 From: Victor Gonzalez Date: Sat, 13 Sep 2025 17:41:21 +0200 Subject: [PATCH 9/9] Empty commit to relaunch the CI