Skip to content

[PWGHF] taskFlow.cxx : solve Monte Carlo Generated to be able to calculate efficiencies #16767

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
apalasciano merged 15 commits into from
Jun 22, 2026
+65 −70
Merged

[PWGHF] taskFlow.cxx : solve Monte Carlo Generated to be able to calculate efficiencies #16767

Changes from all commits
Commits
Show all changes
15 commits
Select commit Hold shift + click to select a range
d90806b
correct FT0 gain eq, add MFT qa plot
AlexianL May 5, 2026
ec908ed
add possibility of eta-dependent flow
AlexianL May 5, 2026
91fc1ab
change default value
AlexianL May 6, 2026
6f2e8b7
add variations in container
AlexianL May 29, 2026
42eddec
comment function that is not used yet
AlexianL May 30, 2026
ff661ab
add possibility to estimate multiplicity by counting tracks-> validat…
AlexianL Jun 8, 2026
66b4480
MC working
AlexianL Jun 9, 2026
1867445
MC good, add efficiency corrections for tracks
AlexianL Jun 10, 2026
c06b9b2
MC good, add efficiency corrections for tracks
AlexianL Jun 10, 2026
6cdceb3
solve issue with abs(), add std::abs()
AlexianL Jun 10, 2026
ffb1d58
correct some code in the efficiency correction
AlexianL Jun 11, 2026
b5c6881
change axis for hEfficiency
AlexianL Jun 12, 2026
12ac3bb
solved multiplicity issues
AlexianL Jun 14, 2026
8cd2e3e
solve McGen for efficiencies
AlexianL Jun 22, 2026
7069879
Merge branch 'master' into changes_taskFlow
AlexianL Jun 22, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
135 changes: 65 additions & 70 deletions PWGHF/HFC/Tasks/taskFlow.cxx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -225,6 +225,7 @@ struct HfTaskFlow {
Configurable<int> nSamples{"nSamples", 10, "number of different samples for correlations"};
Configurable<std::string> nameCorrelationContainer{"nameCorrelationContainer", "", "Add the possibility to the rename the correlation container as configurable"};
Configurable<bool> useEfficiencyCorrection{"useEfficiencyCorrection", false, "Choose to use or not use efficiency correction, if not used, weight is set to 1"};
Configurable<bool> useOnlyPrimaryInMc{"useOnlyPrimaryInMc", false, "Choose to use or not use only primaries for McGen"};
} configTask;

// configurables for collisions
Expand Down Expand Up @@ -318,10 +319,10 @@ struct HfTaskFlow {
Service<o2::framework::O2DatabasePDG> pdg{};
Service<o2::ccdb::BasicCCDBManager> ccdb{};
std::vector<o2::detectors::AlignParam>* offsetFT0{};
std::vector<o2::detectors::AlignParam>* offsetFV0{};
// std::vector<o2::detectors::AlignParam>* offsetFV0{};
o2::ccdb::CcdbApi ccdbApi;
o2::ft0::Geometry ft0Det;
o2::fv0::Geometry* fv0Det{};
// o2::fv0::Geometry* fv0Det{};
std::vector<float> cstFT0RelGain{};
RCTFlagsChecker rctChecker;
RCTFlagsChecker correlationAnalysisRctChecker{kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad, kITSLimAccMCRepr, kMFTLimAccMCRepr, kTPCLimAccMCRepr};
Expand Down Expand Up @@ -349,6 +350,8 @@ struct HfTaskFlow {
// =========================

using SmallGroupMcCollisions = soa::SmallGroups<soa::Join<aod::McCollisionLabels, aod::Collisions, aod::EvSel, aod::CentFT0Cs, aod::CentFT0CVariant1s, aod::CentFT0Ms, aod::CentFV0As, aod::Mults>>;
using FilteredMcCollisionsWMult = soa::Filtered<soa::Join<aod::McCollisions, aod::MultMCExtras>>;
using FilteredMcParticles = soa::Filtered<aod::McParticles>;

// =========================
// Filters & partitions : DATA
Expand Down Expand Up @@ -383,11 +386,19 @@ struct HfTaskFlow {

Filter mftTrackEtaFilter = ((aod::fwdtrack::eta < configMft.etaMftTrackMaxFilter) && (aod::fwdtrack::eta > configMft.etaMftTrackMinFilter));

// Filters below will be used for uncertainties
Filter mftTrackCollisionIdFilter = (aod::fwdtrack::bestCollisionId >= 0);
// Filter mftTrackDcaXYFilter = (nabs(aod::fwdtrack::bestDCAXY) < configMft.mftMaxDCAxy);
// Filter mftTrackDcaZFilter = (nabs(aod::fwdtrack::bestDCAZ) < configMft.mftMaxDCAz);

// =========================
// Filters & partitions : MC
// =========================

Filter mcParticleFilter = (((aod::mcparticle::eta > configTask.etaMcParticlesTriggerMin) && (aod::mcparticle::eta < configTask.etaMcParticlesTriggerMax)) || ((aod::mcparticle::eta > configTask.etaMcParticlesAssocMin) && (aod::mcparticle::eta < configTask.etaMcParticlesAssocMax)) || (nabs(aod::mcparticle::eta) < configCentral.etaCentralTrackMax)) && (aod::mcparticle::pt > configTask.ptMcParticlesTriggerMin) && (aod::mcparticle::pt < configTask.ptMcParticlesTriggerMax);

// Filter for MCcollisions
Filter mcCollisionFilter = nabs(aod::mccollision::posZ) < configCollision.zVertexMax;

// =========================
// Preslice : DATA
// =========================
Expand All @@ -396,7 +407,7 @@ struct HfTaskFlow {
Preslice<HfCandidatesSelLc> perColLcs = aod::track::collisionId;
Preslice<FilteredMftTracks> perColMftTracks = o2::aod::fwdtrack::collisionId;
Preslice<FilteredTracksWDcaSel> perColTracks = aod::track::collisionId;
Preslice<aod::McParticles> perMcColMcParticles = aod::mcparticle::mcCollisionId;
// Preslice<aod::McParticles> perMcColMcParticles = aod::mcparticle::mcCollisionId;

PresliceUnsorted<soa::SmallGroups<aod::BestCollisionsFwd>> perColReassociated2dTracks = o2::aod::fwdtrack::collisionId;
PresliceUnsorted<soa::SmallGroups<aod::BestCollisionsFwd3d>> perColReassociated3dTracks = o2::aod::fwdtrack::collisionId;
Expand Down Expand Up @@ -524,12 +535,12 @@ struct HfTaskFlow {
ccdb->setCreatedNotAfter(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
LOGF(info, "Getting alignment offsets from the CCDB...");
offsetFT0 = ccdb->getForTimeStamp<std::vector<o2::detectors::AlignParam>>("FT0/Calib/Align", configCcdb.noLaterThan.value);
offsetFV0 = ccdb->getForTimeStamp<std::vector<o2::detectors::AlignParam>>("FV0/Calib/Align", configCcdb.noLaterThan.value);
// offsetFV0 = ccdb->getForTimeStamp<std::vector<o2::detectors::AlignParam>>("FV0/Calib/Align", configCcdb.noLaterThan.value);
LOGF(info, "Offset for FT0A: x = %.3f y = %.3f z = %.3f\n", (*offsetFT0)[0].getX(), (*offsetFT0)[0].getY(), (*offsetFT0)[0].getZ());
LOGF(info, "Offset for FT0C: x = %.3f y = %.3f z = %.3f\n", (*offsetFT0)[1].getX(), (*offsetFT0)[1].getY(), (*offsetFT0)[1].getZ());
LOGF(info, "Offset for FV0-left: x = %.3f y = %.3f z = %.3f\n", (*offsetFV0)[0].getX(), (*offsetFV0)[0].getY(), (*offsetFV0)[0].getZ());
LOGF(info, "Offset for FV0-right: x = %.3f y = %.3f z = %.3f\n", (*offsetFV0)[1].getX(), (*offsetFV0)[1].getY(), (*offsetFV0)[1].getZ());
fv0Det = o2::fv0::Geometry::instance(o2::fv0::Geometry::eUninitialized);
// LOGF(info, "Offset for FV0-left: x = %.3f y = %.3f z = %.3f\n", (*offsetFV0)[0].getX(), (*offsetFV0)[0].getY(), (*offsetFV0)[0].getZ());
// LOGF(info, "Offset for FV0-right: x = %.3f y = %.3f z = %.3f\n", (*offsetFV0)[1].getX(), (*offsetFV0)[1].getY(), (*offsetFV0)[1].getZ());
// fv0Det = o2::fv0::Geometry::instance(o2::fv0::Geometry::eUninitialized);

// =========================
// Event histograms
Expand Down Expand Up @@ -650,6 +661,9 @@ struct HfTaskFlow {
registry.add("Data/hEfficiencyTrigger", "", {HistType::kTH3D, {{configAxis.axisPtTrigger}, {configAxis.axisEtaTrigger}, {configAxis.axisVertex}}});
registry.add("Data/hEfficiencyAssociated", "", {HistType::kTH3D, {{configAxis.axisPtAssoc}, {configAxis.axisEtaAssociated}, {configAxis.axisVertex}}});

registry.add("Data/hMultiplicity_uncorrected", "", {HistType::kTH1D, {configAxis.axisMultiplicity}});
registry.add("Data/hMultiplicity_corrected", "", {HistType::kTH1D, {configAxis.axisMultiplicity}});

if (!configTask.doEtaDependentFlow && !configTask.doVariationContainers) {
registry.add("Trig_hist_TPC_MFT", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisPtTrigger}}});
sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {}));
Expand Down Expand Up @@ -852,7 +866,7 @@ struct HfTaskFlow {
sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, {}));
mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, {}));
} else if (configTask.doEtaDependentFlow) {
registry.add("Trig_hist_FT0A_FT0C ", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}});
registry.add("Trig_hist_FT0A_FT0C", "", {HistType::kTHnSparseF, {{configAxis.axisSamples, configAxis.axisVertex, configAxis.axisEtaTrigger}}});
sameEvent.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxisEta, effAxis, {}));
mixedEvent.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxisEta, effAxis, {}));
} else {
Expand Down Expand Up @@ -881,6 +895,8 @@ struct HfTaskFlow {
addHistograms<Mc, MftFv0a, ChPartChPart>();
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::TpcFt0a)) {
addHistograms<Mc, TpcFt0a, ChPartChPart>();
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::MftFt0a)) {
addHistograms<Mc, MftFt0a, ChPartChPart>();
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::TpcFt0c)) {
addHistograms<Mc, TpcFt0c, ChPartChPart>();
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::Ft0aFt0c)) {
Expand Down Expand Up @@ -1216,9 +1232,6 @@ struct HfTaskFlow {
trackCounter += 1;
}

// if (!getEfficiencyCorrection_Nch(weight_Nch, track.pt())) {
// continue;
// }
auto efficiencyNch = 1.0f;
if (configTask.useEfficiencyCorrection) {

Expand All @@ -1241,24 +1254,6 @@ struct HfTaskFlow {
return trackCounter;
}

// bool getEfficiencyCorrectionNch(float& weightNch, float pt)
// {
// float efficiencyNch = 1.;

// if (mEfficiencyNch) {
// int ptBin = mEfficiencyNch->FindBin(pt);
// efficiencyNch = mEfficiencyNch->GetBinContent(ptBin);
// }

// if (efficiencyNch == 0 ) {
// return false;
// }

// weightNch = 1. / efficiencyNch;

// return true;
// }

// =========================
// Cuts with functions
// =========================
Expand Down Expand Up @@ -2380,8 +2375,8 @@ struct HfTaskFlow {
TTracksTrig const& tracks1, TTracksAssoc const& tracks2,
float multiplicity, float posZ, bool sameEvent)
{
auto triggerWeight = 1;
auto associatedWeight = 1;
auto triggerWeight = 1.0f;
auto associatedWeight = 1.0f;
auto loopCounter = 0; // To avoid filling associated tracks QA many times, I fill it only for the first trigger track of the collision
int sampleIndex = gRandom->Uniform(0, configTask.nSamples);
bool fillQaPlots = false;
Expand All @@ -2405,7 +2400,7 @@ struct HfTaskFlow {
if (track1.pt() < configTask.ptMcParticlesTriggerMin || track1.pt() > configTask.ptMcParticlesTriggerMax) {
continue;
}
if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track1.isPhysicalPrimary()) {
if (configTask.useOnlyPrimaryInMc && !track1.isPhysicalPrimary()) {
continue;
}

Expand All @@ -2431,6 +2426,8 @@ struct HfTaskFlow {
fillTriggerQa<Mc, MftFv0a, ChPartChPart>(multiplicity, track1.eta(), track1.phi(), track1.pt());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::TpcFt0a)) {
fillTriggerQa<Mc, TpcFt0a, ChPartChPart>(multiplicity, track1.eta(), track1.phi(), track1.pt());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::MftFt0a)) {
fillTriggerQa<Mc, MftFt0a, ChPartChPart>(multiplicity, track1.eta(), track1.phi(), track1.pt());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::TpcFt0c)) {
fillTriggerQa<Mc, TpcFt0c, ChPartChPart>(multiplicity, track1.eta(), track1.phi(), track1.pt());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::Ft0aFt0c)) {
Expand All @@ -2449,7 +2446,7 @@ struct HfTaskFlow {
if (track2.pt() < configTask.ptMcParticlesAssocMin || track2.pt() > configTask.ptMcParticlesAssocMax) {
continue;
}
if (step >= CorrelationContainer::kCFStepTrackedOnlyPrim && !track2.isPhysicalPrimary()) {
if (configTask.useOnlyPrimaryInMc && !track2.isPhysicalPrimary()) {
continue;
}

Expand All @@ -2471,19 +2468,21 @@ struct HfTaskFlow {
if (sameEvent && fillQaPlots && (loopCounter == 1)) {
registry.fill(HIST("MC/hEfficiencyAssociated"), track2.pt(), track2.eta(), posZ);
if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::TpcTpc)) {
fillAssociatedQa<Mc, TpcTpc, ChPartChPart>(track2.eta(), track2.phi(), track2.pt());
fillAssociatedQa<Mc, TpcTpc, ChPartChPart>(multiplicity, track2.eta(), track2.phi());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::TpcMft)) {
fillAssociatedQa<Mc, TpcMft, ChPartChPart>(track2.eta(), track2.phi(), track2.pt());
fillAssociatedQa<Mc, TpcMft, ChPartChPart>(multiplicity, track2.eta(), track2.phi());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::TpcFv0a)) {
fillAssociatedQa<Mc, TpcFv0a, ChPartChPart>(track2.eta(), track2.phi(), track2.pt());
fillAssociatedQa<Mc, TpcFv0a, ChPartChPart>(multiplicity, track2.eta(), track2.phi());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::MftFv0a)) {
fillAssociatedQa<Mc, MftFv0a, ChPartChPart>(track2.eta(), track2.phi(), track2.pt());
fillAssociatedQa<Mc, MftFv0a, ChPartChPart>(multiplicity, track2.eta(), track2.phi());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::TpcFt0a)) {
fillAssociatedQa<Mc, TpcFt0a, ChPartChPart>(track2.eta(), track2.phi(), track2.pt());
fillAssociatedQa<Mc, TpcFt0a, ChPartChPart>(multiplicity, track2.eta(), track2.phi());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::MftFt0a)) {
fillAssociatedQa<Mc, MftFt0a, ChPartChPart>(multiplicity, track2.eta(), track2.phi());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::TpcFt0c)) {
fillAssociatedQa<Mc, TpcFt0c, ChPartChPart>(track2.eta(), track2.phi(), track2.pt());
fillAssociatedQa<Mc, TpcFt0c, ChPartChPart>(multiplicity, track2.eta(), track2.phi());
} else if (configTask.chooseCorrelationCase.value == static_cast<int>(CorrelationCase::Ft0aFt0c)) {
fillAssociatedQa<Mc, Ft0aFt0c, ChPartChPart>(track2.eta(), track2.phi(), track2.pt());
fillAssociatedQa<Mc, Ft0aFt0c, ChPartChPart>(multiplicity, track2.eta(), track2.phi());
}
} // end of fill QA
} // end of loop over track2
Expand Down Expand Up @@ -3020,6 +3019,12 @@ struct HfTaskFlow {
multiplicity = getMultiplicityEstimator(collision, true);
}

registry.fill(HIST("Data/hMultiplicity_uncorrected"), multiplicity);
if (configCollision.useMultiplicityFromTracksCorrected) {
multiplicity = getCorrectedMultiplicity(tracks);
registry.fill(HIST("Data/hMultiplicity_corrected"), multiplicity);
}

if (multiplicity < configCollision.minMultiplicity || multiplicity >= configCollision.maxMultiplicity) {
return;
}
Expand Down Expand Up @@ -3809,14 +3814,10 @@ struct HfTaskFlow {
// MONTE-CARLO
// ===================================================================================================================================================================================================================================================================

void processSameMcGen(soa::Join<aod::McCollisions, aod::MultMCExtras>::iterator const& mcCollision,
aod::McParticles const& mcParticles,
void processSameMcGen(FilteredMcCollisionsWMult::iterator const& mcCollision,
FilteredMcParticles const& mcParticles,
SmallGroupMcCollisions const& collisions)
{
if (!(std::abs(mcCollision.posZ()) <= configCollision.zVertexMax)) {
return;
}

auto multiplicity = 0;
if (configCollision.useMultiplicityFromTracks) {
for (const auto& track : mcParticles) {
Expand All @@ -3832,15 +3833,12 @@ struct HfTaskFlow {
return;
}

sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll);
fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, multiplicity, mcCollision.posZ(), true);

if (collisions.size() == 0) {
return;
}

sameEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim);
fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, multiplicity, mcCollision.posZ(), true);
sameEvent->fillEvent(multiplicity, CorrelationContainer::kCFStepAll);
fillCorrelationsMonteCarlo(sameEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, multiplicity, mcCollision.posZ(), true);
}
PROCESS_SWITCH(HfTaskFlow, processSameMcGen, "MC Gen : Process same-event correlations", false);

Expand Down Expand Up @@ -4205,15 +4203,10 @@ struct HfTaskFlow {
// MONTE-CARLO
// ===================================================================================================================================================================================================================================================================

void processMixedMcGen(soa::Join<aod::McCollisions, aod::MultMCExtras> const& mcCollisions,
aod::McParticles const& mcParticles,
void processMixedMcGen(FilteredMcCollisionsWMult const& mcCollisions,
FilteredMcParticles const& mcParticles,
SmallGroupMcCollisions const& collisions)
{
// auto getTracksSize = [&mcParticles, this](aod::McCollisions::iterator const& mcCollision) {
// auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache);
// auto multiplicity = associatedTracks.size();
// return multiplicity;
// };

auto getTracksSize = [&mcParticles, this](soa::Join<aod::McCollisions, aod::MultMCExtras>::iterator const& mcCollision) {
auto associatedTracks = mcParticles.sliceByCached(o2::aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), this->cache);
Expand All @@ -4233,10 +4226,12 @@ struct HfTaskFlow {
using MixedBinning = FlexibleBinningPolicy<std::tuple<decltype(getTracksSize)>, aod::mccollision::PosZ, decltype(getTracksSize)>;
MixedBinning const binningOnVtxAndMult{{getTracksSize}, {configAxis.binsMixingVertex, configAxis.binsMixingMultiplicity}, true};

for (auto const& [collision1, collision2] : soa::selfCombinations(binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, mcCollisions)) {
auto tracksTuple = std::make_tuple(mcParticles, mcParticles);

Pair<FilteredMcCollisionsWMult, FilteredMcParticles, FilteredMcParticles, MixedBinning> pairs{binningOnVtxAndMult, configTask.nMixedEvents, -1, mcCollisions, tracksTuple, &cache}; // -1 is the number of the bin to skip

auto tracks1 = mcParticles.sliceBy(perMcColMcParticles, collision1.globalIndex());
auto tracks2 = mcParticles.sliceBy(perMcColMcParticles, collision2.globalIndex());
for (auto it = pairs.begin(); it != pairs.end(); it++) {
auto& [collision1, tracks1, collision2, tracks2] = *it;

auto multiplicityCollision1 = 0;
auto multiplicityCollision2 = 0;
Expand Down Expand Up @@ -4264,17 +4259,17 @@ struct HfTaskFlow {
continue;
}

auto groupedCollisions = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex());

mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepAll);
fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepAll, mcParticles, mcParticles, multiplicityCollision1, collision1.posZ(), false);

if (groupedCollisions.size() == 0) {
auto groupedCollisions1 = collisions.sliceBy(collisionPerMcCollision, collision1.globalIndex());
auto groupedCollisions2 = collisions.sliceBy(collisionPerMcCollision, collision2.globalIndex());
if (groupedCollisions1.size() == 0) {
return;
}
if (groupedCollisions2.size() == 0) {
return;
}

mixedEvent->fillEvent(mcParticles.size(), CorrelationContainer::kCFStepTrackedOnlyPrim);
fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepTrackedOnlyPrim, mcParticles, mcParticles, multiplicityCollision1, collision1.posZ(), false);
mixedEvent->fillEvent(multiplicityCollision1, CorrelationContainer::kCFStepAll);
fillCorrelationsMonteCarlo(mixedEvent, CorrelationContainer::CFStep::kCFStepAll, tracks1, tracks2, multiplicityCollision1, collision1.posZ(), false);
}
}
PROCESS_SWITCH(HfTaskFlow, processMixedMcGen, "MC Gen : Process mixed-event correlations", false);
Expand Down
Loading