Skip to content

Commit 72527fb

Browse files
authored
[PWGUD] Added flags and occupancy in MC table (#18760)
1 parent 7e8b4a9 commit 72527fb

1 file changed

Lines changed: 111 additions & 113 deletions

File tree

‎PWGUD/TableProducer/upcCandProducerBarrel.cxx‎

Lines changed: 111 additions & 113 deletions
Original file line numberDiff line numberDiff line change
@@ -209,6 +209,8 @@ DECLARE_SOA_TABLE(UPCBarrelCands, "AOD", "UPCBARRELCANDS",
209209
DECLARE_SOA_TABLE(UPCBarrelMcColls, "AOD", "UPCBMCCOLL",
210210
upc_cand_prod_bar::TfId,
211211
upc_cand_prod_bar::GlobalBC,
212+
upc_cand_prod_bar::Flags,
213+
upc_cand_prod_bar::OccupancyFT0C,
212214
upc_cand_prod_bar::PosX,
213215
upc_cand_prod_bar::PosY,
214216
upc_cand_prod_bar::PosZ,
@@ -343,8 +345,6 @@ struct UpcCandProducerBarrel {
343345
registry.add("hTF", "TF counts", HistType::kTH1D, {axisTFs});
344346
registry.add("hTVX", "TVX counts", HistType::kTH2D, {axisBCs, axisTFs});
345347
registry.add("hTVXRCT", "TVX counts after RCT selection", HistType::kTH2D, {axisBCs, axisTFs});
346-
registry.add("hTVXupc", "TVX counts in upc ROFs", HistType::kTH2D, {axisBCs, axisTFs});
347-
registry.add("hTVXRCTupc", "TVX counts after RCT selection in upc ROFs", HistType::kTH2D, {axisBCs, axisTFs});
348348

349349
registry.add("hVetoT00", "no RCT selection", HistType::kTH3D, {axisBCs, axisTFs, axisVeto});
350350
registry.add("hVetoTV0", "no RCT selection", HistType::kTH3D, {axisBCs, axisTFs, axisVeto});
@@ -429,81 +429,37 @@ struct UpcCandProducerBarrel {
429429
}
430430
LOGP(info, "Starting new DF. Number of TFs = {}", tfIDs.size());
431431

432-
std::unordered_map<int64_t, SignalRef> signalParticleRefs;
433-
if constexpr (isMC) {
434-
std::unordered_set<int64_t> ambiguousTrackIds;
435-
ambiguousTrackIds.reserve(ambiguousTracks->size());
436-
for (const auto& ambiguousTrack : *ambiguousTracks) {
437-
ambiguousTrackIds.insert(ambiguousTrack.trackId());
438-
}
432+
std::vector<int64_t> bcsWithFT0, bcsWithFV0, bcsWithFDD;
433+
bcsWithFT0.reserve(ft0s.size());
434+
bcsWithFV0.reserve(fv0s.size());
435+
bcsWithFDD.reserve(fdds.size());
439436

440-
std::vector<int64_t> bcsWithMCCollision;
441-
bcsWithMCCollision.reserve(mcCollisions->size());
442-
// Use collisions from every source and retain same-BC pile-up
443-
for (const auto& mcCollision : *mcCollisions) {
444-
bcsWithMCCollision.push_back(static_cast<int64_t>(mcCollision.template bc_as<BCsWithSels>().globalBC()));
437+
LOGP(debug, "Filling FT0 activity arrays");
438+
for (const auto& ft0 : ft0s) {
439+
const float sumAmpFT0A = ft0.sumAmpA();
440+
const float sumAmpFT0C = ft0.sumAmpC();
441+
if ((ft0.timeA() < MaxFITTime && sumAmpFT0A >= minAmpFT0A) || (ft0.timeC() < MaxFITTime && sumAmpFT0C >= minAmpFT0C)) {
442+
bcsWithFT0.push_back(ft0.bc_as<BCsWithSels>().globalBC());
445443
}
446-
const auto minDistanceMC = buildMinimumDistanceMap(tfIDs, bcSOR, nBCsPerTF, bcsWithMCCollision, maxStoredDistance, true);
447-
448-
for (const auto& mcCollision : *mcCollisions) {
449-
const auto bc = mcCollision.template bc_as<BCsWithSels>();
450-
const auto globalBC = bc.globalBC();
451-
const auto iTF = localTFIndex[bc.globalIndex()];
452-
const auto bcInTF = (static_cast<int64_t>(globalBC) - bcSOR) % nBCsPerTF;
453-
const auto particles = mcParticles->sliceBy(particlesPerMCCollision, mcCollision.globalIndex());
454-
const bool isSignal = mcCollision.getSourceId() == signalSourceId.value;
444+
}
455445

456-
std::vector<float> px, py, pz;
457-
std::vector<int32_t> pdg, recoCollisionIds;
458-
std::vector<uint8_t> recoFlags;
459-
int32_t mult = 0;
460-
// Output rows follow input MC collisions, making this the compact collision label
461-
const auto newMCCollisionId = static_cast<int32_t>(selectedMCCollisions.lastIndex() + 1);
462-
for (const auto& particle : particles) {
463-
mult += particle.isPhysicalPrimary();
464-
// Background rows keep only collision metadata and physical-primary multiplicity
465-
if (!isSignal) {
466-
continue;
467-
}
468-
const auto newMCParticleId = static_cast<int16_t>(pdg.size());
469-
px.push_back(particle.px());
470-
py.push_back(particle.py());
471-
pz.push_back(particle.pz());
472-
pdg.push_back(particle.pdgCode());
446+
LOGP(debug, "Filling FV0 activity arrays");
447+
for (const auto& fv0 : fv0s) {
448+
const float sumAmpFV0A = std::accumulate(fv0.amplitude().begin(), fv0.amplitude().end(), 0.f);
449+
if (fv0.time() < MaxFITTime && sumAmpFV0A >= minAmpFV0A) {
450+
bcsWithFV0.push_back(fv0.bc_as<BCsWithSels>().globalBC());
451+
}
452+
}
473453

474-
uint8_t flags = particle.isPhysicalPrimary() ? kPhysicalPrimary : kNoFlags;
475-
int32_t recoCollisionId = NoRecoCollision;
476-
int nRecoTracks = 0;
477-
// Inspect only reconstructed tracks matched to this signal particle
478-
for (const auto& track : tracks.sliceBy(tracksPerMCParticle, particle.globalIndex())) {
479-
if ((track.mcMask() & MCTrackFakeMask) != 0u) {
480-
continue;
481-
}
482-
++nRecoTracks;
483-
flags |= kHasRecoTrack;
484-
flags |= track.isPVContributor() ? kHasPVContributor : kNoFlags;
485-
flags |= ambiguousTrackIds.contains(track.globalIndex()) ? kHasAmbiguousTrack : kNoFlags;
486-
if (track.has_collision()) {
487-
recoCollisionId = track.collisionId();
488-
flags |= collisions.iteratorAt(recoCollisionId).numContrib() > nTracks ? kHighMultiplicityCollision : kNoFlags;
489-
}
490-
}
491-
// A single collision label is meaningful only for exactly one reconstructed track
492-
if (nRecoTracks > 1) {
493-
recoCollisionId = MultipleRecoTracks;
494-
}
495-
recoFlags.push_back(flags);
496-
recoCollisionIds.push_back(recoCollisionId);
497-
// Remap original particle IDs to output index for candidate labels
498-
signalParticleRefs.emplace(particle.globalIndex(), SignalRef{newMCCollisionId, newMCParticleId});
499-
}
500-
selectedMCCollisions(tfIDs[iTF], globalBC, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(),
501-
px, py, pz, pdg, mult, minDistanceMC[iTF][bcInTF],
502-
recoFlags, recoCollisionIds, isSignal);
454+
LOGP(debug, "Filling FDD activity arrays");
455+
for (const auto& fdd : fdds) {
456+
const float sumAmpFDDA = std::accumulate(std::begin(fdd.chargeA()), std::end(fdd.chargeA()), 0.f);
457+
const float sumAmpFDDC = std::accumulate(std::begin(fdd.chargeC()), std::end(fdd.chargeC()), 0.f);
458+
if ((fdd.timeA() < MaxFITTime && sumAmpFDDA >= minAmpFDDA) || (fdd.timeC() < MaxFITTime && sumAmpFDDC >= minAmpFDDC)) {
459+
bcsWithFDD.push_back(fdd.bc_as<BCsWithSels>().globalBC());
503460
}
504461
}
505462

506-
// collect number of all collisions and upc-mode collisions per ROF
507463
LOGP(debug, "Collect number of all collisions and upc-mode collisions per ROF");
508464
std::vector<std::map<int32_t, float>> vMultTracks(tfIDs.size(), std::map<int32_t, float>());
509465
std::vector<std::vector<int>> vCollisionsPerROF(tfIDs.size(), std::vector<int>(nRofPerTF, 0));
@@ -524,16 +480,7 @@ struct UpcCandProducerBarrel {
524480
auto hTVX = registry.get<TH2>(HIST("hTVX"));
525481
auto hTVXRCT = registry.get<TH2>(HIST("hTVXRCT"));
526482

527-
auto hTVXupc = registry.get<TH2>(HIST("hTVXupc"));
528-
auto hTVXRCTupc = registry.get<TH2>(HIST("hTVXRCTupc"));
529-
530-
std::vector<int64_t> bcsWithFT0, bcsWithFV0, bcsWithFDD;
531-
bcsWithFT0.reserve(ft0s.size());
532-
bcsWithFV0.reserve(fv0s.size());
533-
bcsWithFDD.reserve(fdds.size());
534-
535483
LOGP(debug, "Starting lumi accounting");
536-
// lumi accounting
537484
std::vector<std::map<int32_t, float>> vMultFT0C(tfIDs.size(), std::map<int32_t, float>());
538485
for (const auto& ft0 : ft0s) {
539486
const auto bc = ft0.bc_as<BCsWithSels>();
@@ -542,8 +489,6 @@ struct UpcCandProducerBarrel {
542489
const int32_t bcInTF = (globalBC - bcSOR) % nBCsPerTF;
543490
const auto iTF = localTFIndex[bc.globalIndex()];
544491
const auto tfID = tfIDs[iTF];
545-
const int32_t rofInTF = getRofInTF(bcInTF);
546-
bool upcMode = vCollisionsPerROF[iTF][rofInTF] == 0 || vUpcModePerROF[iTF][rofInTF] > 0;
547492

548493
// Multiplicity for FT0C-based occupancy estimates
549494
if (ft0.timeC() < MaxFITTime && ft0.sumAmpC() >= minAmpFT0C) {
@@ -559,44 +504,12 @@ struct UpcCandProducerBarrel {
559504
}
560505

561506
hTVX->Fill(bcInOrbit, tfID);
562-
if (upcMode) {
563-
hTVXupc->Fill(bcInOrbit, tfID);
564-
}
565507

566508
if (!bc.selection_bit(aod::evsel::kNoTimeFrameBorder) || !rctChecker(bc)) {
567509
continue;
568510
}
569511

570512
hTVXRCT->Fill(bcInOrbit, tfID);
571-
if (upcMode) {
572-
hTVXRCTupc->Fill(bcInOrbit, tfID);
573-
}
574-
}
575-
576-
LOGP(debug, "Filling FT0 activity arrays");
577-
for (const auto& ft0 : ft0s) {
578-
const float sumAmpFT0A = ft0.sumAmpA();
579-
const float sumAmpFT0C = ft0.sumAmpC();
580-
if ((ft0.timeA() < MaxFITTime && sumAmpFT0A >= minAmpFT0A) || (ft0.timeC() < MaxFITTime && sumAmpFT0C >= minAmpFT0C)) {
581-
bcsWithFT0.push_back(ft0.bc_as<BCsWithSels>().globalBC());
582-
}
583-
}
584-
585-
LOGP(debug, "Filling FV0 activity arrays");
586-
for (const auto& fv0 : fv0s) {
587-
const float sumAmpFV0A = std::accumulate(fv0.amplitude().begin(), fv0.amplitude().end(), 0.f);
588-
if (fv0.time() < MaxFITTime && sumAmpFV0A >= minAmpFV0A) {
589-
bcsWithFV0.push_back(fv0.bc_as<BCsWithSels>().globalBC());
590-
}
591-
}
592-
593-
LOGP(debug, "Filling FDD activity arrays");
594-
for (const auto& fdd : fdds) {
595-
const float sumAmpFDDA = std::accumulate(std::begin(fdd.chargeA()), std::end(fdd.chargeA()), 0.f);
596-
const float sumAmpFDDC = std::accumulate(std::begin(fdd.chargeC()), std::end(fdd.chargeC()), 0.f);
597-
if ((fdd.timeA() < MaxFITTime && sumAmpFDDA >= minAmpFDDA) || (fdd.timeC() < MaxFITTime && sumAmpFDDC >= minAmpFDDC)) {
598-
bcsWithFDD.push_back(fdd.bc_as<BCsWithSels>().globalBC());
599-
}
600513
}
601514

602515
LOGP(debug, "Starting occupancy calculation");
@@ -620,6 +533,91 @@ struct UpcCandProducerBarrel {
620533
}
621534
}
622535

536+
std::unordered_map<int64_t, SignalRef> signalParticleRefs;
537+
if constexpr (isMC) {
538+
LOGP(debug, "Collecting MC info. Number of MC collisions = {}", mcCollisions->size());
539+
std::unordered_set<int64_t> ambiguousTrackIds;
540+
ambiguousTrackIds.reserve(ambiguousTracks->size());
541+
for (const auto& ambiguousTrack : *ambiguousTracks) {
542+
ambiguousTrackIds.insert(ambiguousTrack.trackId());
543+
}
544+
545+
std::vector<int64_t> bcsWithMCCollision;
546+
bcsWithMCCollision.reserve(mcCollisions->size());
547+
// Use collisions from every source and retain same-BC pile-up
548+
for (const auto& mcCollision : *mcCollisions) {
549+
bcsWithMCCollision.push_back(static_cast<int64_t>(mcCollision.template bc_as<BCsWithSels>().globalBC()));
550+
}
551+
const auto minDistanceMC = buildMinimumDistanceMap(tfIDs, bcSOR, nBCsPerTF, bcsWithMCCollision, maxStoredDistance, true);
552+
553+
for (const auto& mcCollision : *mcCollisions) {
554+
const auto bc = mcCollision.template bc_as<BCsWithSels>();
555+
const int64_t globalBC = bc.globalBC();
556+
const auto iTF = localTFIndex[bc.globalIndex()];
557+
const int64_t bcInTF = (globalBC - bcSOR) % nBCsPerTF;
558+
LOGP(debug, "setting flags for MC collision");
559+
const int32_t rofInTF = getRofInTF(bcInTF);
560+
const bool upcMode = vCollisionsPerROF[iTF][rofInTF] == 0 || vUpcModePerROF[iTF][rofInTF] > 0;
561+
const bool noPileupInRof = vCollisionsPerROF[iTF][rofInTF] <= 1;
562+
uint8_t bcFlags = 0;
563+
bcFlags |= upcMode << 0;
564+
bcFlags |= noPileupInRof << 1;
565+
const auto occupancyFT0C = vOccupancyFT0C[iTF][bcInTF];
566+
567+
const auto particles = mcParticles->sliceBy(particlesPerMCCollision, mcCollision.globalIndex());
568+
const bool isSignal = mcCollision.getSourceId() == signalSourceId.value;
569+
LOGP(debug, "sourceId = {}", mcCollision.getSourceId());
570+
std::vector<float> px, py, pz;
571+
std::vector<int32_t> pdg, recoCollisionIds;
572+
std::vector<uint8_t> recoFlags;
573+
int32_t mult = 0;
574+
// Output rows follow input MC collisions, making this the compact collision label
575+
const auto newMCCollisionId = static_cast<int32_t>(selectedMCCollisions.lastIndex() + 1);
576+
for (const auto& particle : particles) {
577+
mult += particle.isPhysicalPrimary();
578+
// Background rows keep only collision metadata and physical-primary multiplicity
579+
if (!isSignal) {
580+
continue;
581+
}
582+
const auto newMCParticleId = static_cast<int16_t>(pdg.size());
583+
px.push_back(particle.px());
584+
py.push_back(particle.py());
585+
pz.push_back(particle.pz());
586+
pdg.push_back(particle.pdgCode());
587+
588+
uint8_t flags = particle.isPhysicalPrimary() ? kPhysicalPrimary : kNoFlags;
589+
int32_t recoCollisionId = NoRecoCollision;
590+
int nRecoTracks = 0;
591+
// Inspect only reconstructed tracks matched to this signal particle
592+
for (const auto& track : tracks.sliceBy(tracksPerMCParticle, particle.globalIndex())) {
593+
if ((track.mcMask() & MCTrackFakeMask) != 0u) {
594+
continue;
595+
}
596+
++nRecoTracks;
597+
flags |= kHasRecoTrack;
598+
flags |= track.isPVContributor() ? kHasPVContributor : kNoFlags;
599+
flags |= ambiguousTrackIds.contains(track.globalIndex()) ? kHasAmbiguousTrack : kNoFlags;
600+
if (track.has_collision()) {
601+
recoCollisionId = track.collisionId();
602+
flags |= collisions.iteratorAt(recoCollisionId).numContrib() > nTracks ? kHighMultiplicityCollision : kNoFlags;
603+
}
604+
}
605+
// A single collision label is meaningful only for exactly one reconstructed track
606+
if (nRecoTracks > 1) {
607+
recoCollisionId = MultipleRecoTracks;
608+
}
609+
recoFlags.push_back(flags);
610+
recoCollisionIds.push_back(recoCollisionId);
611+
// Remap original particle IDs to output index for candidate labels
612+
signalParticleRefs.emplace(particle.globalIndex(), SignalRef{newMCCollisionId, newMCParticleId});
613+
}
614+
selectedMCCollisions(tfIDs[iTF], globalBC, bcFlags, occupancyFT0C,
615+
mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(),
616+
px, py, pz, pdg, mult, minDistanceMC[iTF][bcInTF],
617+
recoFlags, recoCollisionIds, isSignal);
618+
}
619+
}
620+
623621
LOGP(debug, "Building minimum distance maps");
624622
const uint32_t scanDistance = std::max(maxStoredDistance.value, vetoBCWindow.value);
625623
const DistanceMap minDistanceFT0 = buildMinimumDistanceMap(tfIDs, bcSOR, nBCsPerTF, bcsWithFT0, scanDistance);

0 commit comments

Comments
 (0)