Skip to content

Please consider the following formatting changes to #10968 #3

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

Closed
alibuild wants to merge 2 commits into from
Closed

Please consider the following formatting changes to #10968 #3

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
68481d0
[PWGDQ] Process using realigned muon track in table-maker-mc-with-assoc
ppoava Apr 24, 2025
5eff8e7
Please consider the following formatting changes
alibuild Apr 28, 2025
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
108 changes: 87 additions & 21 deletions PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,7 +16,7 @@
// The skimmed MC stack includes the MC truth particles corresponding to the list of user specified MC signals (see MCsignal.h)
// and the MC truth particles corresponding to the reconstructed tracks selected by the specified track cuts on reconstructed data.

#include <iostream>

Check failure on line 19 in PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[include-iostream] 

Do not include iostream. Use O2 logging instead.
#include <map>
#include <string>
#include <memory>
Expand Down Expand Up @@ -45,6 +45,7 @@
#include "PWGDQ/Core/MCSignalLibrary.h"
#include "Common/DataModel/PIDResponse.h"
#include "Common/DataModel/TrackSelectionTables.h"
#include "Common/DataModel/FwdTrackReAlignTables.h"
#include "Common/DataModel/CollisionAssociationTables.h"
#include "DataFormatsParameters/GRPMagField.h"
#include "DataFormatsParameters/GRPObject.h"
Expand Down Expand Up @@ -83,6 +84,7 @@
aod::McTrackLabels>;
using MyMuons = soa::Join<aod::FwdTracks, aod::McFwdTrackLabels, aod::FwdTracksDCA>;
using MyMuonsWithCov = soa::Join<aod::FwdTracks, aod::FwdTracksCov, aod::McFwdTrackLabels, aod::FwdTracksDCA>;
using MyMuonsRealignWithCov = soa::Join<aod::FwdTracksReAlign, aod::FwdTrksCovReAlign>;

using MyEvents = soa::Join<aod::Collisions, aod::EvSels, aod::McCollisionLabels>;
using MyEventsWithMults = soa::Join<aod::Collisions, aod::EvSels, aod::Mults, aod::MultsExtra, aod::McCollisionLabels>;
Expand All @@ -101,6 +103,7 @@
// constexpr static uint32_t gkTrackFillMapWithDalitzBits = gkTrackFillMap | VarManager::ObjTypes::DalitzBits;
// constexpr static uint32_t gkMuonFillMap = VarManager::ObjTypes::Muon;
constexpr static uint32_t gkMuonFillMapWithCov = VarManager::ObjTypes::Muon | VarManager::ObjTypes::MuonCov;
constexpr static uint32_t gkMuonRealignFillMapWithCov = VarManager::ObjTypes::MuonRealign | VarManager::ObjTypes::MuonCovRealign;
// constexpr static uint32_t gkMuonFillMapWithAmbi = VarManager::ObjTypes::Muon | VarManager::ObjTypes::AmbiMuon;
// constexpr static uint32_t gkMuonFillMapWithCovAmbi = VarManager::ObjTypes::Muon | VarManager::ObjTypes::MuonCov | VarManager::ObjTypes::AmbiMuon;
// constexpr static uint32_t gkTrackFillMapWithAmbi = VarManager::ObjTypes::Track | VarManager::ObjTypes::AmbiTrack;
Expand All @@ -110,7 +113,7 @@
void PrintBitMap(TMap map, int nbits)
{
for (int i = 0; i < nbits; i++) {
cout << ((map & (TMap(1) << i)) > 0 ? "1" : "0");

Check failure on line 116 in PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[logging] 

Use O2 logging (LOG, LOGF, LOGP).
}
}

Expand Down Expand Up @@ -236,8 +239,8 @@
{
// Check whether barrel or muon are enabled
bool isProcessBCenabled = context.mOptions.get<bool>("processPP");
bool isBarrelEnabled = (context.mOptions.get<bool>("processPP") || context.mOptions.get<bool>("processPPBarrelOnly") || context.mOptions.get<bool>("processPbPbBarrelOnly"));
bool isMuonEnabled = (context.mOptions.get<bool>("processPP") || context.mOptions.get<bool>("processPPMuonOnlyBasic") || context.mOptions.get<bool>("processPPMuonOnly") || context.mOptions.get<bool>("processPbPbMuonOnly"));
bool isBarrelEnabled = (context.mOptions.get<bool>("processPP") || context.mOptions.get<bool>("processPPBarrelOnly") || context.mOptions.get<bool>("processPbPbBarrelOnly") || context.mOptions.get<bool>("processPbPbWithFilterBarrelOnly"));
bool isMuonEnabled = (context.mOptions.get<bool>("processPP") || context.mOptions.get<bool>("processPPMuonOnlyBasic") || context.mOptions.get<bool>("processPPMuonOnly") || context.mOptions.get<bool>("processPPRealignedMuonOnly") || context.mOptions.get<bool>("processPbPbMuonOnly")) || context.mOptions.get<bool>("processPbPbRealignedMuonOnly"));
// Make sure at least one process function is enabled
if (!(isProcessBCenabled || isBarrelEnabled || isMuonEnabled)) {
LOG(fatal) << "No process function was enabled for TableMakerMC. Check it out!!!";
Expand Down Expand Up @@ -413,6 +416,8 @@
Preslice<aod::TrackAssoc> trackIndicesPerCollision = aod::track_association::collisionId;
Preslice<aod::FwdTrackAssoc> fwdtrackIndicesPerCollision = aod::track_association::collisionId;
Preslice<aod::MFTTrackAssoc> mfttrackIndicesPerCollision = aod::track_association::collisionId;
PresliceUnsorted<MyMuonsRealignWithCov> perCollisionMuonsRealign = aod::fwdtrackrealign::collisionId;
PresliceUnsorted<MyMuonsRealignWithCov> fwdtrackRealignPerMuon = aod::fwdtrackrealign::fwdtrackId;

void skimMCCollisions(aod::McCollisions const& mcCollisions)
{
Expand Down Expand Up @@ -469,17 +474,17 @@
/*if ((std::abs(mctrack.pdgCode())>400 && std::abs(mctrack.pdgCode())<599) ||
(std::abs(mctrack.pdgCode())>4000 && std::abs(mctrack.pdgCode())<5999) ||
(mcflags > 0)) {
cout << ">>>>>>>>>>>>>>>>>>>>>>> track idx / pdg / process / status code / HEPMC status / primary : "

Check failure on line 477 in PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[logging] 

Use O2 logging (LOG, LOGF, LOGP).
<< mctrack.globalIndex() << " / " << mctrack.pdgCode() << " / "
<< mctrack.getProcess() << " / " << mctrack.getGenStatusCode() << " / " << mctrack.getHepMCStatusCode() << " / " << mctrack.isPhysicalPrimary() << endl;
cout << ">>>>>>>>>>>>>>>>>>>>>>> track bitmap: ";

Check failure on line 480 in PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[logging] 

Use O2 logging (LOG, LOGF, LOGP).
PrintBitMap(mcflags, 16);
cout << endl;

Check failure on line 482 in PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[logging] 

Use O2 logging (LOG, LOGF, LOGP).
if (mctrack.has_mothers()) {
for (auto& m : mctrack.mothersIds()) {
if (m < mcTracks.size()) { // protect against bad mother indices
auto aMother = mcTracks.rawIteratorAt(m);
cout << "<<<<<< mother idx / pdg: " << m << " / " << aMother.pdgCode() << endl;

Check failure on line 487 in PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[logging] 

Use O2 logging (LOG, LOGF, LOGP).
}
}
}
Expand All @@ -489,7 +494,7 @@

if (d < mcTracks.size()) { // protect against bad daughter indices
auto aDaughter = mcTracks.rawIteratorAt(d);
cout << "<<<<<< daughter idx / pdg: " << d << " / " << aDaughter.pdgCode() << endl;

Check failure on line 497 in PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[logging] 

Use O2 logging (LOG, LOGF, LOGP).
}
}
}
Expand Down Expand Up @@ -864,8 +869,8 @@
}
}

template <uint32_t TMuonFillMap, uint32_t TMFTFillMap, typename TEvent, typename TMuons, typename TMFTTracks>
void skimMuons(TEvent const& collision, TMuons const& muons, FwdTrackAssoc const& muonAssocs, aod::McParticles const& mcTracks, TMFTTracks const& /*mftTracks*/)
template <uint32_t TMuonFillMap, uint32_t TMuonRealignFillMap, uint32_t TMFTFillMap, typename TEvent, typename TMuons, typename TMuonsRealign, typename TMFTTracks>
void skimMuons(TEvent const& collision, TMuons const& muons, TMuonsRealign const& muonsRealign, FwdTrackAssoc const& muonAssocs, aod::McParticles const& mcTracks, TMFTTracks const& /*mftTracks*/)
{
// Skim the fwd-tracks (muons)
// Loop over the collision-track associations, recompute track properties depending on the collision assigned, and apply track cuts for selection
Expand Down Expand Up @@ -906,7 +911,26 @@
VarManager::FillTrackCollision<TMuonFillMap>(muontrack, collision);
VarManager::FillGlobalMuonRefit<TMuonFillMap>(muontrack, mfttrack, collision);
} else {
VarManager::FillTrackCollision<TMuonFillMap>(muon, collision);
if constexpr ((static_cast<bool>(TMuonRealignFillMap)) && static_cast<int>(muon.trackType()) > 2) {
// refill kinematic info and recalculate propagation in case of using realigned muons
auto muonRealignSelected = muonsRealign.sliceBy(fwdtrackRealignPerMuon, assoc.fwdtrackId());
if (muonRealignSelected.size() == 1) {
for (const auto& muonRealign : muonRealignSelected) {
// refill muon information with realigned tracks
VarManager::FillTrack<TMuonRealignFillMap>(muonRealign);

if (fConfigVariousOptions.fPropMuon) {
VarManager::FillPropagateMuon<TMuonRealignFillMap>(muonRealign, collision);
}

VarManager::FillTrackCollision<TMuonRealignFillMap>(muonRealign, collision);
}
} else {
LOGF(fatal, "Inconsistent size of realigned muon track candidates.");
}
} else {
VarManager::FillTrackCollision<TMuonFillMap>(muon, collision);
}
}

if (fDoDetailedQA) {
Expand Down Expand Up @@ -1018,16 +1042,35 @@
VarManager::FillTrackCollision<TMuonFillMap>(muontrack, collision);
VarManager::FillGlobalMuonRefit<TMuonFillMap>(muontrack, mfttrack, collision);
} else {
VarManager::FillTrackCollision<TMuonFillMap>(muon, collision);
if constexpr ((static_cast<bool>(TMuonRealignFillMap)) && static_cast<int>(muon.trackType()) > 2) {
// refill kinematic info and recalculate propagation in case of using realigned muons
auto muonRealignSelected = muonsRealign.sliceBy(fwdtrackRealignPerMuon, muon.globalIndex());
if (muonRealignSelected.size() == 1) {
for (const auto& muonRealign : muonRealignSelected) {
// refill muon information with realigned tracks
VarManager::FillTrack<TMuonRealignFillMap>(muonRealign);

if (fConfigVariousOptions.fPropMuon) {
VarManager::FillPropagateMuon<TMuonRealignFillMap>(muonRealign, collision);
}

VarManager::FillTrackCollision<TMuonRealignFillMap>(muonRealign, collision);
}
} else {
LOGF(fatal, "Inconsistent size of realigned muon track candidates.");
}
} else {
VarManager::FillTrackCollision<TMuonFillMap>(muon, collision);
}
}
muonBasic(reducedEventIdx, mchIdx, mftIdx, fFwdTrackFilterMap[muon.globalIndex()], VarManager::fgValues[VarManager::kPt], VarManager::fgValues[VarManager::kEta], VarManager::fgValues[VarManager::kPhi], muon.sign(), 0);
muonExtra(muon.nClusters(), VarManager::fgValues[VarManager::kMuonPDca], VarManager::fgValues[VarManager::kMuonRAtAbsorberEnd],
muon.chi2(), muon.chi2MatchMCHMID(), muon.chi2MatchMCHMFT(),
VarManager::fgValues[VarManager::kMuonChi2], muon.chi2MatchMCHMID(), muon.chi2MatchMCHMFT(),
muon.matchScoreMCHMFT(),
muon.mchBitMap(), muon.midBitMap(),
muon.midBoards(), muon.trackType(), VarManager::fgValues[VarManager::kMuonDCAx], VarManager::fgValues[VarManager::kMuonDCAy],
muon.trackTime(), muon.trackTimeRes());
if constexpr (static_cast<bool>(TMuonFillMap & VarManager::ObjTypes::MuonCov)) {
if constexpr (static_cast<bool>(TMuonFillMap & VarManager::ObjTypes::MuonCov) || static_cast<bool>(TMuonRealignFillMap & VarManager::ObjTypes::MuonCovRealign)) {
muonCov(VarManager::fgValues[VarManager::kX], VarManager::fgValues[VarManager::kY], VarManager::fgValues[VarManager::kZ], VarManager::fgValues[VarManager::kPhi], VarManager::fgValues[VarManager::kTgl], muon.sign() / VarManager::fgValues[VarManager::kPt],
VarManager::fgValues[VarManager::kMuonCXX], VarManager::fgValues[VarManager::kMuonCXY], VarManager::fgValues[VarManager::kMuonCYY], VarManager::fgValues[VarManager::kMuonCPhiX], VarManager::fgValues[VarManager::kMuonCPhiY], VarManager::fgValues[VarManager::kMuonCPhiPhi],
VarManager::fgValues[VarManager::kMuonCTglX], VarManager::fgValues[VarManager::kMuonCTglY], VarManager::fgValues[VarManager::kMuonCTglPhi], VarManager::fgValues[VarManager::kMuonCTglTgl], VarManager::fgValues[VarManager::kMuonC1Pt2X], VarManager::fgValues[VarManager::kMuonC1Pt2Y],
Expand All @@ -1042,10 +1085,10 @@
} // end loop over selected muons
} // end skimMuons

template <uint32_t TEventFillMap, uint32_t TTrackFillMap, uint32_t TMuonFillMap, uint32_t TMFTFillMap, typename TEvents, typename TTracks,
typename TMuons, typename TMFTTracks, typename TTrackAssoc, typename TFwdTrackAssoc, typename TMFTTrackAssoc>
template <uint32_t TEventFillMap, uint32_t TTrackFillMap, uint32_t TMuonFillMap, uint32_t TMuonRealignFillMap, uint32_t TMFTFillMap, typename TEvents, typename TTracks,
typename TMuons, typename TMuonsRealign, typename TMFTTracks, typename TTrackAssoc, typename TFwdTrackAssoc, typename TMFTTrackAssoc>
void fullSkimming(TEvents const& collisions, BCsWithTimestamps const& bcs,
TTracks const& tracksBarrel, TMuons const& muons, TMFTTracks const& mftTracks,
TTracks const& tracksBarrel, TMuons const& muons, TMuonsRealign const& muonsRealign, TMFTTracks const& mftTracks,
TTrackAssoc const& trackAssocs, TFwdTrackAssoc const& fwdTrackAssocs, TMFTTrackAssoc const& mftAssocs,
aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
{
Expand Down Expand Up @@ -1145,10 +1188,15 @@
if (fConfigVariousOptions.fKeepBestMatch) {
skimBestMuonMatches(muons);
}
skimMuons<TMuonFillMap, TMFTFillMap>(collision, muons, groupedMuonIndices, mcParticles, mftTracks);
skimMuons<TMuonFillMap, 0u, TMFTFillMap>(collision, muons, nullptr, groupedMuonIndices, mcParticles, mftTracks);
} else {
auto groupedMuonIndices = fwdTrackAssocs.sliceBy(fwdtrackIndicesPerCollision, origIdx);
skimMuons<TMuonFillMap, 0u>(collision, muons, groupedMuonIndices, mcParticles, nullptr);
if constexpr (static_cast<bool>(TMuonRealignFillMap)) {
auto groupedMuonIndices = fwdTrackAssocs.sliceBy(fwdtrackIndicesPerCollision, origIdx);
skimMuons<TMuonFillMap, 0u, 0u>(collision, muons, nullptr, groupedMuonIndices, mcParticles, nullptr);
} else {
auto groupedMuonIndices = fwdTrackAssocs.sliceBy(fwdtrackIndicesPerCollision, origIdx);
skimMuons<TMuonFillMap, TMuonRealignFillMap, 0u>(collision, muons, muonsRealign, groupedMuonIndices, mcParticles, nullptr);
}
}
}
} // end loop over skimmed collisions
Expand All @@ -1167,8 +1215,8 @@
mothers.push_back(fLabelsMap.find(m)->second);
}
} else {
cout << "Mother label (" << m << ") exceeds the McParticles size (" << mcParticles.size() << ")" << endl;

Check failure on line 1218 in PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[logging] 

Use O2 logging (LOG, LOGF, LOGP).
cout << " Check the MC generator" << endl;

Check failure on line 1219 in PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[logging] 

Use O2 logging (LOG, LOGF, LOGP).
}
}
}
Expand Down Expand Up @@ -1214,7 +1262,7 @@
void DefineHistograms(TString histClasses)
{
std::unique_ptr<TObjArray> objArray(histClasses.Tokenize(";"));
for (Int_t iclass = 0; iclass < objArray->GetEntries(); ++iclass) {

Check failure on line 1265 in PWGDQ/TableProducer/tableMakerMC_withAssoc.cxx

View workflow job for this annotation

GitHub Actions / O2 linter

[root/entity] 

Replace ROOT entities with equivalents from standard C++ or from O2.
TString classStr = objArray->At(iclass)->GetName();
if (fConfigHistOutput.fConfigQA) {
fHistMan->AddHistClass(classStr.Data());
Expand Down Expand Up @@ -1297,53 +1345,69 @@
aod::TrackAssoc const& trackAssocs, aod::FwdTrackAssoc const& fwdTrackAssocs, aod::MFTTrackAssoc const& mftAssocs,
aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
{
fullSkimming<gkEventFillMapWithMults, gkTrackFillMapWithCov, gkMuonFillMapWithCov, gkMFTFillMap>(collisions, bcs, tracksBarrel, tracksMuon, mftTracks, trackAssocs, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
fullSkimming<gkEventFillMapWithMults, gkTrackFillMapWithCov, gkMuonFillMapWithCov, 0u, gkMFTFillMap>(collisions, bcs, tracksBarrel, tracksMuon, nullptr, mftTracks, trackAssocs, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
}

void processPPBarrelOnly(MyEventsWithMults const& collisions, aod::BCsWithTimestamps const& bcs,
MyBarrelTracksWithCov const& tracksBarrel, aod::TrackAssoc const& trackAssocs,
aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
{
fullSkimming<gkEventFillMapWithMults, gkTrackFillMapWithCov, 0u, 0u>(collisions, bcs, tracksBarrel, nullptr, nullptr, trackAssocs, nullptr, nullptr, mcCollisions, mcParticles);
fullSkimming<gkEventFillMapWithMults, gkTrackFillMapWithCov, 0u, 0u, 0u>(collisions, bcs, tracksBarrel, nullptr, nullptr, nullptr, trackAssocs, nullptr, nullptr, mcCollisions, mcParticles);
}

void processPPMuonOnlyBasic(MyEvents const& collisions, aod::BCsWithTimestamps const& bcs,
MyMuonsWithCov const& tracksMuon, MFTTrackLabeled const& mftTracks,
aod::FwdTrackAssoc const& fwdTrackAssocs, aod::MFTTrackAssoc const& mftAssocs,
aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
{
fullSkimming<gkEventFillMap, 0u, gkMuonFillMapWithCov, gkMFTFillMap>(collisions, bcs, nullptr, tracksMuon, mftTracks, nullptr, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
fullSkimming<gkEventFillMap, 0u, gkMuonFillMapWithCov, 0u, gkMFTFillMap>(collisions, bcs, nullptr, tracksMuon, nullptr, mftTracks, nullptr, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
}

void processPPMuonOnly(MyEventsWithMults const& collisions, aod::BCsWithTimestamps const& bcs,
MyMuonsWithCov const& tracksMuon, MFTTrackLabeled const& mftTracks,
aod::FwdTrackAssoc const& fwdTrackAssocs, aod::MFTTrackAssoc const& mftAssocs,
aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
{
fullSkimming<gkEventFillMapWithMults, 0u, gkMuonFillMapWithCov, gkMFTFillMap>(collisions, bcs, nullptr, tracksMuon, mftTracks, nullptr, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
fullSkimming<gkEventFillMapWithMults, 0u, gkMuonFillMapWithCov, 0u, gkMFTFillMap>(collisions, bcs, nullptr, tracksMuon, nullptr, mftTracks, nullptr, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
}

void processPPRealignedMuonOnly(MyEventsWithMults const& collisions, aod::BCsWithTimestamps const& bcs,
MyMuonsWithCov const& tracksMuon, MyMuonsRealignWithCov const& muonsRealign, MFTTrackLabeled const& mftTracks,
aod::FwdTrackAssoc const& fwdTrackAssocs, aod::MFTTrackAssoc const& mftAssocs,
aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
{
fullSkimming<gkEventFillMapWithMults, 0u, gkMuonFillMapWithCov, 0u, gkMFTFillMap>(collisions, bcs, nullptr, tracksMuon, nullptr, mftTracks, nullptr, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
}

void processPbPb(MyEventsWithCentAndMults const& collisions, aod::BCsWithTimestamps const& bcs,
MyBarrelTracksWithCov const& tracksBarrel, MyMuonsWithCov const& tracksMuon, MFTTrackLabeled const& mftTracks,
aod::TrackAssoc const& trackAssocs, aod::FwdTrackAssoc const& fwdTrackAssocs, aod::MFTTrackAssoc const& mftAssocs,
aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
{
fullSkimming<gkEventFillMapWithCentAndMults, gkTrackFillMapWithCov, gkMuonFillMapWithCov, gkMFTFillMap>(collisions, bcs, tracksBarrel, tracksMuon, mftTracks, trackAssocs, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
fullSkimming<gkEventFillMapWithCentAndMults, gkTrackFillMapWithCov, gkMuonFillMapWithCov, 0u, gkMFTFillMap>(collisions, bcs, tracksBarrel, tracksMuon, nullptr, mftTracks, trackAssocs, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
}

void processPbPbBarrelOnly(MyEventsWithCentAndMults const& collisions, aod::BCsWithTimestamps const& bcs,
MyBarrelTracksWithCov const& tracksBarrel, aod::TrackAssoc const& trackAssocs,
aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
{
fullSkimming<gkEventFillMapWithCentAndMults, gkTrackFillMapWithCov, 0u, 0u>(collisions, bcs, tracksBarrel, nullptr, nullptr, trackAssocs, nullptr, nullptr, mcCollisions, mcParticles);
fullSkimming<gkEventFillMapWithCentAndMults, gkTrackFillMapWithCov, 0u, 0u, 0u>(collisions, bcs, tracksBarrel, nullptr, nullptr, nullptr, trackAssocs, nullptr, nullptr, mcCollisions, mcParticles);
}

void processPbPbMuonOnly(MyEventsWithCentAndMults const& collisions, aod::BCsWithTimestamps const& bcs,
MyMuonsWithCov const& tracksMuon, MFTTrackLabeled const& mftTracks,
aod::FwdTrackAssoc const& fwdTrackAssocs, aod::MFTTrackAssoc const& mftAssocs,
aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
{
fullSkimming<gkEventFillMapWithCentAndMults, 0u, gkMuonFillMapWithCov, gkMFTFillMap>(collisions, bcs, nullptr, tracksMuon, mftTracks, nullptr, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
fullSkimming<gkEventFillMapWithCentAndMults, 0u, gkMuonFillMapWithCov, 0u, gkMFTFillMap>(collisions, bcs, nullptr, tracksMuon, nullptr, mftTracks, nullptr, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
}

void processPbPbRealignedMuonOnly(MyEventsWithCentAndMults const& collisions, aod::BCsWithTimestamps const& bcs,
MyMuonsWithCov const& tracksMuon, MyMuonsRealignWithCov const& muonsRealign, MFTTrackLabeled const& mftTracks,
aod::FwdTrackAssoc const& fwdTrackAssocs, aod::MFTTrackAssoc const& mftAssocs,
aod::McCollisions const& mcCollisions, aod::McParticles const& mcParticles)
{
fullSkimming<gkEventFillMapWithCentAndMults, 0u, gkMuonFillMapWithCov, 0u, gkMFTFillMap>(collisions, bcs, nullptr, tracksMuon, nullptr, mftTracks, nullptr, fwdTrackAssocs, mftAssocs, mcCollisions, mcParticles);
}

// Process the BCs and store stats for luminosity retrieval -----------------------------------------------------------------------------------
Expand All @@ -1361,9 +1425,11 @@
PROCESS_SWITCH(TableMakerMC, processPPBarrelOnly, "Produce only barrel skims, pp settings ", false);
PROCESS_SWITCH(TableMakerMC, processPPMuonOnlyBasic, "Produce only muon skims, pp settings, no multiplicity", false);
PROCESS_SWITCH(TableMakerMC, processPPMuonOnly, "Produce only muon skims, pp settings", false);
PROCESS_SWITCH(TableMakerMC, processPPRealignedMuonOnly, "Build realigned muon only DQ skimmed data model typically for pp/p-Pb and UPC Pb-Pb", false);
PROCESS_SWITCH(TableMakerMC, processPbPb, "Produce both barrel and muon skims, PbPb settings", false);
PROCESS_SWITCH(TableMakerMC, processPbPbBarrelOnly, "Produce only barrel skims, PbPb settings", false);
PROCESS_SWITCH(TableMakerMC, processPbPbMuonOnly, "Produce only muon skims, PbPb settings", false);
PROCESS_SWITCH(TableMakerMC, processPbPbRealignedMuonOnly, "Build realigned muon only DQ skimmed data model typically for Pb-Pb, w/o event filtering", false);
PROCESS_SWITCH(TableMakerMC, processOnlyBCs, "Analyze the BCs to store sampled lumi", false);
};

Expand Down
Loading