From bb71592d6e72936478be37b8c9b20fa1a5f06822 Mon Sep 17 00:00:00 2001 From: Gauthier Legras Date: Fri, 8 May 2026 16:12:52 +0200 Subject: [PATCH 1/7] small fixes --- PWGDQ/Tasks/DalitzSelection.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGDQ/Tasks/DalitzSelection.cxx b/PWGDQ/Tasks/DalitzSelection.cxx index 70eb8415d27..229374a39ea 100644 --- a/PWGDQ/Tasks/DalitzSelection.cxx +++ b/PWGDQ/Tasks/DalitzSelection.cxx @@ -343,7 +343,7 @@ struct DalitzSelection { if (!twoTracksFilterMap) { continue; } - + // pairing VarManager::FillPair(track1, track2); From 2bb996df2a58291eeb93ae5561b0d4c469d0e4cd Mon Sep 17 00:00:00 2001 From: Gauthier Legras Date: Fri, 8 May 2026 16:14:20 +0200 Subject: [PATCH 2/7] clang format --- PWGDQ/Tasks/DalitzSelection.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGDQ/Tasks/DalitzSelection.cxx b/PWGDQ/Tasks/DalitzSelection.cxx index 229374a39ea..70eb8415d27 100644 --- a/PWGDQ/Tasks/DalitzSelection.cxx +++ b/PWGDQ/Tasks/DalitzSelection.cxx @@ -343,7 +343,7 @@ struct DalitzSelection { if (!twoTracksFilterMap) { continue; } - + // pairing VarManager::FillPair(track1, track2); From 34aa3c0cae973fdca960cba6bcbad63f77afe8ae Mon Sep 17 00:00:00 2001 From: Gauthier Legras Date: Fri, 15 May 2026 13:09:57 +0200 Subject: [PATCH 3/7] adding track-to-collision reassociation to dalitz selection --- PWGDQ/Tasks/DalitzSelection.cxx | 229 +++++++++++++++++++++++++++----- 1 file changed, 194 insertions(+), 35 deletions(-) diff --git a/PWGDQ/Tasks/DalitzSelection.cxx b/PWGDQ/Tasks/DalitzSelection.cxx index 70eb8415d27..af6d58772a7 100644 --- a/PWGDQ/Tasks/DalitzSelection.cxx +++ b/PWGDQ/Tasks/DalitzSelection.cxx @@ -24,10 +24,10 @@ #include "PWGDQ/Core/VarManager.h" #include "PWGDQ/DataModel/ReducedInfoTables.h" +#include "Common/DataModel/CollisionAssociationTables.h" #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/PIDResponseTOF.h" #include "Common/DataModel/PIDResponseTPC.h" -#include "Common/DataModel/TrackSelectionTables.h" #include #include @@ -60,20 +60,23 @@ using namespace o2::framework::expressions; using namespace o2::aod; using namespace o2::soa; -using MyEvents = soa::Join; +//using MyEvents = soa::Join +using MyEventsWithCent = soa::Join; -using MyBarrelTracks = soa::Join; -constexpr static uint32_t EventFillMap = VarManager::ObjTypes::Collision; -constexpr static uint32_t TrackFillMap = VarManager::ObjTypes::Track | VarManager::ObjTypes::TrackExtra | VarManager::ObjTypes::TrackDCA | VarManager::ObjTypes::TrackSelection | VarManager::ObjTypes::TrackPID; +//constexpr static uint32_t EventFillMap = VarManager::ObjTypes::Collision; +constexpr static uint32_t EventFillMapWithCent = VarManager::ObjTypes::Collision| VarManager::ObjTypes::CollisionCent; +constexpr static uint32_t TrackFillMap = VarManager::ObjTypes::Track | VarManager::ObjTypes::TrackExtra | VarManager::ObjTypes::TrackDCA | VarManager::ObjTypes::TrackPID; struct DalitzSelection { Produces dalitzbits; Preslice perCollision = aod::track::collisionId; + Preslice trackIndicesPerCollision = aod::track_association::collisionId; // Configurables // cuts @@ -102,6 +105,7 @@ struct DalitzSelection { struct : ConfigurableGroup { Configurable fConfigEnableLikeSign{"cfgEnableLikeSign", false, "Whether or not also add like-sign pairs (for studying combinatorial background which might contain misID or non-primary electrons)"}; Configurable fQA{"cfgQA", true, "QA histograms"}; + Configurable fRemoveDoubleCounting{"cfgRemoveDoubleCounting", true, "If a track/pair is selected for several collisions, we still count it only once"}; // Configurables for TPC post-calibration maps Configurable fConfigCcdbUrl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; Configurable fConfigCcdbPathTPC{"ccdb-path-tpc", "Users/i/iarsene/Calib/TPCpostCalib", "base path to the ccdb object"}; @@ -125,6 +129,11 @@ struct DalitzSelection { std::map fTrackmapProbe; // whether it is selected with probe cut std::map fDalitzmap; // whether it is selected as dalitz decay daughter with symmetric or tag cut std::map fDalitzmapProbe; // whether it is selected as dalitz decay daughter with probe cut + + // maps to remove ambiguities + std::map fDalitzmapAmbiguity; + std::map fDalitzmapProbeAmbiguity; + std::map, uint8_t> fAmbiguousPairs; AnalysisCompositeCut* fEventCut; std::vector fTrackCuts; @@ -295,13 +304,23 @@ struct DalitzSelection { fOutputList.setObject(fHistMan->GetMainHistogramList()); } - template - void runTrackSelection(TTracks const& tracksBarrel) + template + void runTrackSelection(TTracks const& tracksBarrel, TEvent const& collision) { - for (const auto& track : tracksBarrel) { + for (const auto& track1 : tracksBarrel) { uint8_t filterMap = uint8_t(0); uint8_t filterMapProbe = uint8_t(0); - VarManager::FillTrack(track); + int fullTrackIdx = 0; + if constexpr (isReassoc) { + auto const& fullTrack = track1.template track_as(); + VarManager::FillTrack(fullTrack); + VarManager::FillTrackCollision(fullTrack, collision); + fullTrackIdx = fullTrack.globalIndex(); + } + else { + VarManager::FillTrack(track1); + fullTrackIdx = track1.globalIndex(); + } int i = 0; for (auto cut = fTrackCuts.begin(); cut != fTrackCuts.end(); ++cut, ++i) { if ((*cut).IsSelected(VarManager::fgValues)) { @@ -317,35 +336,66 @@ struct DalitzSelection { } } if (filterMap) { - fTrackmap[track.globalIndex()] = filterMap; + fTrackmap[fullTrackIdx] = filterMap; } if (filterMapProbe) { - fTrackmapProbe[track.globalIndex()] = filterMapProbe; + fTrackmapProbe[fullTrackIdx] = filterMapProbe; } } // end loop over tracks } - template - void runDalitzPairing(TTracks const& tracks1, TTracks const& tracks2) + template + void runDalitzPairing(TTracks const& tracks1, TTracks const& tracks2, TEvent collision) { + if (isReassoc & fConfigOptions.fRemoveDoubleCounting) { + // keep track of selections from previous events to check if the track was already selected or not + fDalitzmapAmbiguity = fDalitzmap; + fDalitzmapProbeAmbiguity = fDalitzmapProbe; + } + for (const auto& [track1, track2] : o2::soa::combinations(CombinationsFullIndexPolicy(tracks1, tracks2))) { - if (track1.globalIndex() == track2.globalIndex()) { + + int trackIdx1; + int trackIdx2; + bool isLikeSign; + if constexpr (isReassoc) { + auto const& fullTrack1 = track1.template track_as(); + auto const& fullTrack2 = track2.template track_as(); + trackIdx1 = fullTrack1.globalIndex(); + trackIdx2 = fullTrack2.globalIndex(); + isLikeSign = (fullTrack1.sign() * fullTrack2.sign() > 0); + } + else { + trackIdx1 = track1.globalIndex(); + trackIdx2 = track2.globalIndex(); + isLikeSign = (track1.sign() * track2.sign() > 0); + } + + if (trackIdx1 == trackIdx2) { continue; } - if (!fIsTagAndProbe && track1.globalIndex() >= track2.globalIndex()) { + if (!fIsTagAndProbe && trackIdx1 >= trackIdx2) { continue; } - if (!fConfigOptions.fConfigEnableLikeSign && (track1.sign() * track2.sign() > 0)) { + if (!fConfigOptions.fConfigEnableLikeSign && isLikeSign) { continue; } - uint8_t twoTracksFilterMap = fTrackmap[track1.globalIndex()] & (fIsTagAndProbe ? fTrackmapProbe[track2.globalIndex()] : fTrackmap[track2.globalIndex()]); + uint8_t twoTracksFilterMap = fTrackmap[trackIdx1] & (fIsTagAndProbe ? fTrackmapProbe[trackIdx2] : fTrackmap[trackIdx2]); if (!twoTracksFilterMap) { continue; } // pairing - VarManager::FillPair(track1, track2); + if constexpr (isReassoc) { + auto const& fullTrack1 = track1.template track_as(); + auto const& fullTrack2 = track2.template track_as(); + VarManager::FillPair(fullTrack1, fullTrack2); + } + else { + VarManager::FillPair(track1, track2); + } + // Fill pair selection map and fill pair histogram int icut = 0; @@ -355,21 +405,35 @@ struct DalitzSelection { continue; } if ((*pairCut).IsSelected(VarManager::fgValues)) { - if (track1.sign() * track2.sign() < 0) { - fDalitzmap[track1.globalIndex()] |= (uint8_t(1) << icut); + bool isPairAlreadySelected = false; + if (isReassoc & fConfigOptions.fRemoveDoubleCounting) { + // if we remove double counting and the pair is already selected, we don't fill the histograms + std::pair iPair(trackIdx1, trackIdx2); + if (fAmbiguousPairs.find(iPair) != fAmbiguousPairs.end()) { + if (fAmbiguousPairs[iPair] & (static_cast(1) << icut)) { // if this pair is already stored with this cut + isPairAlreadySelected = true; + } else { + fAmbiguousPairs[iPair] |= static_cast(1) << icut; + } + } else { + fAmbiguousPairs[iPair] = static_cast(1) << icut; + } + } + if (!isLikeSign) { + fDalitzmap[trackIdx1] |= (uint8_t(1) << icut); if (fIsTagAndProbe) { - fDalitzmapProbe[track2.globalIndex()] |= (uint8_t(1) << icut); - if (fConfigOptions.fQA) { + fDalitzmapProbe[trackIdx2] |= (uint8_t(1) << icut); + if (fConfigOptions.fQA && !isPairAlreadySelected) { fHistMan->FillHistClass(Form("Pair_%s_%s_%s", (*trackCut).GetName(), fTrackCutsProbe.at(icut).GetName(), (*pairCut).GetName()), VarManager::fgValues); } } else { - fDalitzmap[track2.globalIndex()] |= (uint8_t(1) << icut); - if (fConfigOptions.fQA) { + fDalitzmap[trackIdx2] |= (uint8_t(1) << icut); + if (fConfigOptions.fQA && !isPairAlreadySelected) { fHistMan->FillHistClass(Form("Pair_%s_%s", (*trackCut).GetName(), (*pairCut).GetName()), VarManager::fgValues); } } } else { - if (fConfigOptions.fQA) { + if (fConfigOptions.fQA && !isPairAlreadySelected) { fHistMan->FillHistClass(fIsTagAndProbe ? Form("PairLS_%s_%s_%s", (*trackCut).GetName(), fTrackCutsProbe.at(icut).GetName(), (*pairCut).GetName()) : Form("PairLS_%s_%s", (*trackCut).GetName(), (*pairCut).GetName()), VarManager::fgValues); } } // end if like-sign @@ -380,12 +444,38 @@ struct DalitzSelection { // Fill Hists if (fConfigOptions.fQA) { for (const auto& track : tracks1) { - uint8_t filterMap = fDalitzmap[track.globalIndex()]; - uint8_t filterMapProbe = fDalitzmapProbe[track.globalIndex()]; - if (!filterMap && !filterMapProbe) { - continue; + uint8_t filterMap; + uint8_t filterMapProbe; + if constexpr (isReassoc) { + auto const& fullTrack = track.template track_as(); + filterMap = fDalitzmap[fullTrack.globalIndex()]; + filterMapProbe = fDalitzmapProbe[fullTrack.globalIndex()]; + if (fConfigOptions.fRemoveDoubleCounting) { + // we remove track selections which were already selected before + uint8_t previousFilterMap = fDalitzmapAmbiguity[fullTrack.globalIndex()]; + uint8_t previousFilterMapProbe = fDalitzmapProbeAmbiguity[fullTrack.globalIndex()]; + filterMap &= ~previousFilterMap; + filterMapProbe &= ~previousFilterMapProbe; + } + + if (!filterMap && !filterMapProbe) { + continue; + } + + VarManager::FillTrack(fullTrack); + // The caveat here is that we only fill the DCA to the first selected collision + VarManager::FillTrackCollision(fullTrack, collision); + } + else { + filterMap = fDalitzmap[track.globalIndex()]; + filterMapProbe = fDalitzmapProbe[track.globalIndex()]; + + if (!filterMap && !filterMapProbe) { + continue; + } + + VarManager::FillTrack(track); } - VarManager::FillTrack(track); int icut = 0; auto trackCut = fTrackCuts.begin(); @@ -403,7 +493,7 @@ struct DalitzSelection { } } - void processFullTracks(MyEvents const& collisions, aod::BCsWithTimestamps const&, soa::Filtered const& filteredTracks, MyBarrelTracks const& tracks) + void processFullTracks(MyEventsWithCent const& collisions, aod::BCsWithTimestamps const&, soa::Filtered const& filteredTracks, MyBarrelTracks const& tracks) { const int pairType = VarManager::kDecayToEE; fDalitzmap.clear(); @@ -413,7 +503,7 @@ struct DalitzSelection { fTrackmap.clear(); fTrackmapProbe.clear(); VarManager::ResetValues(VarManager::kNRunWiseVariables, VarManager::kNBarrelTrackVariables); - VarManager::FillEvent(collision); + VarManager::FillEvent(collision); bool isEventSelected = fEventCut->IsSelected(VarManager::fgValues); if (isEventSelected) { @@ -456,20 +546,89 @@ struct DalitzSelection { } auto groupedFilteredTracks = filteredTracks.sliceBy(perCollision, collision.globalIndex()); - runTrackSelection(groupedFilteredTracks); - runDalitzPairing(groupedFilteredTracks, groupedFilteredTracks); + runTrackSelection(groupedFilteredTracks, nullptr); + runDalitzPairing(groupedFilteredTracks, groupedFilteredTracks, nullptr); + } + } + + for (const auto& track : tracks) { // Fill dalitz bits + dalitzbits(fIsTagAndProbe ? fDalitzmapProbe[track.globalIndex()] : fDalitzmap[track.globalIndex()]); + } + } + + void processFullTracksWithAssoc(MyEventsWithCent const& collisions, aod::BCsWithTimestamps const&, MyBarrelTracks const& tracks, TrackAssoc const& trackAssocs) + { + + const int pairType = VarManager::kDecayToEE; + fDalitzmap.clear(); + fDalitzmapProbe.clear(); + fDalitzmapAmbiguity.clear(); + fDalitzmapProbeAmbiguity.clear(); + fAmbiguousPairs.clear(); + + for (const auto& collision : collisions) { + fTrackmap.clear(); + fTrackmapProbe.clear(); + VarManager::ResetValues(VarManager::kNRunWiseVariables, VarManager::kNBarrelTrackVariables); + VarManager::FillEvent(collision); + bool isEventSelected = fEventCut->IsSelected(VarManager::fgValues); + + if (isEventSelected) { + + reinterpret_cast(fStatsList->At(0))->Fill(0); + + auto bc = collision.template bc_as(); + + if (fCurrentRun != bc.runNumber()) { + VarManager::ResetValues(0, VarManager::kNRunWiseVariables); + + // We setup the magnetic field, because the conversion rejection cut might depend on it + float magField = 0.; + if (fConfigOptions.fUseRemoteField.value) { + grpmag = fCCDB->getForTimeStamp(fConfigOptions.grpmagPath, bc.timestamp()); + if (grpmag != nullptr) { + magField = grpmag->getNominalL3Field(); + } else { + LOGF(fatal, "GRP object is not available in CCDB at timestamp=%llu", bc.timestamp()); + } + } else { + magField = fConfigOptions.fConfigMagField.value; + } + LOGF(info, "setting mag field to %f", magField); + if (magField == 0.) { + LOGF(fatal, "magnetic field not set correctly, please check"); + } + VarManager::SetMagneticField(magField); + + if (fConfigOptions.fConfigComputeTPCpostCalib) { + auto calibList = fCCDB->getForTimeStamp(fConfigOptions.fConfigCcdbPathTPC.value, bc.timestamp()); + VarManager::SetCalibrationObject(VarManager::kTPCElectronMean, calibList->FindObject("mean_map_electron")); + VarManager::SetCalibrationObject(VarManager::kTPCElectronSigma, calibList->FindObject("sigma_map_electron")); + VarManager::SetCalibrationObject(VarManager::kTPCPionMean, calibList->FindObject("mean_map_pion")); + VarManager::SetCalibrationObject(VarManager::kTPCPionSigma, calibList->FindObject("sigma_map_pion")); + VarManager::SetCalibrationObject(VarManager::kTPCProtonMean, calibList->FindObject("mean_map_proton")); + VarManager::SetCalibrationObject(VarManager::kTPCProtonSigma, calibList->FindObject("sigma_map_proton")); + } + fCurrentRun = bc.runNumber(); + } + + auto groupedTracksAssoc = trackAssocs.sliceBy(trackIndicesPerCollision, collision.globalIndex()); + runTrackSelection(groupedTracksAssoc, collision); + runDalitzPairing(groupedTracksAssoc, groupedTracksAssoc, collision); } } for (const auto& track : tracks) { // Fill dalitz bits dalitzbits(fIsTagAndProbe ? fDalitzmapProbe[track.globalIndex()] : fDalitzmap[track.globalIndex()]); } + } - void processDummy(MyEvents const&) + void processDummy(MyEventsWithCent const&) { } + PROCESS_SWITCH(DalitzSelection, processFullTracksWithAssoc, "Run Dalitz selection on AO2D tables with reassociation", false); PROCESS_SWITCH(DalitzSelection, processFullTracks, "Run Dalitz selection on AO2D tables", false); PROCESS_SWITCH(DalitzSelection, processDummy, "Do nothing", false); }; From 1ba319a1ce49176c2761ac2c0a249886466a2f7a Mon Sep 17 00:00:00 2001 From: Gauthier Legras Date: Fri, 15 May 2026 13:13:17 +0200 Subject: [PATCH 4/7] clang format --- PWGDQ/Tasks/DalitzSelection.cxx | 38 ++++++++++++++------------------- 1 file changed, 16 insertions(+), 22 deletions(-) diff --git a/PWGDQ/Tasks/DalitzSelection.cxx b/PWGDQ/Tasks/DalitzSelection.cxx index af6d58772a7..b69b99c9336 100644 --- a/PWGDQ/Tasks/DalitzSelection.cxx +++ b/PWGDQ/Tasks/DalitzSelection.cxx @@ -60,7 +60,7 @@ using namespace o2::framework::expressions; using namespace o2::aod; using namespace o2::soa; -//using MyEvents = soa::Join +// using MyEvents = soa::Join using MyEventsWithCent = soa::Join; using MyBarrelTracks = soa::Join; -//constexpr static uint32_t EventFillMap = VarManager::ObjTypes::Collision; -constexpr static uint32_t EventFillMapWithCent = VarManager::ObjTypes::Collision| VarManager::ObjTypes::CollisionCent; +// constexpr static uint32_t EventFillMap = VarManager::ObjTypes::Collision; +constexpr static uint32_t EventFillMapWithCent = VarManager::ObjTypes::Collision | VarManager::ObjTypes::CollisionCent; constexpr static uint32_t TrackFillMap = VarManager::ObjTypes::Track | VarManager::ObjTypes::TrackExtra | VarManager::ObjTypes::TrackDCA | VarManager::ObjTypes::TrackPID; struct DalitzSelection { @@ -129,7 +129,7 @@ struct DalitzSelection { std::map fTrackmapProbe; // whether it is selected with probe cut std::map fDalitzmap; // whether it is selected as dalitz decay daughter with symmetric or tag cut std::map fDalitzmapProbe; // whether it is selected as dalitz decay daughter with probe cut - + // maps to remove ambiguities std::map fDalitzmapAmbiguity; std::map fDalitzmapProbeAmbiguity; @@ -316,8 +316,7 @@ struct DalitzSelection { VarManager::FillTrack(fullTrack); VarManager::FillTrackCollision(fullTrack, collision); fullTrackIdx = fullTrack.globalIndex(); - } - else { + } else { VarManager::FillTrack(track1); fullTrackIdx = track1.globalIndex(); } @@ -352,9 +351,9 @@ struct DalitzSelection { fDalitzmapAmbiguity = fDalitzmap; fDalitzmapProbeAmbiguity = fDalitzmapProbe; } - + for (const auto& [track1, track2] : o2::soa::combinations(CombinationsFullIndexPolicy(tracks1, tracks2))) { - + int trackIdx1; int trackIdx2; bool isLikeSign; @@ -364,13 +363,12 @@ struct DalitzSelection { trackIdx1 = fullTrack1.globalIndex(); trackIdx2 = fullTrack2.globalIndex(); isLikeSign = (fullTrack1.sign() * fullTrack2.sign() > 0); - } - else { + } else { trackIdx1 = track1.globalIndex(); trackIdx2 = track2.globalIndex(); isLikeSign = (track1.sign() * track2.sign() > 0); } - + if (trackIdx1 == trackIdx2) { continue; } @@ -391,12 +389,10 @@ struct DalitzSelection { auto const& fullTrack1 = track1.template track_as(); auto const& fullTrack2 = track2.template track_as(); VarManager::FillPair(fullTrack1, fullTrack2); - } - else { + } else { VarManager::FillPair(track1, track2); } - // Fill pair selection map and fill pair histogram int icut = 0; auto trackCut = fTrackCuts.begin(); @@ -457,23 +453,22 @@ struct DalitzSelection { filterMap &= ~previousFilterMap; filterMapProbe &= ~previousFilterMapProbe; } - + if (!filterMap && !filterMapProbe) { continue; } - + VarManager::FillTrack(fullTrack); // The caveat here is that we only fill the DCA to the first selected collision VarManager::FillTrackCollision(fullTrack, collision); - } - else { + } else { filterMap = fDalitzmap[track.globalIndex()]; filterMapProbe = fDalitzmapProbe[track.globalIndex()]; - + if (!filterMap && !filterMapProbe) { continue; } - + VarManager::FillTrack(track); } @@ -555,7 +550,7 @@ struct DalitzSelection { dalitzbits(fIsTagAndProbe ? fDalitzmapProbe[track.globalIndex()] : fDalitzmap[track.globalIndex()]); } } - + void processFullTracksWithAssoc(MyEventsWithCent const& collisions, aod::BCsWithTimestamps const&, MyBarrelTracks const& tracks, TrackAssoc const& trackAssocs) { @@ -621,7 +616,6 @@ struct DalitzSelection { for (const auto& track : tracks) { // Fill dalitz bits dalitzbits(fIsTagAndProbe ? fDalitzmapProbe[track.globalIndex()] : fDalitzmap[track.globalIndex()]); } - } void processDummy(MyEventsWithCent const&) From 2a0a1548465859f14e7c768256399eb950df2f53 Mon Sep 17 00:00:00 2001 From: Gauthier Legras Date: Fri, 15 May 2026 13:44:04 +0200 Subject: [PATCH 5/7] simplify a bit --- PWGDQ/Tasks/DalitzSelection.cxx | 94 +++++++++++++-------------------- 1 file changed, 36 insertions(+), 58 deletions(-) diff --git a/PWGDQ/Tasks/DalitzSelection.cxx b/PWGDQ/Tasks/DalitzSelection.cxx index b69b99c9336..19ed080320e 100644 --- a/PWGDQ/Tasks/DalitzSelection.cxx +++ b/PWGDQ/Tasks/DalitzSelection.cxx @@ -487,6 +487,40 @@ struct DalitzSelection { } } } + + void initNewRun(long timestamp) { + + VarManager::ResetValues(0, VarManager::kNRunWiseVariables); + + // We setup the magnetic field, because the conversion rejection cut might depend on it + float magField = 0.; + if (fConfigOptions.fUseRemoteField.value) { + grpmag = fCCDB->getForTimeStamp(fConfigOptions.grpmagPath, timestamp); + if (grpmag != nullptr) { + magField = grpmag->getNominalL3Field(); + } else { + LOGF(fatal, "GRP object is not available in CCDB at timestamp=%llu", timestamp); + } + } else { + magField = fConfigOptions.fConfigMagField.value; + } + LOGF(info, "setting mag field to %f", magField); + if (magField == 0.) { + LOGF(fatal, "magnetic field not set correctly, please check"); + } + VarManager::SetMagneticField(magField); + + if (fConfigOptions.fConfigComputeTPCpostCalib) { + auto calibList = fCCDB->getForTimeStamp(fConfigOptions.fConfigCcdbPathTPC.value, timestamp); + VarManager::SetCalibrationObject(VarManager::kTPCElectronMean, calibList->FindObject("mean_map_electron")); + VarManager::SetCalibrationObject(VarManager::kTPCElectronSigma, calibList->FindObject("sigma_map_electron")); + VarManager::SetCalibrationObject(VarManager::kTPCPionMean, calibList->FindObject("mean_map_pion")); + VarManager::SetCalibrationObject(VarManager::kTPCPionSigma, calibList->FindObject("sigma_map_pion")); + VarManager::SetCalibrationObject(VarManager::kTPCProtonMean, calibList->FindObject("mean_map_proton")); + VarManager::SetCalibrationObject(VarManager::kTPCProtonSigma, calibList->FindObject("sigma_map_proton")); + } + + } void processFullTracks(MyEventsWithCent const& collisions, aod::BCsWithTimestamps const&, soa::Filtered const& filteredTracks, MyBarrelTracks const& tracks) { @@ -508,35 +542,7 @@ struct DalitzSelection { auto bc = collision.template bc_as(); if (fCurrentRun != bc.runNumber()) { - VarManager::ResetValues(0, VarManager::kNRunWiseVariables); - - // We setup the magnetic field, because the conversion rejection cut might depend on it - float magField = 0.; - if (fConfigOptions.fUseRemoteField.value) { - grpmag = fCCDB->getForTimeStamp(fConfigOptions.grpmagPath, bc.timestamp()); - if (grpmag != nullptr) { - magField = grpmag->getNominalL3Field(); - } else { - LOGF(fatal, "GRP object is not available in CCDB at timestamp=%llu", bc.timestamp()); - } - } else { - magField = fConfigOptions.fConfigMagField.value; - } - LOGF(info, "setting mag field to %f", magField); - if (magField == 0.) { - LOGF(fatal, "magnetic field not set correctly, please check"); - } - VarManager::SetMagneticField(magField); - - if (fConfigOptions.fConfigComputeTPCpostCalib) { - auto calibList = fCCDB->getForTimeStamp(fConfigOptions.fConfigCcdbPathTPC.value, bc.timestamp()); - VarManager::SetCalibrationObject(VarManager::kTPCElectronMean, calibList->FindObject("mean_map_electron")); - VarManager::SetCalibrationObject(VarManager::kTPCElectronSigma, calibList->FindObject("sigma_map_electron")); - VarManager::SetCalibrationObject(VarManager::kTPCPionMean, calibList->FindObject("mean_map_pion")); - VarManager::SetCalibrationObject(VarManager::kTPCPionSigma, calibList->FindObject("sigma_map_pion")); - VarManager::SetCalibrationObject(VarManager::kTPCProtonMean, calibList->FindObject("mean_map_proton")); - VarManager::SetCalibrationObject(VarManager::kTPCProtonSigma, calibList->FindObject("sigma_map_proton")); - } + initNewRun(bc.timestamp()); fCurrentRun = bc.runNumber(); } @@ -575,35 +581,7 @@ struct DalitzSelection { auto bc = collision.template bc_as(); if (fCurrentRun != bc.runNumber()) { - VarManager::ResetValues(0, VarManager::kNRunWiseVariables); - - // We setup the magnetic field, because the conversion rejection cut might depend on it - float magField = 0.; - if (fConfigOptions.fUseRemoteField.value) { - grpmag = fCCDB->getForTimeStamp(fConfigOptions.grpmagPath, bc.timestamp()); - if (grpmag != nullptr) { - magField = grpmag->getNominalL3Field(); - } else { - LOGF(fatal, "GRP object is not available in CCDB at timestamp=%llu", bc.timestamp()); - } - } else { - magField = fConfigOptions.fConfigMagField.value; - } - LOGF(info, "setting mag field to %f", magField); - if (magField == 0.) { - LOGF(fatal, "magnetic field not set correctly, please check"); - } - VarManager::SetMagneticField(magField); - - if (fConfigOptions.fConfigComputeTPCpostCalib) { - auto calibList = fCCDB->getForTimeStamp(fConfigOptions.fConfigCcdbPathTPC.value, bc.timestamp()); - VarManager::SetCalibrationObject(VarManager::kTPCElectronMean, calibList->FindObject("mean_map_electron")); - VarManager::SetCalibrationObject(VarManager::kTPCElectronSigma, calibList->FindObject("sigma_map_electron")); - VarManager::SetCalibrationObject(VarManager::kTPCPionMean, calibList->FindObject("mean_map_pion")); - VarManager::SetCalibrationObject(VarManager::kTPCPionSigma, calibList->FindObject("sigma_map_pion")); - VarManager::SetCalibrationObject(VarManager::kTPCProtonMean, calibList->FindObject("mean_map_proton")); - VarManager::SetCalibrationObject(VarManager::kTPCProtonSigma, calibList->FindObject("sigma_map_proton")); - } + initNewRun(bc.timestamp()); fCurrentRun = bc.runNumber(); } From 6acc01edc6d20c0e6d12105470169cd2f98fc4ed Mon Sep 17 00:00:00 2001 From: Gauthier Legras Date: Fri, 15 May 2026 13:46:04 +0200 Subject: [PATCH 6/7] clang format --- PWGDQ/Tasks/DalitzSelection.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGDQ/Tasks/DalitzSelection.cxx b/PWGDQ/Tasks/DalitzSelection.cxx index 19ed080320e..78879992a1f 100644 --- a/PWGDQ/Tasks/DalitzSelection.cxx +++ b/PWGDQ/Tasks/DalitzSelection.cxx @@ -487,9 +487,10 @@ struct DalitzSelection { } } } - - void initNewRun(long timestamp) { - + + void initNewRun(long timestamp) + { + VarManager::ResetValues(0, VarManager::kNRunWiseVariables); // We setup the magnetic field, because the conversion rejection cut might depend on it @@ -519,7 +520,6 @@ struct DalitzSelection { VarManager::SetCalibrationObject(VarManager::kTPCProtonMean, calibList->FindObject("mean_map_proton")); VarManager::SetCalibrationObject(VarManager::kTPCProtonSigma, calibList->FindObject("sigma_map_proton")); } - } void processFullTracks(MyEventsWithCent const& collisions, aod::BCsWithTimestamps const&, soa::Filtered const& filteredTracks, MyBarrelTracks const& tracks) From ee96cb30d42733e888e8518988dd41e9c6505ec5 Mon Sep 17 00:00:00 2001 From: Gauthier Legras Date: Fri, 15 May 2026 14:06:26 +0200 Subject: [PATCH 7/7] megalinter --- PWGDQ/Tasks/DalitzSelection.cxx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/PWGDQ/Tasks/DalitzSelection.cxx b/PWGDQ/Tasks/DalitzSelection.cxx index 78879992a1f..317015a044f 100644 --- a/PWGDQ/Tasks/DalitzSelection.cxx +++ b/PWGDQ/Tasks/DalitzSelection.cxx @@ -52,6 +52,7 @@ #include #include #include +#include #include using namespace o2; @@ -488,7 +489,7 @@ struct DalitzSelection { } } - void initNewRun(long timestamp) + void initNewRun(int64_t timestamp) { VarManager::ResetValues(0, VarManager::kNRunWiseVariables);