diff --git a/Common/Tasks/centralityStudy.cxx b/Common/Tasks/centralityStudy.cxx index 298a7e57eaf..1bfab6c5835 100644 --- a/Common/Tasks/centralityStudy.cxx +++ b/Common/Tasks/centralityStudy.cxx @@ -59,25 +59,48 @@ struct centralityStudy { uint64_t startOfRunTimestamp; // vertex Z equalization - TList* hCalibObjects; - TProfile* hVtxZFV0A; - TProfile* hVtxZFT0A; - TProfile* hVtxZFT0C; - TProfile* hVtxZNTracks; - TProfile* hVtxZNGlobals; - TProfile* hVtxZMFT; - TProfile* hVtxZFDDA; - TProfile* hVtxZFDDC; + TProfile* hVtxZFV0A = nullptr; + TProfile* hVtxZFT0A = nullptr; + TProfile* hVtxZFT0C = nullptr; + TProfile* hVtxZNTracks = nullptr; + TProfile* hVtxZNGlobals = nullptr; + TProfile* hVtxZMFT = nullptr; + TProfile* hVtxZFDDA = nullptr; + TProfile* hVtxZFDDC = nullptr; + + // calibration histograms + TH1* hCentralityFV0A = nullptr; + TH1* hCentralityFT0A = nullptr; + TH1* hCentralityFT0C = nullptr; + TH1* hCentralityFT0M = nullptr; + TH1* hCentralityFDDM = nullptr; + TH1* hCentralityNTPV = nullptr; + TH1* hCentralityNGlo = nullptr; + TH1* hCentralityMFT = nullptr; + + float centFV0A = 105.f; + float centFT0A = 105.f; + float centFT0C = 105.f; + float centFT0M = 105.f; + float centFDDM = 105.f; + float centNTPV = 105.f; + float centNGlo = 105.f; + float centMFT = 105.f; // Configurables Configurable applyVertexZEqualization{"applyVertexZEqualization", false, "0 - no, 1 - yes"}; Configurable minTimeDelta{"minTimeDelta", -1.0f, "reject collision if another collision is this close or less in time"}; - Configurable ccdbURL{"ccdbURL", "http://alice-ccdb.cern.ch", "ccdb url"}; - Configurable pathGRPECSObject{"pathGRPECSObject", "GLO/Config/GRPECS", "Path to GRPECS object"}; - Configurable pathVertexZ{"pathVertexZ", "Users/d/ddobrigk/Centrality/Calibration", "Path to vertexZ profiles"}; - Configurable irSource{"irSource", "ZNC hadronic", "Source of the interaction rate: (Recommended: pp --> T0VTX, Pb-Pb --> ZNC hadronic)"}; - Configurable irCrashOnNull{"irCrashOnNull", false, "Flag to avoid CTP RateFetcher crash."}; + struct : ConfigurableGroup { + std::string prefix = "ccdbSettings"; + Configurable ccdbURL{"ccdbURL", "http://alice-ccdb.cern.ch", "ccdb url"}; + Configurable pathCentrality{"pathCentrality", "Centrality/Estimators", "path to centrality calibration if fetchCentralityCalibration is enabled"}; + Configurable pathGRPECSObject{"pathGRPECSObject", "GLO/Config/GRPECS", "Path to GRPECS object"}; + Configurable pathVertexZ{"pathVertexZ", "Users/d/ddobrigk/Centrality/Calibration", "Path to vertexZ profiles"}; + Configurable irSource{"irSource", "ZNC hadronic", "Source of the interaction rate: (Recommended: pp --> T0VTX, Pb-Pb --> ZNC hadronic)"}; + Configurable irCrashOnNull{"irCrashOnNull", false, "Flag to avoid CTP RateFetcher crash."}; + Configurable fetchCentralityCalibration{"fetchCentralityCalibration", false, "Flag to fetch the centrality calibration within the task instead of the centrality table"}; + } ccdbSettings; // _______________________________________ // Configurable group @@ -127,7 +150,6 @@ struct centralityStudy { Configurable vertexZwithT0{"vertexZwithT0", 1000.0f, "require a certain vertex-Z in BC analysis"}; Configurable rejectIsFlangeEvent{"rejectIsFlangeEvent", false, "At least one channel with -350 TDC < time < -450 TDC"}; Configurable minFT0CforVertexZ{"minFT0CforVertexZ", -1.0f, "minimum FT0C for vertex-Z profile calculation"}; - } bcsel; // _______________________________________ @@ -202,17 +224,7 @@ struct centralityStudy { void init(InitContext&) { - hCalibObjects = nullptr; - hVtxZFV0A = nullptr; - hVtxZFT0A = nullptr; - hVtxZFT0C = nullptr; - hVtxZNTracks = nullptr; - hVtxZNGlobals = nullptr; - hVtxZMFT = nullptr; - hVtxZFDDA = nullptr; - hVtxZFDDC = nullptr; - - ccdb->setURL(ccdbURL); + ccdb->setURL(ccdbSettings.ccdbURL); // ccdb->setCaching(true); // ccdb->setLocalObjectValidityChecking(); ccdb->setFatalWhenNull(false); @@ -291,7 +303,7 @@ struct centralityStudy { histos.add("hFT0COccupancyVsNGlobalTracksVsFT0C", "hFT0COccupancyVsNGlobalTracksVsFT0C", kTH3F, {axisFT0COccupancy, axisMultGlobalTracks, axisMultFT0C}); } - if (doprocessCollisionsWithCentrality) { + if (doprocessCollisionsWithCentrality || ccdbSettings.fetchCentralityCalibration) { // in case requested: do vs centrality debugging histos.add("hCentrality", "hCentrality", kTH1F, {axisCentrality}); histos.add("hNContribsVsCentrality", "hNContribsVsCentrality", kTH2F, {axisCentrality, axisMultPVContributors}); @@ -301,6 +313,7 @@ struct centralityStudy { histos.add("hNMFTTracksVsCentrality", "hNMFTTracksVsCentrality", kTH2F, {axisCentrality, axisMultMFTTracks}); histos.add("hPVChi2VsCentrality", "hPVChi2VsCentrality", kTH2F, {axisCentrality, axisPVChi2}); histos.add("hDeltaTimeVsCentrality", "hDeltaTimeVsCentrality", kTH2F, {axisCentrality, axisDeltaTime}); + histos.add("hInteractionRateVsCentrality", "hInteractionRateVsCentrality", kTH2F, {axisCentrality, axisInteractionRate}); if (studies.doOccupancyStudyVsCentrality2d) { histos.add("hNcontribsProfileVsTrackOccupancyVsCentrality", "hNcontribsProfileVsTrackOccupancyVsCentrality", kTProfile2D, {axisTrackOccupancy, axisCentrality}); @@ -379,22 +392,22 @@ struct centralityStudy { LOGF(info, "Setting up for run: %i", mRunNumber); // only get object when switching runs - o2::parameters::GRPECSObject* grpo = ccdb->getForRun(pathGRPECSObject, mRunNumber); + o2::parameters::GRPECSObject* grpo = ccdb->getForRun(ccdbSettings.pathGRPECSObject, mRunNumber); startOfRunTimestamp = grpo->getTimeStart(); if (applyVertexZEqualization.value) { // acquire vertex-Z equalization histograms if requested LOGF(info, "Acquiring vertex-Z profiles for run %i", mRunNumber); - hCalibObjects = ccdb->getForRun(pathVertexZ, mRunNumber); + TList* hCalibObjects = ccdb->getForRun(ccdbSettings.pathVertexZ, mRunNumber); - hVtxZFV0A = static_cast(hCalibObjects->FindObject("hVtxZFV0A")); - hVtxZFT0A = static_cast(hCalibObjects->FindObject("hVtxZFT0A")); - hVtxZFT0C = static_cast(hCalibObjects->FindObject("hVtxZFT0C")); - // hVtxZFDDA = static_cast(hCalibObjects->FindObject("hVtxZFDDA")); - // hVtxZFDDC = static_cast(hCalibObjects->FindObject("hVtxZFDDC")); - hVtxZNTracks = static_cast(hCalibObjects->FindObject("hVtxZNTracksPV")); - hVtxZNGlobals = static_cast(hCalibObjects->FindObject("hVtxZNGlobals")); - hVtxZMFT = static_cast(hCalibObjects->FindObject("hVtxZMFT")); + hVtxZFV0A = dynamic_cast(hCalibObjects->FindObject("hVtxZFV0A")); + hVtxZFT0A = dynamic_cast(hCalibObjects->FindObject("hVtxZFT0A")); + hVtxZFT0C = dynamic_cast(hCalibObjects->FindObject("hVtxZFT0C")); + // hVtxZFDDA = dynamic_cast(hCalibObjects->FindObject("hVtxZFDDA")); + // hVtxZFDDC = dynamic_cast(hCalibObjects->FindObject("hVtxZFDDC")); + hVtxZNTracks = dynamic_cast(hCalibObjects->FindObject("hVtxZNTracksPV")); + hVtxZNGlobals = dynamic_cast(hCalibObjects->FindObject("hVtxZNGlobals")); + hVtxZMFT = dynamic_cast(hCalibObjects->FindObject("hVtxZMFT")); // Capture error if (!hVtxZFV0A || !hVtxZFT0A || !hVtxZFT0C || !hVtxZNTracks || !hVtxZNGlobals || !hVtxZMFT) { @@ -402,6 +415,76 @@ struct centralityStudy { } } + if (ccdbSettings.fetchCentralityCalibration) { + LOGF(info, "Acquiring centrality calibration for run %i", mRunNumber); + TList* hCentralityObjects = ccdb->getForRun(ccdbSettings.pathCentrality, mRunNumber); + hCentralityFV0A = dynamic_cast(hCentralityObjects->FindObject("hCalibZeqFV0")); + hCentralityFT0A = dynamic_cast(hCentralityObjects->FindObject("hCalibZeqFT0A")); + hCentralityFT0C = dynamic_cast(hCentralityObjects->FindObject("hCalibZeqFT0C")); + hCentralityFT0M = dynamic_cast(hCentralityObjects->FindObject("hCalibZeqFT0")); + hCentralityFDDM = dynamic_cast(hCentralityObjects->FindObject("hCalibZeqFDD")); + hCentralityNTPV = dynamic_cast(hCentralityObjects->FindObject("hCalibZeqNTracksPV")); + hCentralityNGlo = dynamic_cast(hCentralityObjects->FindObject("hCalibZeqNGlobal")); + hCentralityMFT = dynamic_cast(hCentralityObjects->FindObject("hCalibZeqMFT")); + + // won't capture null pointers -> explicitly check for those when attempting to evaluate + auto reportSuccess = [](TH1* hist, const std::string& name) { + if (!hist) { + LOGF(info, "Calibration missing for %s", name); + } else { + LOGF(info, "Calibration loaded for %s", name); + } + }; + + reportSuccess(hCentralityFV0A, "FV0A"); + reportSuccess(hCentralityFT0A, "FT0A"); + reportSuccess(hCentralityFT0C, "FT0C"); + reportSuccess(hCentralityFT0M, "FT0M"); + reportSuccess(hCentralityFDDM, "FDDM"); + reportSuccess(hCentralityNTPV, "NTPV"); + reportSuccess(hCentralityNGlo, "NGlobals"); + reportSuccess(hCentralityMFT, "MFT"); + + LOGF(info, "Centrality calibration loading done."); + auto getCent = [](TH1* hist, float mult) -> float { + return hist ? hist->GetBinContent(mult) : 0.0; + }; + + centFV0A = getCent(hCentralityFV0A, collision.multFV0A()); + centFT0A = getCent(hCentralityFT0A, collision.multFT0A()); + centFT0C = getCent(hCentralityFT0C, collision.multFT0C()); + centFT0M = getCent(hCentralityFT0M, collision.multFT0A() + collision.multFT0C()); + centFDDM = getCent(hCentralityFDDM, collision.multFDDA() + collision.multFDDC()); + centNTPV = getCent(hCentralityNTPV, collision.multNTracksPV()); + centNGlo = getCent(hCentralityNGlo, collision.multNTracksGlobal()); + centMFT = getCent(hCentralityMFT, collision.mftNtracks()); + } else if (doprocessCollisionsWithCentrality) { + if constexpr (requires { collision.centFV0A(); }) { + centFV0A = collision.centFV0A(); + } + if constexpr (requires { collision.centFT0A(); }) { + centFT0A = collision.centFT0A(); + } + if constexpr (requires { collision.centFT0C(); }) { + centFT0C = collision.centFT0C(); + } + if constexpr (requires { collision.centFT0M(); }) { + centFT0M = collision.centFT0M(); + } + if constexpr (requires { collision.centFDDM(); }) { + centFDDM = collision.centFDDM(); + } + if constexpr (requires { collision.centNTPV(); }) { + centNTPV = collision.centNTPV(); + } + if constexpr (requires { collision.centNGlobal(); }) { + centNGlo = collision.centNGlobal(); + } + if constexpr (requires { collision.centMFT(); }) { + centMFT = collision.centMFT(); + } + } + if (!studies.doRunByRunHistograms) { return; } @@ -434,6 +517,7 @@ struct centralityStudy { histPointers.insert({histPath + "hNGlobalTracks", histos.add((histPath + "hNGlobalTracks").c_str(), "hNGlobalTracks", {kTH1D, {{axisMultUltraFineGlobalTracks}}})}); histPointers.insert({histPath + "hNMFTTracks", histos.add((histPath + "hNMFTTracks").c_str(), "hNMFTTracks", {kTH1D, {{axisMultUltraFineMFTTracks}}})}); histPointers.insert({histPath + "hNPVContributors", histos.add((histPath + "hNPVContributors").c_str(), "hNPVContributors", {kTH1D, {{axisMultUltraFinePVContributors}}})}); + histPointers.insert({histPath + "hInteractionRate", histos.add((histPath + "hInteractionRate").c_str(), "hInteractionRate", {kTH1D, {{axisInteractionRate}}})}); if (applyVertexZEqualization) { histPointers.insert({histPath + "hFT0C_Collisions_Unequalized", histos.add((histPath + "hFT0C_Collisions_Unequalized").c_str(), "hFT0C_Collisions_Unequalized", {kTH1D, {{axisMultUltraFineFT0C}}})}); @@ -464,7 +548,7 @@ struct centralityStudy { histPointers.insert({histPath + "hFDDCVsFT0C", histos.add((histPath + "hFDDCVsFT0C").c_str(), "hFDDCVsFT0C", {kTH2F, {{axisMultFT0C, axisMultFDDC}}})}); } - if (doprocessCollisionsWithCentrality) { + if (doprocessCollisionsWithCentrality || ccdbSettings.fetchCentralityCalibration) { // in case requested: do vs centrality debugging histPointers.insert({histPath + "hCentrality", histos.add((histPath + "hCentrality").c_str(), "hCentrality", {kTH1F, {{axisCentrality}}})}); histPointers.insert({histPath + "hNContribsVsCentrality", histos.add((histPath + "hNContribsVsCentrality").c_str(), "hNContribsVsCentrality", {kTH2F, {{axisCentrality, axisMultPVContributors}}})}); @@ -474,6 +558,7 @@ struct centralityStudy { histPointers.insert({histPath + "hNMFTTracksVsCentrality", histos.add((histPath + "hNMFTTracksVsCentrality").c_str(), "hNMFTTracksVsCentrality", {kTH2F, {{axisCentrality, axisMultMFTTracks}}})}); histPointers.insert({histPath + "hPVChi2VsCentrality", histos.add((histPath + "hPVChi2VsCentrality").c_str(), "hPVChi2VsCentrality", {kTH2F, {{axisCentrality, axisPVChi2}}})}); histPointers.insert({histPath + "hDeltaTimeVsCentrality", histos.add((histPath + "hDeltaTimeVsCentrality").c_str(), "hDeltaTimeVsCentrality", {kTH2F, {{axisCentrality, axisDeltaTime}}})}); + histPointers.insert({histPath + "hInteractionRateVsCentrality", histos.add((histPath + "hInteractionRateVsCentrality").c_str(), "hInteractionRateVsCentrality", {kTH2F, {{axisCentrality, axisInteractionRate}}})}); } if (studies.doNGlobalTracksVsRawSignals) { @@ -497,7 +582,6 @@ struct centralityStudy { histPointers.insert({histPath + "hPVzProfileCoVsTime", histos.add((histPath + "hPVzProfileCoVsTime").c_str(), "hPVzProfileCoVsTime", {kTProfile, {{axisDeltaTimestamp}}})}); histPointers.insert({histPath + "hPVzProfileBcVsTime", histos.add((histPath + "hPVzProfileBcVsTime").c_str(), "hPVzProfileBcVsTime", {kTProfile, {{axisDeltaTimestamp}}})}); histPointers.insert({histPath + "hIRProfileVsTime", histos.add((histPath + "hIRProfileVsTime").c_str(), "hIRProfileVsTime", {kTProfile, {{axisDeltaTimestamp}}})}); - histPointers.insert({histPath + "hInteractionRate", histos.add((histPath + "hInteractionRate").c_str(), "hInteractionRate", {kTH1D, {{axisInteractionRate}}})}); } } @@ -652,7 +736,7 @@ struct centralityStudy { float timeToNeighbour = TMath::Min( std::abs(collision.timeToNext()), std::abs(collision.timeToPrevious())); - histos.fill(HIST("hDeltaTimeVsCentrality"), collision.centFT0C(), timeToNeighbour); + histos.fill(HIST("hDeltaTimeVsCentrality"), centFT0C, timeToNeighbour); if (timeToNeighbour < minTimeDelta) { return; } @@ -830,45 +914,51 @@ struct centralityStudy { } // if the table has centrality information - if constexpr (requires { collision.centFT0C(); }) { - // process FT0C centrality plots - histos.fill(HIST("hCentrality"), collision.centFT0C()); - histos.fill(HIST("hNContribsVsCentrality"), collision.centFT0C(), collision.multPVTotalContributors()); - histos.fill(HIST("hNITSTPCTracksVsCentrality"), collision.centFT0C(), collision.multNTracksITSTPC()); - histos.fill(HIST("hNITSOnlyTracksVsCentrality"), collision.centFT0C(), collision.multNTracksITSOnly()); - histos.fill(HIST("hNGlobalTracksVsCentrality"), collision.centFT0C(), collision.multNTracksGlobal()); - histos.fill(HIST("hNMFTTracksVsCentrality"), collision.centFT0C(), collision.mftNtracks()); - histos.fill(HIST("hPVChi2VsCentrality"), collision.centFT0C(), collision.multPVChi2()); + // process FT0C centrality plots + if (doprocessCollisionsWithCentrality || ccdbSettings.fetchCentralityCalibration) { + histos.fill(HIST("hCentrality"), centFT0C); + histos.fill(HIST("hNContribsVsCentrality"), centFT0C, collision.multPVTotalContributors()); + histos.fill(HIST("hNITSTPCTracksVsCentrality"), centFT0C, collision.multNTracksITSTPC()); + histos.fill(HIST("hNITSOnlyTracksVsCentrality"), centFT0C, collision.multNTracksITSOnly()); + histos.fill(HIST("hNGlobalTracksVsCentrality"), centFT0C, collision.multNTracksGlobal()); + histos.fill(HIST("hNMFTTracksVsCentrality"), centFT0C, collision.mftNtracks()); + histos.fill(HIST("hPVChi2VsCentrality"), centFT0C, collision.multPVChi2()); if (studies.doRunByRunHistograms) { - getHist(TH1, histPath + "hCentrality")->Fill(collision.centFT0C()); - getHist(TH2, histPath + "hNContribsVsCentrality")->Fill(collision.centFT0C(), collision.multPVTotalContributors()); - getHist(TH2, histPath + "hNITSTPCTracksVsCentrality")->Fill(collision.centFT0C(), collision.multNTracksITSTPC()); - getHist(TH2, histPath + "hNITSOnlyTracksVsCentrality")->Fill(collision.centFT0C(), collision.multNTracksITSOnly()); - getHist(TH2, histPath + "hNGlobalTracksVsCentrality")->Fill(collision.centFT0C(), collision.multNTracksGlobal()); - getHist(TH2, histPath + "hNMFTTracksVsCentrality")->Fill(collision.centFT0C(), collision.mftNtracks()); - getHist(TH2, histPath + "hPVChi2VsCentrality")->Fill(collision.centFT0C(), collision.multPVChi2()); + getHist(TH1, histPath + "hCentrality")->Fill(centFT0C); + getHist(TH2, histPath + "hNContribsVsCentrality")->Fill(centFT0C, collision.multPVTotalContributors()); + getHist(TH2, histPath + "hNITSTPCTracksVsCentrality")->Fill(centFT0C, collision.multNTracksITSTPC()); + getHist(TH2, histPath + "hNITSOnlyTracksVsCentrality")->Fill(centFT0C, collision.multNTracksITSOnly()); + getHist(TH2, histPath + "hNGlobalTracksVsCentrality")->Fill(centFT0C, collision.multNTracksGlobal()); + getHist(TH2, histPath + "hNMFTTracksVsCentrality")->Fill(centFT0C, collision.mftNtracks()); + getHist(TH2, histPath + "hPVChi2VsCentrality")->Fill(centFT0C, collision.multPVChi2()); } if (studies.doOccupancyStudyVsCentrality2d) { - histos.fill(HIST("hNcontribsProfileVsTrackOccupancyVsCentrality"), collision.trackOccupancyInTimeRange(), collision.centFT0C(), collision.multPVTotalContributors()); - histos.fill(HIST("hNGlobalTracksProfileVsTrackOccupancyVsCentrality"), collision.trackOccupancyInTimeRange(), collision.centFT0C(), collision.multNTracksGlobal()); - histos.fill(HIST("hNcontribsProfileVsFT0COccupancyVsCentrality"), collision.ft0cOccupancyInTimeRange(), collision.centFT0C(), collision.multPVTotalContributors()); - histos.fill(HIST("hNGlobalTracksProfileVsFT0COccupancyVsCentrality"), collision.ft0cOccupancyInTimeRange(), collision.centFT0C(), collision.multNTracksGlobal()); + histos.fill(HIST("hNcontribsProfileVsTrackOccupancyVsCentrality"), collision.trackOccupancyInTimeRange(), centFT0C, collision.multPVTotalContributors()); + histos.fill(HIST("hNGlobalTracksProfileVsTrackOccupancyVsCentrality"), collision.trackOccupancyInTimeRange(), centFT0C, collision.multNTracksGlobal()); + histos.fill(HIST("hNcontribsProfileVsFT0COccupancyVsCentrality"), collision.ft0cOccupancyInTimeRange(), centFT0C, collision.multPVTotalContributors()); + histos.fill(HIST("hNGlobalTracksProfileVsFT0COccupancyVsCentrality"), collision.ft0cOccupancyInTimeRange(), centFT0C, collision.multNTracksGlobal()); } if (studies.doOccupancyStudyVsCentrality3d) { - histos.fill(HIST("hTrackOccupancyVsNContribsVsCentrality"), collision.trackOccupancyInTimeRange(), collision.multPVTotalContributors(), collision.centFT0C()); - histos.fill(HIST("hTrackOccupancyVsNGlobalTracksVsCentrality"), collision.trackOccupancyInTimeRange(), collision.multNTracksGlobal(), collision.centFT0C()); - histos.fill(HIST("hFT0COccupancyVsNContribsVsCentrality"), collision.ft0cOccupancyInTimeRange(), collision.multPVTotalContributors(), collision.centFT0C()); - histos.fill(HIST("hFT0COccupancyVsNGlobalTracksVsCentrality"), collision.ft0cOccupancyInTimeRange(), collision.multNTracksGlobal(), collision.centFT0C()); + histos.fill(HIST("hTrackOccupancyVsNContribsVsCentrality"), collision.trackOccupancyInTimeRange(), collision.multPVTotalContributors(), centFT0C); + histos.fill(HIST("hTrackOccupancyVsNGlobalTracksVsCentrality"), collision.trackOccupancyInTimeRange(), collision.multNTracksGlobal(), centFT0C); + histos.fill(HIST("hFT0COccupancyVsNContribsVsCentrality"), collision.ft0cOccupancyInTimeRange(), collision.multPVTotalContributors(), centFT0C); + histos.fill(HIST("hFT0COccupancyVsNGlobalTracksVsCentrality"), collision.ft0cOccupancyInTimeRange(), collision.multNTracksGlobal(), centFT0C); } } if constexpr (requires { collision.has_multBC(); }) { if (collision.has_multBC()) { auto multbc = collision.template multBC_as(); - uint64_t bcTimestamp = multbc.timestamp(); - const float interactionRate = mRateFetcher.fetch(ccdb.service, bcTimestamp, mRunNumber, irSource.value, irCrashOnNull) / 1000.; // kHz + const uint64_t bcTimestamp = multbc.timestamp(); + const float interactionRate = mRateFetcher.fetch(ccdb.service, bcTimestamp, mRunNumber, ccdbSettings.irSource.value, ccdbSettings.irCrashOnNull) / 1000.; // kHz histos.fill(HIST("hInteractionRate"), interactionRate); + if (doprocessCollisionsWithCentrality || ccdbSettings.fetchCentralityCalibration) { + histos.fill(HIST("hInteractionRateVsCentrality"), centFT0C, interactionRate); + } + if (studies.doRunByRunHistograms) { + getHist(TH2, histPath + "hInteractionRateVsCentrality")->Fill(centFT0C, interactionRate); + } if (studies.doRunByRunHistograms) { getHist(TH1, histPath + "hInteractionRate")->Fill(interactionRate); if (studies.doTimeStudies) { @@ -1013,8 +1103,8 @@ struct centralityStudy { histos.fill(HIST("hFV0A_BCs"), multbc.multFV0A() * scale.factorFV0A); histos.fill(HIST("hFV0AT0C_BCs"), (multbc.multFV0A() + multbc.multFT0C()) * scale.factorFV0AT0C); - uint64_t bcTimestamp = multbc.timestamp(); - const float interactionRate = mRateFetcher.fetch(ccdb.service, bcTimestamp, mRunNumber, irSource.value, irCrashOnNull) / 1000.; // kHz + const uint64_t bcTimestamp = multbc.timestamp(); + const float interactionRate = mRateFetcher.fetch(ccdb.service, bcTimestamp, mRunNumber, ccdbSettings.irSource.value, ccdbSettings.irCrashOnNull) / 1000.; // kHz histos.fill(HIST("hInteractionRate_BCs"), interactionRate); if (studies.do2DPlots) {