From 0a863d3962f58a671c4a748d3567aec788184b6d Mon Sep 17 00:00:00 2001 From: Nicolas Strangmann Date: Tue, 23 Sep 2025 17:06:43 +0200 Subject: [PATCH 1/3] [PWGEM/PhotonMeson] Add FT0 QC and FT0C centrality estimator to BC wise GG --- PWGEM/PhotonMeson/DataModel/bcWiseTables.h | 43 +++++----- .../TableProducer/bcWiseClusterSkimmer.cxx | 62 ++++++++++---- .../Tasks/emcalBcWiseGammaGamma.cxx | 85 +++++++++++-------- 3 files changed, 115 insertions(+), 75 deletions(-) diff --git a/PWGEM/PhotonMeson/DataModel/bcWiseTables.h b/PWGEM/PhotonMeson/DataModel/bcWiseTables.h index a306d5645ce..efd3f9a2007 100644 --- a/PWGEM/PhotonMeson/DataModel/bcWiseTables.h +++ b/PWGEM/PhotonMeson/DataModel/bcWiseTables.h @@ -36,7 +36,7 @@ enum Observable { kNCells, kM02, kTime, - kFT0MCent, + kCent, kZVtx, kFT0Amp, kpT, @@ -54,7 +54,7 @@ const float downscalingFactors[nObservables]{ 1E0, // Number of cells 1E4, // M02 1E2, // Cluster time - 2E0, // FT0M centrality + 2E0, // FT0 centrality 1E3, // Z-vertex position 1E-1, // FT0M amplitude 1E3, // MC pi0 pt @@ -64,37 +64,36 @@ const float downscalingFactors[nObservables]{ namespace bcwisebc { -DECLARE_SOA_COLUMN(HasFT0, hasFT0, bool); //! has_foundFT0() -DECLARE_SOA_COLUMN(HasTVX, hasTVX, bool); //! has the TVX trigger flag -DECLARE_SOA_COLUMN(HaskTVXinEMC, haskTVXinEMC, bool); //! kTVXinEMC -DECLARE_SOA_COLUMN(HasEMCCell, hasEMCCell, bool); //! at least one EMCal cell in the BC -DECLARE_SOA_COLUMN(StoredCentrality, storedCentrality, uint8_t); //! FT0M centrality (0-100) (x2) -DECLARE_SOA_COLUMN(StoredFT0MAmplitude, storedFT0MAmplitude, uint16_t); //! ft0a+c amplitude -DECLARE_SOA_COLUMN(StoredMu, storedMu, uint16_t); //! probability of TVX collision per BC (x1000) -DECLARE_SOA_COLUMN(StoredTimeSinceSOF, storedTimeSinceSOF, uint16_t); //! time since decreation of ADJUST in seconds (x2) - -DECLARE_SOA_DYNAMIC_COLUMN(Centrality, centrality, [](uint8_t storedcentrality) -> float { return std::nextafter(storedcentrality / emdownscaling::downscalingFactors[emdownscaling::kFT0MCent], std::numeric_limits::infinity()); }); //! Centrality (0-100) -DECLARE_SOA_DYNAMIC_COLUMN(FT0MAmplitude, ft0Amplitude, [](uint16_t storedFT0MAmplitude) -> float { return std::nextafter(storedFT0MAmplitude / emdownscaling::downscalingFactors[emdownscaling::kFT0Amp], std::numeric_limits::infinity()); }); //! FT0M amplitude -DECLARE_SOA_DYNAMIC_COLUMN(Mu, mu, [](uint16_t storedMu) -> float { return std::nextafter(storedMu / emdownscaling::downscalingFactors[emdownscaling::kMu], std::numeric_limits::infinity()); }); //! probability of TVX collision per BC +DECLARE_SOA_COLUMN(HasFT0, hasFT0, bool); //! has_foundFT0() +DECLARE_SOA_COLUMN(HasTVX, hasTVX, bool); //! has the TVX trigger flag +DECLARE_SOA_COLUMN(HaskTVXinEMC, haskTVXinEMC, bool); //! kTVXinEMC +DECLARE_SOA_COLUMN(HasEMCCell, hasEMCCell, bool); //! at least one EMCal cell in the BC +DECLARE_SOA_COLUMN(StoredFT0CCentrality, storedFt0CCentrality, uint8_t); //! FT0C centrality (0-100) (x2) +DECLARE_SOA_COLUMN(StoredFT0MCentrality, storedFT0MCentrality, uint8_t); //! FT0M centrality (0-100) (x2) +DECLARE_SOA_COLUMN(StoredFT0MAmplitude, storedFT0MAmplitude, uint16_t); //! ft0a+c amplitude +DECLARE_SOA_COLUMN(StoredMu, storedMu, uint16_t); //! probability of TVX collision per BC (x1000) +DECLARE_SOA_COLUMN(StoredTimeSinceSOF, storedTimeSinceSOF, uint16_t); //! time since decreation of ADJUST in seconds (x2) + +DECLARE_SOA_DYNAMIC_COLUMN(FT0CCentrality, ft0cCentrality, [](uint8_t storedft0ccentrality) -> float { return std::nextafter(storedft0ccentrality / emdownscaling::downscalingFactors[emdownscaling::kCent], std::numeric_limits::infinity()); }); //! Centrality (0-100) +DECLARE_SOA_DYNAMIC_COLUMN(FT0MCentrality, ft0mCentrality, [](uint8_t storedft0mcentrality) -> float { return std::nextafter(storedft0mcentrality / emdownscaling::downscalingFactors[emdownscaling::kCent], std::numeric_limits::infinity()); }); //! Centrality (0-100) +DECLARE_SOA_DYNAMIC_COLUMN(FT0MAmplitude, ft0Amplitude, [](uint16_t storedFT0MAmplitude) -> float { return std::nextafter(storedFT0MAmplitude / emdownscaling::downscalingFactors[emdownscaling::kFT0Amp], std::numeric_limits::infinity()); }); //! FT0M amplitude +DECLARE_SOA_DYNAMIC_COLUMN(Mu, mu, [](uint16_t storedMu) -> float { return std::nextafter(storedMu / emdownscaling::downscalingFactors[emdownscaling::kMu], std::numeric_limits::infinity()); }); //! probability of TVX collision per BC DECLARE_SOA_DYNAMIC_COLUMN(TimeSinceSOF, timeSinceSOF, [](uint16_t storedTimeSinceSOF) -> float { return std::nextafter(storedTimeSinceSOF / emdownscaling::downscalingFactors[emdownscaling::kTimeSinceSOF], std::numeric_limits::infinity()); }); //! probability of TVX collision per BC } // namespace bcwisebc DECLARE_SOA_TABLE(BCWiseBCs, "AOD", "BCWISEBC", //! table of bc wise centrality estimation and event selection input - o2::soa::Index<>, bcwisebc::HasFT0, bcwisebc::HasTVX, bcwisebc::HaskTVXinEMC, bcwisebc::HasEMCCell, bcwisebc::StoredCentrality, - bcwisebc::StoredFT0MAmplitude, bcwisebc::StoredMu, bcwisebc::StoredTimeSinceSOF, bcwisebc::Centrality, bcwisebc::FT0MAmplitude, bcwisebc::Mu, bcwisebc::TimeSinceSOF); + o2::soa::Index<>, bcwisebc::HasFT0, bcwisebc::HasTVX, bcwisebc::HaskTVXinEMC, bcwisebc::HasEMCCell, bcwisebc::StoredFT0CCentrality, bcwisebc::StoredFT0MCentrality, + bcwisebc::StoredFT0MAmplitude, bcwisebc::StoredMu, bcwisebc::StoredTimeSinceSOF, bcwisebc::FT0CCentrality, bcwisebc::FT0MCentrality, bcwisebc::FT0MAmplitude, bcwisebc::Mu, bcwisebc::TimeSinceSOF); DECLARE_SOA_INDEX_COLUMN(BCWiseBC, bcWiseBC); //! bunch crossing ID used as index namespace bcwisecollision { -DECLARE_SOA_COLUMN(StoredCentrality, storedCentrality, uint8_t); //! FT0M centrality (0-100) (x2) -DECLARE_SOA_COLUMN(StoredZVtx, storedZVtx, int16_t); //! Z-vertex position (x1000) +DECLARE_SOA_COLUMN(StoredZVtx, storedZVtx, int16_t); //! Z-vertex position (x1000) -DECLARE_SOA_DYNAMIC_COLUMN(Centrality, centrality, [](uint8_t storedcentrality) -> float { return std::nextafter(storedcentrality / emdownscaling::downscalingFactors[emdownscaling::kFT0MCent], std::numeric_limits::infinity()); }); //! Centrality (0-100) -DECLARE_SOA_DYNAMIC_COLUMN(ZVtx, zVtx, [](int16_t storedzvtx) -> float { return storedzvtx / emdownscaling::downscalingFactors[emdownscaling::kZVtx]; }); //! Centrality (0-100) +DECLARE_SOA_DYNAMIC_COLUMN(ZVtx, zVtx, [](int16_t storedzvtx) -> float { return storedzvtx / emdownscaling::downscalingFactors[emdownscaling::kZVtx]; }); //! Z-Vertex } // namespace bcwisecollision DECLARE_SOA_TABLE(BCWiseCollisions, "AOD", "BCWISECOLL", //! table of skimmed EMCal clusters - o2::soa::Index<>, BCWiseBCId, bcwisecollision::StoredCentrality, bcwisecollision::StoredZVtx, - bcwisecollision::Centrality, bcwisecollision::ZVtx); + o2::soa::Index<>, BCWiseBCId, bcwisecollision::StoredZVtx, bcwisecollision::ZVtx); namespace bcwisecluster { diff --git a/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx b/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx index ab6bba76b3e..7f670c51e5e 100644 --- a/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx +++ b/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx @@ -41,9 +41,9 @@ using namespace o2::aod::emdownscaling; using namespace o2::framework; using namespace o2::framework::expressions; -using MyCollisions = soa::Join; -using MyMCCollisions = soa::Join; -using MyBCs = soa::Join; +using MyCollisions = soa::Join; +using MyMCCollisions = soa::Join; +using MyBCs = soa::Join; using SelectedUniqueClusters = soa::Filtered; // Clusters from collisions with only one collision in the BC using SelectedUniqueMCClusters = soa::Filtered>; // Clusters from collisions with only one collision in the BC @@ -98,12 +98,20 @@ struct bcWiseClusterSkimmer { { const int nEventBins = 6; mHistManager.add("nBCs", "Number of BCs;;#bf{#it{N}_{BCs}}", HistType::kTH1F, {{nEventBins, -0.5, 5.5}}); - const TString binLabels[nEventBins] = {"All", "FT0", "TVX", "kTVXinEMC", "Cell", "NoBorder"}; + const TString binLabels[nEventBins] = {"All", "FT0", "TVX", "kTVXinEMC", "Cell", "HasMCColl"}; for (int iBin = 0; iBin < nEventBins; iBin++) mHistManager.get(HIST("nBCs"))->GetXaxis()->SetBinLabel(iBin + 1, binLabels[iBin]); mHistManager.add("CentralityVsGenMultiplicity", "Centrality vs number of generated MC particles;Centrality;#bf{#it{N}_{gen}}", HistType::kTH2F, {{102, 0., 102}, cfgMultiplicityBinning}); + mHistManager.add("CentralityFT0CVsM", "Centrality of FT0C vs FT0M;FT0C Cent;FT0M Cent", HistType::kTH2F, {{102, 0., 102}, {102, 0., 102}}); mHistManager.add("BCCentVsCollCent", "Centrality of the BC vs Centrality of the collision;BC Centrality;Collision Centrality", HistType::kTH2F, {{102, 0., 102}, {102, 0., 102}}); + mHistManager.add("BCHasFT0FoundFT0", "BCHasFT0FoundFT0;BC has FT0;BC has found FT0", HistType::kTH2F, {{1000, -2., 50000}, {1000, -2., 50000}}); + mHistManager.add("BCFoundFT0Diff", "BCFoundFT0Diff;BC_{ID}^{found FT0} - BC_{ID}^{FT0}", HistType::kTH1F, {{200001, -100000.5, 100000.5}}); + mHistManager.add("BCIDOfMCColl", "BCIDOfMCColl;BCID", HistType::kTH1F, {{4001, -0.5, 4000.5}}); + mHistManager.add("BCIDOfMCCollButNoFT0", "BCIDOfMCCollButNoFT0;BCID", HistType::kTH1F, {{4001, -0.5, 4000.5}}); + + mHistManager.add("MCZVtx", "Vertex position of MC collision;#bf{z_{vtx}^{MC} (cm)};#bf{#it{N}_{BCs}}", HistType::kTH1F, {{2000, -100, 100}}); + mHistManager.add("MCZVtx_TVX", "Vertex position of MC collision;#bf{z_{vtx}^{MC} (cm)};#bf{#it{N}_{BCs}}", HistType::kTH1F, {{2000, -100, 100}}); LOG(info) << "BC wise cluster skimmer cuts:"; LOG(info) << "------------------------------------"; @@ -233,14 +241,29 @@ struct bcWiseClusterSkimmer { return mu; } - void processEventProperties(const auto& bc, const auto& collisionsInBC, const auto& cellsInBC) + void processEventProperties(const auto& bc, const auto& collisionsInBC, const auto& cellsInBC, const bool hasMCCollision = false) { - bool hasFT0 = bc.has_foundFT0(); + bool hasFT0 = bc.has_ft0(); + bool hasFoundFT0 = bc.has_foundFT0(); + int foundFT0ID = hasFoundFT0 ? bc.foundFT0().bcId() : -1; + int FT0ID = hasFT0 ? bc.ft0().bcId() : -1; + mHistManager.fill(HIST("BCHasFT0FoundFT0"), (float)FT0ID, (float)foundFT0ID); + mHistManager.fill(HIST("BCFoundFT0Diff"), (float)foundFT0ID - (float)FT0ID); + + auto bcIDInOrbit = bc.globalBC() % 3564; + + if (hasMCCollision) { + mHistManager.fill(HIST("BCIDOfMCColl"), (float)bcIDInOrbit); + if (!hasFoundFT0) { + mHistManager.fill(HIST("BCIDOfMCCollButNoFT0"), (float)bcIDInOrbit); + } + } + bool hasTVX = bc.selection_bit(aod::evsel::kIsTriggerTVX); bool haskTVXinEMC = bc.alias_bit(kTVXinEMC); bool hasEMCCell = cellsInBC.size() > 0; mHistManager.fill(HIST("nBCs"), 0); - if (hasFT0) + if (hasFoundFT0) mHistManager.fill(HIST("nBCs"), 1); if (hasTVX) mHistManager.fill(HIST("nBCs"), 2); @@ -248,23 +271,26 @@ struct bcWiseClusterSkimmer { mHistManager.fill(HIST("nBCs"), 3); if (hasEMCCell) mHistManager.fill(HIST("nBCs"), 4); + if (hasMCCollision) + mHistManager.fill(HIST("nBCs"), 5); if (cfgStoreMu || cfgStoreTime) setLHCIFData(bc); double mu = cfgStoreMu ? calculateMu(bc) : 0.; float timeSinceSOF = cfgStoreTime ? (bc.timestamp() - mLHCIFdata->getFillNumberTime()) / 1e3 : 0.; // Convert to seconds - float ft0Amp = hasFT0 ? bc.foundFT0().sumAmpA() + bc.foundFT0().sumAmpC() : 0.; + float ft0Amp = hasFoundFT0 ? bc.foundFT0().sumAmpA() + bc.foundFT0().sumAmpC() : 0.; double centralityOfCollision = 101.5; if (collisionsInBC.size() > 0) - centralityOfCollision = collisionsInBC.iteratorAt(0).centFT0M(); - double centralityOfBC = bc.centFT0M(); + centralityOfCollision = collisionsInBC.iteratorAt(0).centFT0C(); + double centralityOfBC = bc.centFT0C(); mHistManager.fill(HIST("BCCentVsCollCent"), centralityOfBC, centralityOfCollision); + mHistManager.fill(HIST("CentralityFT0CVsM"), centralityOfBC, bc.centFT0M()); - bcTable(hasFT0, hasTVX, haskTVXinEMC, hasEMCCell, convertForStorage(centralityOfBC, kFT0MCent), convertForStorage(ft0Amp, kFT0Amp), convertForStorage(mu, kMu), convertForStorage(timeSinceSOF, kTimeSinceSOF)); + bcTable(hasFoundFT0, hasTVX, haskTVXinEMC, hasEMCCell, convertForStorage(centralityOfBC, kCent), convertForStorage(bc.centFT0M(), kCent), convertForStorage(ft0Amp, kFT0Amp), convertForStorage(mu, kMu), convertForStorage(timeSinceSOF, kTimeSinceSOF)); for (const auto& collision : collisionsInBC) - collisionTable(bcTable.lastIndex(), convertForStorage(collision.centFT0M(), kFT0MCent), convertForStorage(collision.posZ(), kZVtx)); + collisionTable(bcTable.lastIndex(), convertForStorage(collision.posZ(), kZVtx)); } template @@ -333,10 +359,14 @@ struct bcWiseClusterSkimmer { auto collisionsInBC = collisions.sliceBy(perFoundBC, bc.globalIndex()); auto cellsInBC = cells.sliceBy(cellsPerBC, bc.globalIndex()); - processEventProperties(bc, collisionsInBC, cellsInBC); - auto mcCollisionsBC = mcCollisions.sliceBy(mcCollperBC, bc.globalIndex()); + + processEventProperties(bc, collisionsInBC, cellsInBC, mcCollisionsBC.size() > 0); + for (const auto& mcCollision : mcCollisionsBC) { + mHistManager.fill(HIST("MCZVtx"), mcCollision.posZ()); + if (bc.selection_bit(aod::evsel::kIsTriggerTVX)) + mHistManager.fill(HIST("MCZVtx_TVX"), mcCollision.posZ()); auto mcParticlesInColl = mcParticles.sliceBy(perMcCollision, mcCollision.globalIndex()); mHistManager.fill(HIST("CentralityVsGenMultiplicity"), bc.centFT0M(), mcParticlesInColl.size()); for (const auto& mcParticle : mcParticlesInColl) { @@ -358,11 +388,11 @@ struct bcWiseClusterSkimmer { if (collisionsInBC.size() == 1) { auto clustersInBC = uClusters.sliceBy(perCol, collisionsInBC.begin().globalIndex()); processClusters(clustersInBC, bcTable.lastIndex()); - processClusterMCInfo(clustersInBC, bc.globalIndex(), mcParticles); + processClusterMCInfo(clustersInBC, bcTable.lastIndex(), mcParticles); } else { auto clustersInBC = aClusters.sliceBy(perBC, bc.globalIndex()); processClusters(clustersInBC, bcTable.lastIndex()); - processClusterMCInfo(clustersInBC, bc.globalIndex(), mcParticles); + processClusterMCInfo(clustersInBC, bcTable.lastIndex(), mcParticles); } fMapPi0Index.clear(); fMapEtaIndex.clear(); diff --git a/PWGEM/PhotonMeson/Tasks/emcalBcWiseGammaGamma.cxx b/PWGEM/PhotonMeson/Tasks/emcalBcWiseGammaGamma.cxx index 0aacd233324..efbc38d799c 100644 --- a/PWGEM/PhotonMeson/Tasks/emcalBcWiseGammaGamma.cxx +++ b/PWGEM/PhotonMeson/Tasks/emcalBcWiseGammaGamma.cxx @@ -45,6 +45,7 @@ struct EmcalBcWiseGammaGamma { Configurable cfgRequirekTVXinEMC{"cfgRequirekTVXinEMC", true, "Reconstruct mesons only in kTVXinEMC triggered BCs"}; Configurable cfgRequireEMCCell{"cfgRequireEMCCell", true, "Reconstruct mesons only in BCs containing at least one EMCal cell (workaround for kTVXinEMC trigger)"}; Configurable cfgSelectOnlyUniqueAmbiguous{"cfgSelectOnlyUniqueAmbiguous", 0, "0: all clusters, 1: only unique clusters, 2: only ambiguous clusters"}; + Configurable cfgCentralityEstimator{"cfgCentralityEstimator", 0, "0: FT0C, 1: FT0M"}; Configurable cfgClusterDefinition{"cfgClusterDefinition", 13, "Clusterizer to be selected, e.g. 13 for kV3MostSplitLowSeed"}; Configurable cfgMinClusterEnergy{"cfgMinClusterEnergy", 700, "Minimum energy of selected clusters (MeV)"}; @@ -125,6 +126,16 @@ struct EmcalBcWiseGammaGamma { } } + float getCentrality(const auto& bc) + { + if (cfgCentralityEstimator == 0) + return bc.ft0cCentrality(); + else if (cfgCentralityEstimator == 1) + return bc.ft0mCentrality(); + else + throw std::runtime_error("Unknown centrality estimator selected"); + } + /// \brief returns if cluster is too close to edge of EMCal bool isTooCloseToEdge(const int cellID, const int DistanceToBorder = 1) { @@ -143,37 +154,37 @@ struct EmcalBcWiseGammaGamma { void fillEventHists(const auto& bc, const auto& collisions, const auto& clusters) { - mHistManager.fill(HIST("Event/nBCs"), 0, bc.centrality()); + mHistManager.fill(HIST("Event/nBCs"), 0, getCentrality(bc)); float mu = bc.mu(); mHistManager.fill(HIST("Event/Mu"), mu); mHistManager.fill(HIST("Event/TimeSinceSOF"), bc.timeSinceSOF() / 60.); double p = mu > 0.001 ? mu / (1 - std::exp(-mu)) : 1.; // No pile-up for small mu (protection against division by zero) - mHistManager.fill(HIST("Event/nCollisions"), 0, bc.centrality(), p); + mHistManager.fill(HIST("Event/nCollisions"), 0, getCentrality(bc), p); if (bc.hasFT0()) { - mHistManager.fill(HIST("Event/nBCs"), 1, bc.centrality()); - mHistManager.fill(HIST("Event/nCollisions"), 1, bc.centrality(), p); + mHistManager.fill(HIST("Event/nBCs"), 1, getCentrality(bc)); + mHistManager.fill(HIST("Event/nCollisions"), 1, getCentrality(bc), p); } if (bc.hasTVX()) { - mHistManager.fill(HIST("Event/nBCs"), 2, bc.centrality()); - mHistManager.fill(HIST("Event/nCollisions"), 2, bc.centrality(), p); + mHistManager.fill(HIST("Event/nBCs"), 2, getCentrality(bc)); + mHistManager.fill(HIST("Event/nCollisions"), 2, getCentrality(bc), p); } if (bc.haskTVXinEMC()) { - mHistManager.fill(HIST("Event/nBCs"), 3, bc.centrality()); - mHistManager.fill(HIST("Event/nCollisions"), 3, bc.centrality(), p); + mHistManager.fill(HIST("Event/nBCs"), 3, getCentrality(bc)); + mHistManager.fill(HIST("Event/nCollisions"), 3, getCentrality(bc), p); } if (bc.hasEMCCell()) { - mHistManager.fill(HIST("Event/nBCs"), 4, bc.centrality()); - mHistManager.fill(HIST("Event/nCollisions"), 4, bc.centrality(), p); + mHistManager.fill(HIST("Event/nBCs"), 4, getCentrality(bc)); + mHistManager.fill(HIST("Event/nCollisions"), 4, getCentrality(bc), p); } if (clusters.size() > 0) { - mHistManager.fill(HIST("Event/nBCs"), 5, bc.centrality()); - mHistManager.fill(HIST("Event/nCollisions"), 5, bc.centrality(), p); + mHistManager.fill(HIST("Event/nBCs"), 5, getCentrality(bc)); + mHistManager.fill(HIST("Event/nCollisions"), 5, getCentrality(bc), p); } - mHistManager.fill(HIST("Event/Centrality"), bc.centrality()); - mHistManager.fill(HIST("Event/CentralityVsAmplitude"), bc.centrality(), bc.ft0Amplitude()); + mHistManager.fill(HIST("Event/Centrality"), getCentrality(bc)); + mHistManager.fill(HIST("Event/CentralityVsAmplitude"), getCentrality(bc), bc.ft0Amplitude()); - mHistManager.fill(HIST("Event/nCollPerBC"), collisions.size(), bc.centrality()); + mHistManager.fill(HIST("Event/nCollPerBC"), collisions.size(), getCentrality(bc)); if (collisions.size() == 2) { mHistManager.fill(HIST("Event/Z1VsZ2"), collisions.iteratorAt(0).zVtx(), collisions.iteratorAt(1).zVtx()); mHistManager.fill(HIST("Event/dZ"), collisions.iteratorAt(0).zVtx() - collisions.iteratorAt(1).zVtx()); @@ -205,7 +216,7 @@ struct EmcalBcWiseGammaGamma { if (openingAngle12 < cfgMinOpenAngle) continue; - mHistManager.fill(HIST("GG/invMassVsPt"), v12.M(), v12.Pt(), bc.centrality()); + mHistManager.fill(HIST("GG/invMassVsPt"), v12.M(), v12.Pt(), getCentrality(bc)); if (clusters.size() < 3) continue; @@ -241,7 +252,7 @@ struct EmcalBcWiseGammaGamma { ROOT::Math::PtEtaPhiMVector vBG = v3 + vi; - mHistManager.fill(HIST("GG/invMassVsPtBackground"), vBG.M(), vBG.Pt(), bc.centrality()); + mHistManager.fill(HIST("GG/invMassVsPtBackground"), vBG.M(), vBG.Pt(), getCentrality(bc)); } } } @@ -265,25 +276,25 @@ struct EmcalBcWiseGammaGamma { if (!g1.isEta()) { const auto& mcPi0 = mcPi0s.iteratorAt(g1.mesonID() - mcPi0s.offset()); - mHistManager.fill(HIST("True/pi0_PtRecVsPtTrue"), v12.Pt(), mcPi0.pt(), bc.centrality()); + mHistManager.fill(HIST("True/pi0_PtRecVsPtTrue"), v12.Pt(), mcPi0.pt(), getCentrality(bc)); if (mcPi0.isPrimary()) - mHistManager.fill(HIST("True/pi0_invMassVsPt_Primary"), v12.M(), v12.Pt(), bc.centrality()); + mHistManager.fill(HIST("True/pi0_invMassVsPt_Primary"), v12.M(), v12.Pt(), getCentrality(bc)); else if (mcPi0.isFromWD()) - mHistManager.fill(HIST("True/pi0_invMassVsPt_Secondary"), v12.M(), v12.Pt(), bc.centrality()); + mHistManager.fill(HIST("True/pi0_invMassVsPt_Secondary"), v12.M(), v12.Pt(), getCentrality(bc)); else - mHistManager.fill(HIST("True/pi0_invMassVsPt_HadronicShower"), v12.M(), v12.Pt(), bc.centrality()); + mHistManager.fill(HIST("True/pi0_invMassVsPt_HadronicShower"), v12.M(), v12.Pt(), getCentrality(bc)); } else { const auto& mcEta = mcEtas.iteratorAt(g1.mesonID() - mcEtas.offset()); - mHistManager.fill(HIST("True/eta_PtRecVsPtTrue"), v12.Pt(), mcEta.pt(), bc.centrality()); + mHistManager.fill(HIST("True/eta_PtRecVsPtTrue"), v12.Pt(), mcEta.pt(), getCentrality(bc)); if (mcEta.isPrimary()) - mHistManager.fill(HIST("True/eta_invMassVsPt_Primary"), v12.M(), v12.Pt(), bc.centrality()); + mHistManager.fill(HIST("True/eta_invMassVsPt_Primary"), v12.M(), v12.Pt(), getCentrality(bc)); else if (mcEta.isFromWD()) - mHistManager.fill(HIST("True/eta_invMassVsPt_Secondary"), v12.M(), v12.Pt(), bc.centrality()); + mHistManager.fill(HIST("True/eta_invMassVsPt_Secondary"), v12.M(), v12.Pt(), getCentrality(bc)); else - mHistManager.fill(HIST("True/eta_invMassVsPt_HadronicShower"), v12.M(), v12.Pt(), bc.centrality()); + mHistManager.fill(HIST("True/eta_invMassVsPt_HadronicShower"), v12.M(), v12.Pt(), getCentrality(bc)); } } } @@ -307,28 +318,28 @@ struct EmcalBcWiseGammaGamma { { for (const auto& mcPi0 : mcPi0s) { if (mcPi0.isPrimary()) { - mHistManager.fill(HIST("Generated/pi0_AllBCs"), mcPi0.pt(), bc.centrality()); + mHistManager.fill(HIST("Generated/pi0_AllBCs"), mcPi0.pt(), getCentrality(bc)); if (bc.hasFT0()) - mHistManager.fill(HIST("Generated/pi0_FT0"), mcPi0.pt(), bc.centrality()); + mHistManager.fill(HIST("Generated/pi0_FT0"), mcPi0.pt(), getCentrality(bc)); if (bc.hasTVX()) - mHistManager.fill(HIST("Generated/pi0_TVX"), mcPi0.pt(), bc.centrality()); + mHistManager.fill(HIST("Generated/pi0_TVX"), mcPi0.pt(), getCentrality(bc)); if (bc.haskTVXinEMC()) - mHistManager.fill(HIST("Generated/pi0_kTVXinEMC"), mcPi0.pt(), bc.centrality()); + mHistManager.fill(HIST("Generated/pi0_kTVXinEMC"), mcPi0.pt(), getCentrality(bc)); if (mcPi0.isAccepted() && bc.haskTVXinEMC()) - mHistManager.fill(HIST("Accepted/pi0_kTVXinEMC"), mcPi0.pt(), bc.centrality()); + mHistManager.fill(HIST("Accepted/pi0_kTVXinEMC"), mcPi0.pt(), getCentrality(bc)); } } for (const auto& mcEta : mcEtas) { if (mcEta.isPrimary()) { - mHistManager.fill(HIST("Generated/eta_AllBCs"), mcEta.pt(), bc.centrality()); + mHistManager.fill(HIST("Generated/eta_AllBCs"), mcEta.pt(), getCentrality(bc)); if (bc.hasFT0()) - mHistManager.fill(HIST("Generated/eta_FT0"), mcEta.pt(), bc.centrality()); + mHistManager.fill(HIST("Generated/eta_FT0"), mcEta.pt(), getCentrality(bc)); if (bc.hasTVX()) - mHistManager.fill(HIST("Generated/eta_TVX"), mcEta.pt(), bc.centrality()); + mHistManager.fill(HIST("Generated/eta_TVX"), mcEta.pt(), getCentrality(bc)); if (bc.haskTVXinEMC()) - mHistManager.fill(HIST("Generated/eta_kTVXinEMC"), mcEta.pt(), bc.centrality()); + mHistManager.fill(HIST("Generated/eta_kTVXinEMC"), mcEta.pt(), getCentrality(bc)); if (mcEta.isAccepted() && bc.haskTVXinEMC()) - mHistManager.fill(HIST("Accepted/eta_kTVXinEMC"), mcEta.pt(), bc.centrality()); + mHistManager.fill(HIST("Accepted/eta_kTVXinEMC"), mcEta.pt(), getCentrality(bc)); } } } @@ -340,7 +351,7 @@ struct EmcalBcWiseGammaGamma { fillEventHists(bc, collisions, clusters); - fillClusterHists(clusters, bc.centrality()); + fillClusterHists(clusters, getCentrality(bc)); reconstructMesons(clusters, bc); } @@ -356,7 +367,7 @@ struct EmcalBcWiseGammaGamma { return; for (const auto& cluster : clusters) - mHistManager.fill(HIST("True/clusterERecVsETrue"), cluster.e(), cluster.trueE(), bc.centrality()); + mHistManager.fill(HIST("True/clusterERecVsETrue"), cluster.e(), cluster.trueE(), getCentrality(bc)); reconstructTrueMesons(clusters, mcPi0s, mcEtas, bc); } From 432c51e8ffb7c117a94e62e9e31fade02b2711fb Mon Sep 17 00:00:00 2001 From: Nicolas Strangmann Date: Tue, 23 Sep 2025 17:14:28 +0200 Subject: [PATCH 2/3] Make MegaLinter happy --- PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx b/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx index 7f670c51e5e..6e3ccf1dbae 100644 --- a/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx +++ b/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx @@ -247,15 +247,15 @@ struct bcWiseClusterSkimmer { bool hasFoundFT0 = bc.has_foundFT0(); int foundFT0ID = hasFoundFT0 ? bc.foundFT0().bcId() : -1; int FT0ID = hasFT0 ? bc.ft0().bcId() : -1; - mHistManager.fill(HIST("BCHasFT0FoundFT0"), (float)FT0ID, (float)foundFT0ID); - mHistManager.fill(HIST("BCFoundFT0Diff"), (float)foundFT0ID - (float)FT0ID); + mHistManager.fill(HIST("BCHasFT0FoundFT0"), static_cast FT0ID, static_cast foundFT0ID); + mHistManager.fill(HIST("BCFoundFT0Diff"), static_cast foundFT0ID - static_cast FT0ID); auto bcIDInOrbit = bc.globalBC() % 3564; if (hasMCCollision) { - mHistManager.fill(HIST("BCIDOfMCColl"), (float)bcIDInOrbit); + mHistManager.fill(HIST("BCIDOfMCColl"), static_cast bcIDInOrbit); if (!hasFoundFT0) { - mHistManager.fill(HIST("BCIDOfMCCollButNoFT0"), (float)bcIDInOrbit); + mHistManager.fill(HIST("BCIDOfMCCollButNoFT0"), static_cast bcIDInOrbit); } } From f8c7333fc5dd77f83d88d8ecfc1fbd1e5e046f30 Mon Sep 17 00:00:00 2001 From: Nicolas Strangmann Date: Tue, 23 Sep 2025 21:58:01 +0200 Subject: [PATCH 3/3] Fix static_cast --- PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx b/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx index 6e3ccf1dbae..b193c642175 100644 --- a/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx +++ b/PWGEM/PhotonMeson/TableProducer/bcWiseClusterSkimmer.cxx @@ -247,15 +247,15 @@ struct bcWiseClusterSkimmer { bool hasFoundFT0 = bc.has_foundFT0(); int foundFT0ID = hasFoundFT0 ? bc.foundFT0().bcId() : -1; int FT0ID = hasFT0 ? bc.ft0().bcId() : -1; - mHistManager.fill(HIST("BCHasFT0FoundFT0"), static_cast FT0ID, static_cast foundFT0ID); - mHistManager.fill(HIST("BCFoundFT0Diff"), static_cast foundFT0ID - static_cast FT0ID); + mHistManager.fill(HIST("BCHasFT0FoundFT0"), static_cast(FT0ID), static_cast(foundFT0ID)); + mHistManager.fill(HIST("BCFoundFT0Diff"), static_cast(foundFT0ID - FT0ID)); auto bcIDInOrbit = bc.globalBC() % 3564; if (hasMCCollision) { - mHistManager.fill(HIST("BCIDOfMCColl"), static_cast bcIDInOrbit); + mHistManager.fill(HIST("BCIDOfMCColl"), static_cast(bcIDInOrbit)); if (!hasFoundFT0) { - mHistManager.fill(HIST("BCIDOfMCCollButNoFT0"), static_cast bcIDInOrbit); + mHistManager.fill(HIST("BCIDOfMCCollButNoFT0"), static_cast(bcIDInOrbit)); } }