@@ -143,6 +143,18 @@ DECLARE_SOA_TABLE_STAGED_VERSIONED(FColMasks_001, "FCOLMASK", 1, //! collision m
 using FColMasks = FColMasks_001;
 using StoredFColMasks = StoredFColMasks_001;
 
+// table for collision tags: one bit per (wagon, pair type) combination the collision tagger was
+// self-configured to check, set if the collision has what it takes to form at least one pair of
+// that type (both particle-1-role and particle-2-role candidates present, or, for a same-species
+// pair, at least 2 distinct candidates passing the one shared selection). Used to pre-filter the
+// mixed-event pool instead of discovering empty collisions only after slicing. Which bit means
+// what is assigned at self-configuration time and logged by the tagger; see
+// PWGCF/Femto/TableProducer/femtoProducerCollisionTagger.cxx.
+DECLARE_SOA_TABLE_STAGED_VERSIONED(FColTags_001, "FCOLTAG", 1, //! collision tags
+                                   femtocollisions::CollisionTag);
+using FColTags = FColTags_001;
+using StoredFColTags = StoredFColTags_001;
+
 DECLARE_SOA_TABLE_STAGED_VERSIONED(FColSphericities_001, "FCOLSPHERICITY", 1, //! sphericity
                                    femtocollisions::Sphericity);
 using FColSphericities = FColSphericities_001;
 
@@ -14,6 +14,11 @@ o2physics_add_dpl_workflow(femto-producer
           PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::EventFilteringUtils O2Physics::PWGEMPhotonMesonCore
           COMPONENT_NAME Analysis)
 
+o2physics_add_dpl_workflow(femto-producer-collision-tagger
+          SOURCES ./femtoProducerCollisionTagger.cxx
+          PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore
+          COMPONENT_NAME Analysis)
+
 o2physics_add_dpl_workflow(femto-producer-derived-to-derived
           SOURCES ./femtoProducerDerivedToDerived.cxx
           PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore
 
@@ -18,6 +18,7 @@
 #include "PWGCF/Femto/Core/closePairRejection.h"
 #include "PWGCF/Femto/Core/collisionBuilder.h"
 #include "PWGCF/Femto/Core/collisionHistManager.h"
+#include "PWGCF/Femto/Core/collisionTagger.h"
 #include "PWGCF/Femto/Core/modes.h"
 #include "PWGCF/Femto/Core/pairBuilder.h"
 #include "PWGCF/Femto/Core/pairCleaner.h"
@@ -32,11 +33,13 @@
 #include <Framework/AnalysisTask.h>
 #include <Framework/BinningPolicy.h>
 #include <Framework/Configurable.h>
+#include <Framework/DeviceSpec.h>
 #include <Framework/Expressions.h>
 #include <Framework/HistogramRegistry.h>
 #include <Framework/HistogramSpec.h>
 #include <Framework/InitContext.h>
 #include <Framework/OutputObjHeader.h>
+#include <Framework/RunningWorkflowInfo.h>
 #include <Framework/runDataProcessing.h>
 
 #include <map>
@@ -68,13 +71,20 @@ struct FemtoPairD0D0 {
 
   using FemtoMcParticlesWithLabel = o2::soa::Join<o2::aod::FMcParticles, o2::aod::FMcMotherLabels>;
 
+  // opt-in: carries FColTags, only needed by processMixedEventWithTagging.
+  using FemtoCollisionsWithTags = o2::soa::Join<FemtoCollisions, o2::aod::FColTags>;
+  using FilteredFemtoCollisionsWithTags = o2::soa::Filtered<FemtoCollisionsWithTags>;
+
   o2::framework::SliceCache cache;
 
   // setup collisions
   collisionbuilder::ConfCollisionSelection collisionSelection;
   o2::framework::expressions::Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection);
   colhistmanager::ConfCollisionBinning confCollisionBinning;
 
+  // opt-in, only needed by processMixedEventWithTagging below.
+  collisiontagger::ConfTagging<collisiontagger::role::D0D0Pair> confTaggingD0D0;
+
   // setup for daughters
   // separate binning per d0 slot, so that both hypotheses can be binned independently
   trackhistmanager::ConfD01PosDauBinning confD01PosDauBinning;
@@ -141,9 +151,9 @@ struct FemtoPairD0D0 {
   closepairrejection::ConfCprD0DaugherD0DaughterPos confCprPos;
   closepairrejection::ConfCprD0DaugherD0DaughterNeg confCprNeg;
 
-  void init(o2::framework::InitContext&)
+  void init(o2::framework::InitContext& context)
   {
-    bool processData = doprocessSameEvent || doprocessMixedEvent;
+    bool processData = doprocessSameEvent || doprocessMixedEvent || doprocessMixedEventWithTagging;
     bool processMc = doprocessSameEventMc || doprocessMixedEventMc;
 
     if (processData && processMc) {
@@ -153,6 +163,19 @@ struct FemtoPairD0D0 {
       LOG(fatal) << "Neither data nor mc processing is enabled. Breaking...";
     }
 
+    if (doprocessMixedEventWithTagging) {
+      auto const& workflows = context.services().get<o2::framework::RunningWorkflowInfo const>();
+      auto const& ownDevice = context.services().get<o2::framework::DeviceSpec const>();
+      auto roles = collisiontagger::discoverTaggedRoles(workflows);
+      int bit = collisiontagger::findOwnBit(roles, ownDevice.name, confTaggingD0D0.Role);
+      if (bit < 0) {
+        LOG(fatal) << "processMixedEventWithTagging is enabled, but no femto-collision-tagger device "
+                   << "(with processD0D0 enabled) tagging this device (" << ownDevice.name << ") was found in this workflow.";
+      }
+      confTaggingD0D0.internalTagMask.value = static_cast<datatypes::CollisionTagType>(1) << bit;
+      LOG(info) << "Collision tagger bit for " << ownDevice.name << " (D0D0): " << bit;
+    }
+
     // setup columnpolicy for binning
     // default values are used during instantiation, so we need to explicity update them here
     mixBinsVtxMult = {{confMixing.vtxBins.value, confMixing.multBins.value}};
@@ -208,6 +231,16 @@ struct FemtoPairD0D0 {
   }
   PROCESS_SWITCH(FemtoPairD0D0, processSameEventMc, "Enable processing same event processing for d0-d0 with mc information", false);
 
+  // Opt-in counterpart of processMixedEvent() below -- same "Partition declared and bound inside
+  // process()" idiom as femtoPairTrackTrack.cxx's processMixedEventWithTagging.
+  void processMixedEventWithTagging(FilteredFemtoCollisionsWithTags const& cols, FemtoTracks const& tracks, FemtoD0s const& /*d0s*/)
+  {
+    o2::framework::Partition<FilteredFemtoCollisionsWithTags> taggedCollisions = ncheckbit(o2::aod::femtocollisions::collisionTag, confTaggingD0D0.internalTagMask);
+    taggedCollisions.bindTable(cols);
+    pairD0D0Builder.processMixedEvent<modes::Mode::kMe_Reco>(taggedCollisions, tracks, d0Partition1, d0Partition2, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent);
+  }
+  PROCESS_SWITCH(FemtoPairD0D0, processMixedEventWithTagging, "Enable processing mixed event processing for d0-d0, pre-filtered using the collision tagger", false);
+
   void processMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoD0s const& /*d0s*/)
   {
     pairD0D0Builder.processMixedEvent<modes::Mode::kMe_Reco>(cols, tracks, d0Partition1, d0Partition2, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent);
 
@@ -18,6 +18,7 @@
 #include "PWGCF/Femto/Core/closePairRejection.h"
 #include "PWGCF/Femto/Core/collisionBuilder.h"
 #include "PWGCF/Femto/Core/collisionHistManager.h"
+#include "PWGCF/Femto/Core/collisionTagger.h"
 #include "PWGCF/Femto/Core/modes.h"
 #include "PWGCF/Femto/Core/pairBuilder.h"
 #include "PWGCF/Femto/Core/pairCleaner.h"
@@ -33,11 +34,13 @@
 #include <Framework/AnalysisTask.h>
 #include <Framework/BinningPolicy.h>
 #include <Framework/Configurable.h>
+#include <Framework/DeviceSpec.h>
 #include <Framework/Expressions.h>
 #include <Framework/HistogramRegistry.h>
 #include <Framework/HistogramSpec.h>
 #include <Framework/InitContext.h>
 #include <Framework/OutputObjHeader.h>
+#include <Framework/RunningWorkflowInfo.h>
 #include <Framework/runDataProcessing.h>
 
 #include <map>
@@ -56,6 +59,10 @@ struct FemtoPairTrackCascade {
   using FilteredFemtoCollisionsWithLabel = o2::soa::Filtered<FemtoCollisionsWithLabel>;
   using FilteredFemtoCollisionWithLabel = FilteredFemtoCollisionsWithLabel::iterator;
 
+  // opt-in FColTags , only needed by processXiMixedEventWithTagging/processOmegaMixedEventWithTagging
+  using FemtoCollisionsWithTags = o2::soa::Join<FemtoCollisions, o2::aod::FColTags>;
+  using FilteredFemtoCollisionsWithTags = o2::soa::Filtered<FemtoCollisionsWithTags>;
+
   using FemtoTracks = o2::soa::Join<o2::aod::FTracks, o2::aod::FTrackMasks>;
   using FemtoXis = o2::soa::Join<o2::aod::FXis, o2::aod::FXiMasks>;
   using FemtoOmegas = o2::soa::Join<o2::aod::FOmegas, o2::aod::FOmegaMasks>;
@@ -78,6 +85,11 @@ struct FemtoPairTrackCascade {
   o2::framework::expressions::Filter collisionFilter = MAKE_COLLISION_FILTER(collisionSelection);
   colhistmanager::ConfCollisionBinning confCollisionBinning;
 
+  // opt-in, only needed by processXiMixedEventWithTagging/processOmegaMixedEventWithTagging --
+  // two separate instances since Xi and Omega are tagged independently (see init()).
+  collisiontagger::ConfTagging<collisiontagger::role::TrackXiPair> confTaggingXi;
+  collisiontagger::ConfTagging<collisiontagger::role::TrackOmegaPair> confTaggingOmega;
+
   // setup tracks
   trackbuilder::ConfTrackSelection1 confTrackSelection;
   trackhistmanager::ConfTrackBinning1 confTrackBinning;
@@ -185,18 +197,43 @@ struct FemtoPairTrackCascade {
   closepairrejection::ConfCprTrackCascadeBachelor confCprBachelor;
   closepairrejection::ConfCprTrackV0Daughter confCprV0Daughter;
 
-  void init(o2::framework::InitContext&)
+  void init(o2::framework::InitContext& context)
   {
-    bool processData = doprocessXiSameEvent || doprocessXiMixedEvent || doprocessOmegaSameEvent || doprocessOmegaMixedEvent;
+    bool processData = doprocessXiSameEvent || doprocessXiMixedEvent || doprocessOmegaSameEvent || doprocessOmegaMixedEvent || doprocessXiMixedEventWithTagging || doprocessOmegaMixedEventWithTagging;
     bool processFitVars = doprocessXiSameEventWithFitVars || doprocessXiMixedEventWithFitVars || doprocessOmegaSameEventWithFitVars || doprocessOmegaMixedEventWithFitVars;
     bool processMc = doprocessXiSameEventMc || doprocessXiMixedEventMc || doprocessOmegaSameEventMc || doprocessOmegaMixedEventMc;
 
     if (static_cast<int>(processData) + static_cast<int>(processFitVars) + static_cast<int>(processMc) > 1) {
       LOG(fatal) << "More than one of data, FitVars or mc processing is activated. Breaking...";
     }
 
-    bool processXi = doprocessXiSameEvent || doprocessXiSameEventWithFitVars || doprocessXiSameEventMc || doprocessXiMixedEvent || doprocessXiMixedEventWithFitVars || doprocessXiMixedEventMc;
-    bool processOmega = doprocessOmegaSameEvent || doprocessOmegaSameEventWithFitVars || doprocessOmegaSameEventMc || doprocessOmegaMixedEvent || doprocessOmegaMixedEventWithFitVars || doprocessOmegaMixedEventMc;
+    bool processXi = doprocessXiSameEvent || doprocessXiSameEventWithFitVars || doprocessXiSameEventMc || doprocessXiMixedEvent || doprocessXiMixedEventWithFitVars || doprocessXiMixedEventMc || doprocessXiMixedEventWithTagging;
+    bool processOmega = doprocessOmegaSameEvent || doprocessOmegaSameEventWithFitVars || doprocessOmegaSameEventMc || doprocessOmegaMixedEvent || doprocessOmegaMixedEventWithFitVars || doprocessOmegaMixedEventMc || doprocessOmegaMixedEventWithTagging;
+
+    // Each species discovers its own tag bit independently (see Core/collisionTagger.h).
+    if (doprocessXiMixedEventWithTagging || doprocessOmegaMixedEventWithTagging) {
+      auto const& workflows = context.services().get<o2::framework::RunningWorkflowInfo const>();
+      auto const& ownDevice = context.services().get<o2::framework::DeviceSpec const>();
+      auto roles = collisiontagger::discoverTaggedRoles(workflows);
+      if (doprocessXiMixedEventWithTagging) {
+        int bit = collisiontagger::findOwnBit(roles, ownDevice.name, confTaggingXi.Role);
+        if (bit < 0) {
+          LOG(fatal) << "processXiMixedEventWithTagging is enabled, but no femto-collision-tagger device "
+                     << "(with processTrackCascade enabled) tagging this device (" << ownDevice.name << ") was found in this workflow.";
+        }
+        confTaggingXi.internalTagMask.value = static_cast<datatypes::CollisionTagType>(1) << bit;
+        LOG(info) << "Collision tagger bit for " << ownDevice.name << " (Xi): " << bit;
+      }
+      if (doprocessOmegaMixedEventWithTagging) {
+        int bit = collisiontagger::findOwnBit(roles, ownDevice.name, confTaggingOmega.Role);
+        if (bit < 0) {
+          LOG(fatal) << "processOmegaMixedEventWithTagging is enabled, but no femto-collision-tagger device "
+                     << "(with processTrackCascade enabled) tagging this device (" << ownDevice.name << ") was found in this workflow.";
+        }
+        confTaggingOmega.internalTagMask.value = static_cast<datatypes::CollisionTagType>(1) << bit;
+        LOG(info) << "Collision tagger bit for " << ownDevice.name << " (Omega): " << bit;
+      }
+    }
 
     if (processXi && processOmega) {
       LOG(fatal) << "Both xi-track and omega-track processing is enabled. Breaking...";
@@ -280,6 +317,17 @@ struct FemtoPairTrackCascade {
   }
   PROCESS_SWITCH(FemtoPairTrackCascade, processXiSameEventMc, "Enable processing same event processing for tracks and xis with mc information", false);
 
+  // Opt-in counterpart of processXiMixedEvent() below -- same "Partition declared and bound
+  // inside process()" idiom as femtoPairTrackTrack.cxx's processMixedEventWithTagging. Requires
+  // a femto-collision-tagger device (processTrackCascade enabled) in the same workflow -- see init().
+  void processXiMixedEventWithTagging(FilteredFemtoCollisionsWithTags const& cols, FemtoTracks const& tracks, FemtoXis const& /*xis*/)
+  {
+    o2::framework::Partition<FilteredFemtoCollisionsWithTags> taggedCollisions = ncheckbit(o2::aod::femtocollisions::collisionTag, confTaggingXi.internalTagMask);
+    taggedCollisions.bindTable(cols);
+    pairTrackXiBuilder.processMixedEvent<modes::Mode::kMe_Reco>(taggedCollisions, tracks, trackPartition, xiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent);
+  }
+  PROCESS_SWITCH(FemtoPairTrackCascade, processXiMixedEventWithTagging, "Enable processing mixed event processing for tracks and xis, pre-filtered using the collision tagger", false);
+
   void processXiMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoXis const& /*xis*/)
   {
     pairTrackXiBuilder.processMixedEvent<modes::Mode::kMe_Reco>(cols, tracks, trackPartition, xiPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent);
@@ -316,6 +364,15 @@ struct FemtoPairTrackCascade {
   }
   PROCESS_SWITCH(FemtoPairTrackCascade, processOmegaSameEventMc, "Enable processing same event processing for tracks and omegas with mc information", false);
 
+  // Opt-in counterpart of processOmegaMixedEvent() below -- same idiom as processXiMixedEventWithTagging above.
+  void processOmegaMixedEventWithTagging(FilteredFemtoCollisionsWithTags const& cols, FemtoTracks const& tracks, FemtoOmegas const& /*omegas*/)
+  {
+    o2::framework::Partition<FilteredFemtoCollisionsWithTags> taggedCollisions = ncheckbit(o2::aod::femtocollisions::collisionTag, confTaggingOmega.internalTagMask);
+    taggedCollisions.bindTable(cols);
+    pairTrackOmegaBuilder.processMixedEvent<modes::Mode::kMe_Reco>(taggedCollisions, tracks, trackPartition, omegaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent);
+  }
+  PROCESS_SWITCH(FemtoPairTrackCascade, processOmegaMixedEventWithTagging, "Enable processing mixed event processing for tracks and omegas, pre-filtered using the collision tagger", false);
+
   void processOmegaMixedEvent(FilteredFemtoCollisions const& cols, FemtoTracks const& tracks, FemtoOmegas const& /*omegas*/)
   {
     pairTrackOmegaBuilder.processMixedEvent<modes::Mode::kMe_Reco>(cols, tracks, trackPartition, omegaPartition, cache, mixBinsVtxMult, mixBinsVtxCent, mixBinsVtxMultCent);