diff --git a/Common/DataModel/Multiplicity.h b/Common/DataModel/Multiplicity.h index d2db60732f2..8d1e9b10ab3 100644 --- a/Common/DataModel/Multiplicity.h +++ b/Common/DataModel/Multiplicity.h @@ -211,12 +211,14 @@ using MultHepMCHI = MultHepMCHIs::iterator; namespace multZeq { -DECLARE_SOA_COLUMN(MultZeqFV0A, multZeqFV0A, float); //! Multiplicity equalized for the vertex position with the FV0A detector -DECLARE_SOA_COLUMN(MultZeqFT0A, multZeqFT0A, float); //! Multiplicity equalized for the vertex position with the FT0A detector -DECLARE_SOA_COLUMN(MultZeqFT0C, multZeqFT0C, float); //! Multiplicity equalized for the vertex position with the FT0C detector -DECLARE_SOA_COLUMN(MultZeqFDDA, multZeqFDDA, float); //! Multiplicity equalized for the vertex position with the FDDA detector -DECLARE_SOA_COLUMN(MultZeqFDDC, multZeqFDDC, float); //! Multiplicity equalized for the vertex position with the FDDC detector -DECLARE_SOA_COLUMN(MultZeqNTracksPV, multZeqNTracksPV, float); //! Multiplicity equalized for the vertex position from the PV contributors +DECLARE_SOA_COLUMN(MultZeqFV0A, multZeqFV0A, float); //! Multiplicity equalized for the vertex position with the FV0A detector +DECLARE_SOA_COLUMN(MultZeqFT0A, multZeqFT0A, float); //! Multiplicity equalized for the vertex position with the FT0A detector +DECLARE_SOA_COLUMN(MultZeqFT0C, multZeqFT0C, float); //! Multiplicity equalized for the vertex position with the FT0C detector +DECLARE_SOA_COLUMN(MultZeqFDDA, multZeqFDDA, float); //! Multiplicity equalized for the vertex position with the FDDA detector +DECLARE_SOA_COLUMN(MultZeqFDDC, multZeqFDDC, float); //! Multiplicity equalized for the vertex position with the FDDC detector +DECLARE_SOA_COLUMN(MultZeqNTracksPV, multZeqNTracksPV, float); //! Multiplicity equalized for the vertex position from the PV contributors +DECLARE_SOA_COLUMN(MultZeqNTracksGlobal, multZeqNTracksGlobal, float); //! Multiplicity equalized for the vertex position, global tracks +DECLARE_SOA_COLUMN(MultZeqMFTNtracks, multZeqMFTNtracks, float); //! Multiplicity equalized for the vertex position, MFT tracks } // namespace multZeq DECLARE_SOA_TABLE(FV0MultZeqs, "AOD", "FV0MULTZEQ", //! Multiplicity equalized for the vertex position with the FV0 detector multZeq::MultZeqFV0A); @@ -226,6 +228,10 @@ DECLARE_SOA_TABLE(FDDMultZeqs, "AOD", "FDDMULTZEQ", //! Multiplicity equalized f multZeq::MultZeqFDDA, multZeq::MultZeqFDDC); DECLARE_SOA_TABLE(PVMultZeqs, "AOD", "PVMULTZEQ", //! Multiplicity equalized for the vertex position from the PV contributors multZeq::MultZeqNTracksPV); +DECLARE_SOA_TABLE(GlobalMultZeqs, "AOD", "GLOBALMULTZEQ", //! Multiplicity equalized for the vertex position, global tracks + multZeq::MultZeqNTracksGlobal); +DECLARE_SOA_TABLE(MFTMultZeqs, "AOD", "MFTMULTZEQS", //! Multiplicity equalized for the vertex position, MFT tracks + multZeq::MultZeqMFTNtracks); using MultZeqs = soa::Join; using MultZeq = MultZeqs::iterator; diff --git a/Common/Tools/MultModule.h b/Common/Tools/MultModule.h index f722643fc2e..017c1d70de3 100644 --- a/Common/Tools/MultModule.h +++ b/Common/Tools/MultModule.h @@ -61,6 +61,8 @@ static const std::vector tableNames{ "FT0MultZeqs", "FDDMultZeqs", "PVMultZeqs", + "GlobalMultZeqs", + "MFTMultZeqs", "MultMCExtras", "Mult2MCExtras", "MFTMults", @@ -86,7 +88,7 @@ static const std::vector tableNames{ "BCCentFT0As", "BCCentFT0Cs"}; -static constexpr int nTablesConst = 36; +static constexpr int nTablesConst = 38; static const std::vector parameterNames{"enable"}; static const int defaultParameters[nTablesConst][nParameters]{ @@ -125,6 +127,8 @@ static const int defaultParameters[nTablesConst][nParameters]{ {-1}, {-1}, {-1}, + {-1}, + {-1}, {-1}}; // table index : match order above @@ -142,6 +146,8 @@ enum tableIndex { kFV0Mults, // standard kFT0MultZeqs, // zeq calib, standard kFDDMultZeqs, // zeq calib, standard kPVMultZeqs, // zeq calib, standard + kGlobalMultZeqs, // zeq calib, extra + kMFTMultZeqs, // zeq calib, extra kMultMCExtras, // MC exclusive kMult2MCExtras, // MC exclusive kMFTMults, // requires MFT task @@ -185,6 +191,8 @@ struct products : o2::framework::ProducesGroup { o2::framework::Produces tableFT0Zeqs; o2::framework::Produces tableFDDZeqs; o2::framework::Produces tablePVZeqs; + o2::framework::Produces tableNGlobalZeqs; + o2::framework::Produces tableNMFTZeqs; o2::framework::Produces tableExtraMc; o2::framework::Produces tableExtraMult2MCExtras; o2::framework::Produces mftMults; @@ -256,6 +264,8 @@ struct multEntry { float multFDDAZeq = -999.0f; float multFDDCZeq = -999.0f; float multNContribsZeq = 0; + float multMFTTracksZeq = 0; + float multGlobalTracksZeq = 0; int multGlobalTracks = 0; // multsGlobal int multNbrContribsEta05GlobalTrackWoDCA = 0; // multsGlobal @@ -317,6 +327,8 @@ class MultModule hVtxZFDDA = nullptr; hVtxZFDDC = nullptr; hVtxZNTracks = nullptr; + hVtxZNMFTTracks = nullptr; + hVtxZNGlobalTracks = nullptr; } // internal: calib related, vtx-z profiles @@ -330,6 +342,8 @@ class MultModule TProfile* hVtxZFDDA; TProfile* hVtxZFDDC; TProfile* hVtxZNTracks; + TProfile* hVtxZNMFTTracks; // non-legacy, added August/2025 + TProfile* hVtxZNGlobalTracks; // non-legacy, added August/2025 // declaration of structs here // (N.B.: will be invisible to the outside, create your own copies) @@ -469,15 +483,28 @@ class MultModule internalOpts.mEnabledTables[kMFTMults] = 1; listOfRequestors[kMFTMults].Append(Form("%s ", "dependency check")); } + if (internalOpts.mEnabledTables[kCentMFTs] && !internalOpts.mEnabledTables[kMFTMultZeqs]) { + internalOpts.mEnabledTables[kMFTMultZeqs] = 1; + listOfRequestors[kMFTMultZeqs].Append(Form("%s ", "dependency check")); + } if (internalOpts.mEnabledTables[kCentNGlobals] && !internalOpts.mEnabledTables[kMultsGlobal]) { internalOpts.mEnabledTables[kMultsGlobal] = 1; listOfRequestors[kMultsGlobal].Append(Form("%s ", "dependency check")); } + if (internalOpts.mEnabledTables[kCentNGlobals] && !internalOpts.mEnabledTables[kGlobalMultZeqs]) { + internalOpts.mEnabledTables[kGlobalMultZeqs] = 1; + listOfRequestors[kGlobalMultZeqs].Append(Form("%s ", "dependency check")); + } if (internalOpts.embedINELgtZEROselection.value > 0 && !internalOpts.mEnabledTables[kPVMults]) { internalOpts.mEnabledTables[kPVMults] = 1; listOfRequestors[kPVMults].Append(Form("%s ", "dependency check")); } + // capture the need for PYTHIA calibration in Pb-Pb runs + if (metadataInfo.isMC() && mRunNumber >= 544013 && mRunNumber <= 545367) { + internalOpts.generatorName.value = "PYTHIA"; + } + // list enabled tables for (int i = 0; i < nTablesConst; i++) { // printout to be improved in the future @@ -486,11 +513,6 @@ class MultModule } } - // capture the need for PYTHIA calibration in Pb-Pb runs - if (metadataInfo.isMC() && mRunNumber >= 544013 && mRunNumber <= 545367) { - internalOpts.generatorName.value = "PYTHIA"; - } - mRunNumber = 0; mRunNumberCentrality = 0; lCalibLoaded = false; @@ -500,8 +522,9 @@ class MultModule hVtxZFDDA = nullptr; hVtxZFDDC = nullptr; hVtxZNTracks = nullptr; + hVtxZNMFTTracks = nullptr; + hVtxZNGlobalTracks = nullptr; - // pass to the outside opts = internalOpts; } @@ -632,12 +655,20 @@ class MultModule hVtxZFDDA = static_cast(lCalibObjects->FindObject("hVtxZFDDA")); hVtxZFDDC = static_cast(lCalibObjects->FindObject("hVtxZFDDC")); hVtxZNTracks = static_cast(lCalibObjects->FindObject("hVtxZNTracksPV")); + hVtxZNMFTTracks = static_cast(lCalibObjects->FindObject("hVtxZMFT")); + hVtxZNGlobalTracks = static_cast(lCalibObjects->FindObject("hVtxZNGlobals")); lCalibLoaded = true; // Capture error if (!hVtxZFV0A || !hVtxZFT0A || !hVtxZFT0C || !hVtxZFDDA || !hVtxZFDDC || !hVtxZNTracks) { LOGF(error, "Problem loading CCDB objects! Please check"); lCalibLoaded = false; } + if (!hVtxZNMFTTracks) { + LOGF(info, "MFT track counter: vertex-Z calibration not loaded, will run without."); + } + if (!hVtxZNGlobalTracks) { + LOGF(info, "Global track counter: vertex-Z calibration not loaded, will run without."); + } } else { LOGF(error, "Problem loading CCDB object! Please check"); lCalibLoaded = false; @@ -722,9 +753,9 @@ class MultModule } //_______________________________________________________________________ - // forward detector signals, vertex-Z equalized + // vertex-Z equalized signals if (internalOpts.mEnabledTables[kFV0MultZeqs]) { - if (std::fabs(collision.posZ() && lCalibLoaded)) { + if (std::fabs(collision.posZ()) < 15.0f && lCalibLoaded) { mults.multFV0AZeq = hVtxZFV0A->Interpolate(0.0) * mults.multFV0A / hVtxZFV0A->Interpolate(collision.posZ()); } else { mults.multFV0AZeq = 0.0f; @@ -732,7 +763,7 @@ class MultModule cursors.tableFV0Zeqs(mults.multFV0AZeq); } if (internalOpts.mEnabledTables[kFT0MultZeqs]) { - if (std::fabs(collision.posZ() && lCalibLoaded)) { + if (std::fabs(collision.posZ()) < 15.0f && lCalibLoaded) { mults.multFT0AZeq = hVtxZFT0A->Interpolate(0.0) * mults.multFT0A / hVtxZFT0A->Interpolate(collision.posZ()); mults.multFT0CZeq = hVtxZFT0C->Interpolate(0.0) * mults.multFT0C / hVtxZFT0C->Interpolate(collision.posZ()); } else { @@ -742,7 +773,7 @@ class MultModule cursors.tableFT0Zeqs(mults.multFT0AZeq, mults.multFT0CZeq); } if (internalOpts.mEnabledTables[kFDDMultZeqs]) { - if (std::fabs(collision.posZ() && lCalibLoaded)) { + if (std::fabs(collision.posZ()) < 15.0f && lCalibLoaded) { mults.multFDDAZeq = hVtxZFDDA->Interpolate(0.0) * mults.multFDDA / hVtxZFDDA->Interpolate(collision.posZ()); mults.multFDDCZeq = hVtxZFDDC->Interpolate(0.0) * mults.multFDDC / hVtxZFDDC->Interpolate(collision.posZ()); } else { @@ -754,7 +785,7 @@ class MultModule //_______________________________________________________________________ // determine if barrel track loop is required, do it (once!) if so but save CPU if not - if (internalOpts.mEnabledTables[kTPCMults] || internalOpts.mEnabledTables[kPVMults] || internalOpts.mEnabledTables[kMultsExtra] || internalOpts.mEnabledTables[kPVMultZeqs] || internalOpts.mEnabledTables[kMultsGlobal]) { + if (internalOpts.mEnabledTables[kTPCMults] || internalOpts.mEnabledTables[kPVMults] || internalOpts.mEnabledTables[kMultsExtra] || internalOpts.mEnabledTables[kPVMultZeqs] || internalOpts.mEnabledTables[kMultsGlobal] || internalOpts.mEnabledTables[kGlobalMultZeqs]) { // single loop to calculate all for (const auto& track : tracks) { if (track.hasTPC()) { @@ -822,6 +853,17 @@ class MultModule } cursors.multsGlobal(mults.multGlobalTracks, mults.multNbrContribsEta08GlobalTrackWoDCA, mults.multNbrContribsEta10GlobalTrackWoDCA, mults.multNbrContribsEta05GlobalTrackWoDCA); + + if (!hVtxZNGlobalTracks || std::fabs(collision.posZ()) > 15.0f) { + mults.multGlobalTracksZeq = mults.multGlobalTracks; // if no equalization available, don't do it + } else { + mults.multGlobalTracksZeq = hVtxZNGlobalTracks->Interpolate(0.0) * mults.multFT0C / hVtxZNGlobalTracks->Interpolate(collision.posZ()); + } + + // provide vertex-Z equalized Nglobals (or non-equalized if missing or beyond range) + if (internalOpts.mEnabledTables[kGlobalMultZeqs]) { + cursors.tableNGlobalZeqs(mults.multGlobalTracksZeq); + } } // fill track counters at this stage if requested @@ -842,7 +884,7 @@ class MultModule collision.flags()); } if (internalOpts.mEnabledTables[kPVMultZeqs]) { - if (std::fabs(collision.posZ()) && lCalibLoaded) { + if (std::fabs(collision.posZ()) < 15.0f && lCalibLoaded) { mults.multNContribsZeq = hVtxZNTracks->Interpolate(0.0) * mults.multNContribs / hVtxZNTracks->Interpolate(collision.posZ()); } else { mults.multNContribsZeq = 0.0f; @@ -934,6 +976,18 @@ class MultModule cursors.mftMults(nAllTracks, nTracks); mults[collision.globalIndex()].multMFTAllTracks = nAllTracks; mults[collision.globalIndex()].multMFTTracks = nTracks; + + // vertex-Z equalized MFT + if (!hVtxZNMFTTracks || std::fabs(collision.posZ()) > 15.0f) { + mults[collision.globalIndex()].multMFTTracksZeq = mults[collision.globalIndex()].multMFTTracks; // if no equalization available, don't do it + } else { + mults[collision.globalIndex()].multMFTTracksZeq = hVtxZNMFTTracks->Interpolate(0.0) * mults[collision.globalIndex()].multMFTTracks / hVtxZNMFTTracks->Interpolate(collision.posZ()); + } + + // provide vertex-Z equalized Nglobals (or non-equalized if missing or beyond range) + if (internalOpts.mEnabledTables[kMFTMultZeqs]) { + cursors.tableNMFTZeqs(mults[collision.globalIndex()].multMFTTracksZeq); + } } //__________________________________________________ @@ -1225,9 +1279,9 @@ class MultModule if (internalOpts.mEnabledTables[kCentNTPVs]) populateTable(cursors.centNTPV, ntpvInfo, mults[iEv].multNContribs, isInelGt0); if (internalOpts.mEnabledTables[kCentNGlobals]) - populateTable(cursors.centNGlobals, nGlobalInfo, mults[iEv].multGlobalTracks, isInelGt0); + populateTable(cursors.centNGlobals, nGlobalInfo, mults[iEv].multGlobalTracksZeq, isInelGt0); if (internalOpts.mEnabledTables[kCentMFTs]) - populateTable(cursors.centMFTs, mftInfo, mults[iEv].multMFTTracks, isInelGt0); + populateTable(cursors.centMFTs, mftInfo, mults[iEv].multMFTTracksZeq, isInelGt0); } // populate centralities per BC