@@ -209,6 +209,8 @@ DECLARE_SOA_TABLE(UPCBarrelCands, "AOD", "UPCBARRELCANDS",
209209DECLARE_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