Propagate ITS UPC mode flag to matching AOD BCs and collisions (#13416)

* Use enums to set the UPC/Std ITS mode flags

* Propagate ITS UPC mode modified flag to final PVs

* Propagate ITS UPC mode flag to matching AOD BCs

(cherry picked from commit 7a6665b)

Author: shahor02

DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/ROFRecord.h

@@ -31,6 +31,8 @@ class ROFRecord
 {
 
  public:
+  enum { VtxStdMode = 0,
+         VtxUPCMode = 1 };
   using EvIdx = o2::dataformats::RangeReference<int, int>;
   using BCData = o2::InteractionRecord;
   using ROFtype = unsigned int;

DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h

@@ -124,6 +124,7 @@ class Vertex : public VertexBase
   using ushort = unsigned short;
   enum Flags : ushort {
     TimeValidated = 0x1 << 0, // Flag that the vertex was validated by external time measurement (e.g. FIT)
+    UPCMode = 0x1 << 1,       // vertex is found in the UPC mode ITS ROF
     FlagsMask = 0xffff
   };
 

Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h

@@ -624,6 +624,8 @@ class AODProducerWorkflowDPL : public Task
 
   std::uint64_t fillBCSlice(int (&slice)[2], double tmin, double tmax, const std::map<uint64_t, int>& bcsMap) const;
 
+  std::vector<uint8_t> fillBCFlags(const o2::globaltracking::RecoContainer& data, std::map<uint64_t, int>& bcsMap) const;
+
   // helper for tpc clusters
   void countTPCClusters(const o2::globaltracking::RecoContainer& data);
 

Detectors/AOD/src/AODProducerWorkflowSpec.cxx

@@ -1797,6 +1797,7 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
   using namespace o2::aodhelpers;
 
   auto bcCursor = createTableCursor<o2::aod::BCs>(pc);
+  auto bcFlagsCursor = createTableCursor<o2::aod::BCFlags>(pc);
   auto cascadesCursor = createTableCursor<o2::aod::Cascades>(pc);
   auto collisionsCursor = createTableCursor<o2::aod::Collisions>(pc);
   auto decay3BodyCursor = createTableCursor<o2::aod::Decay3Bodys>(pc);
@@ -2220,6 +2221,13 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
 
   bcToClassMask.clear();
 
+  // filling BC flags table:
+  auto bcFlags = fillBCFlags(recoData, bcsMap);
+  bcFlagsCursor.reserve(bcFlags.size());
+  for (auto f : bcFlags) {
+    bcFlagsCursor(f);
+  }
+
   // fill cpvcluster table
   if (mInputSources[GIndex::CPV]) {
     float posX, posZ;
@@ -2884,6 +2892,36 @@ std::uint64_t AODProducerWorkflowDPL::fillBCSlice(int (&slice)[2], double tmin,
   return bcOfTimeRef;
 }
 
+std::vector<uint8_t> AODProducerWorkflowDPL::fillBCFlags(const o2::globaltracking::RecoContainer& data, std::map<uint64_t, int>& bcsMap) const
+{
+  std::vector<uint8_t> flags(bcsMap.size());
+
+  // flag BCs belonging to UPC mode ITS ROFs
+  auto bcIt = bcsMap.begin();
+  auto itsrofs = data.getITSTracksROFRecords();
+  auto lROF = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameLengthInBC;
+  auto bROF = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameBiasInBC;
+  for (auto& rof : itsrofs) {
+    if (!rof.getFlag(o2::itsmft::ROFRecord::VtxUPCMode)) {
+      continue;
+    }
+    uint64_t globalBC0 = rof.getBCData().toLong() + bROF, globalBC1 = globalBC0 + lROF - 1;
+    // BCs are sorted, iterate until the start of ROF
+    while (bcIt != bcsMap.end()) {
+      if (bcIt->first < globalBC0) {
+        ++bcIt;
+        continue;
+      }
+      if (bcIt->first > globalBC1) {
+        break;
+      }
+      flags[bcIt->second] |= o2::aod::bc::ITSUPCMode;
+      ++bcIt;
+    }
+  }
+  return flags;
+}
+
 void AODProducerWorkflowDPL::endOfStream(EndOfStreamContext& /*ec*/)
 {
   LOGF(info, "aod producer dpl total timing: Cpu: %.3e Real: %.3e s in %d slots",
@@ -2945,6 +2983,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
 
   std::vector<OutputSpec> outputs{
     OutputForTable<BCs>::spec(),
+    OutputForTable<BCFlags>::spec(),
     OutputForTable<Cascades>::spec(),
     OutputForTable<Collisions>::spec(),
     OutputForTable<Decay3Bodys>::spec(),

Detectors/GlobalTrackingWorkflow/src/PrimaryVertexingSpec.cxx

@@ -150,6 +150,34 @@ void PrimaryVertexingSpec::run(ProcessingContext& pc)
       }
     }
     mVertexer.process(tracks, gids, ft0Data, vertices, vertexTrackIDs, v2tRefs, tracksMCInfo, lblVtx);
+
+    // flag vertices using UPC ITS mode
+    auto itsrofs = recoData.getITSTracksROFRecords();
+    std::vector<bool> itsTrUPC(recoData.getITSTracks().size());
+    for (auto& rof : itsrofs) {
+      if (rof.getFlag(o2::itsmft::ROFRecord::VtxUPCMode)) {
+        for (int i = rof.getFirstEntry(); i < rof.getFirstEntry() + rof.getNEntries(); i++) {
+          itsTrUPC[i] = true;
+        }
+      }
+    }
+    int nv = vertices.size();
+    for (int iv = 0; iv < nv; iv++) {
+      int idMin = v2tRefs[iv].getFirstEntry(), idMax = idMin + v2tRefs[iv].getEntries();
+      int nits = 0, nitsUPC = 0;
+      for (int id = idMin; id < idMax; id++) {
+        auto gid = recoData.getITSContributorGID(vertexTrackIDs[id]);
+        if (gid.getSource() == GIndex::ITS) {
+          nits++;
+          if (itsTrUPC[gid.getIndex()]) {
+            nitsUPC++;
+          }
+        }
+      }
+      if (nitsUPC > nits / 2) {
+        vertices[iv].setFlags(PVertex::UPCMode);
+      }
+    }
   }
 
   pc.outputs().snapshot(Output{"GLO", "PVTX", 0}, vertices);

Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx

@@ -201,10 +201,21 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       if (mIsMC) {
         vMCRecInfo = mTimeFrame->getPrimaryVerticesMCRecInfo(iRof);
       }
-      if (o2::its::TrackerParamConfig::Instance().doUPCIteration && (vtxSpan.size() && vtxSpan[0].getFlags() == 1)) { // at least one vertex in this ROF and it is from second vertex iteration
-        LOGP(debug, "ROF {} rejected as vertices are from the UPC iteration", iRof);
-        processUPCMask[iRof] = true;
-        cutUPCVertex++;
+      if (o2::its::TrackerParamConfig::Instance().doUPCIteration) {
+        if (vtxSpan.size()) {
+          if (vtxSpan[0].isFlagSet(Vertex::UPCMode) == 1) { // at least one vertex in this ROF and it is from second vertex iteration
+            LOGP(debug, "ROF {} rejected as vertices are from the UPC iteration", iRof);
+            processUPCMask[iRof] = true;
+            cutUPCVertex++;
+            vtxROF.setFlag(o2::itsmft::ROFRecord::VtxUPCMode);
+          } else { // in all cases except if as standard mode vertex was found, the ROF was processed with UPC settings
+            vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
+          }
+        } else {
+          vtxROF.setFlag(o2::itsmft::ROFRecord::VtxUPCMode);
+        }
+      } else {
+        vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
       }
       vtxROF.setNEntries(vtxSpan.size());
       bool selROF = vtxSpan.size() == 0;
@@ -219,11 +230,6 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
           allVerticesLabels.push_back(vMCRecInfo[iV].first);
           allVerticesPurities.push_back(vMCRecInfo[iV].second);
         }
-        if (v.isFlagSet(2)) { // Vertex is reconstructed in a second iteration
-          vtxROF.setFlag(2);  // flag that at least one vertex is from the second iteration
-        } else {
-          vtxROF.setFlag(1); // flag that at least one vertex is from the first iteration
-        }
       }
       if (processingMask[iRof] && !selROF) { // passed selection in clusters and not in vertex multiplicity
         LOGP(info, "ROF {} rejected by the vertex multiplicity selection [{},{}]", iRof, multEstConf.cutMultVtxLow, multEstConf.cutMultVtxHigh);
@@ -292,7 +298,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       int offset = -tracksROF.getFirstEntry(); // cluster entry!!!
       tracksROF.setFirstEntry(first);
       tracksROF.setNEntries(number);
-      tracksROF.setFlags(number ? vtxROF.getFlags() : 0); // copies 0xffffffff if cosmics
+      tracksROF.setFlags(vtxROF.getFlags()); // copies 0xffffffff if cosmics
       if (processingMask[iROF]) {
         irFrames.emplace_back(tracksROF.getBCData(), tracksROF.getBCData() + nBCPerTF - 1).info = tracks.size();
       }
@@ -388,4 +394,4 @@ void ITSTrackingInterface::setTraitsFromProvider(VertexerTraits* vertexerTraits,
 template void ITSTrackingInterface::run<true>(framework::ProcessingContext& pc);
 template void ITSTrackingInterface::run<false>(framework::ProcessingContext& pc);
 } // namespace its
-} // namespace o2
+} // namespace o2

Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx

@@ -517,7 +517,9 @@ void VertexerTraits::computeVertices(const int iteration)
                               mTimeFrame->getTrackletClusters(rofId)[iCluster].getSize(),          // Contributors
                               mTimeFrame->getTrackletClusters(rofId)[iCluster].getAvgDistance2()); // In place of chi2
 
-        vertices.back().setFlags(iteration + 1);
+        if (iteration) {
+          vertices.back().setFlags(Vertex::UPCMode);
+        }
         vertices.back().setTimeStamp(mTimeFrame->getTrackletClusters(rofId)[iCluster].getROF());
         if (mTimeFrame->hasMCinformation()) {
           std::vector<o2::MCCompLabel> labels;

Framework/Core/include/Framework/DataTypes.h

@@ -16,6 +16,13 @@
 #include <cstdint>
 #include <limits>
 
+namespace o2::aod::bc
+{
+enum BCFlags : uint8_t {
+  ITSUPCMode = 0x1
+};
+}
+
 namespace o2::aod::collision
 {
 enum CollisionFlagsRun2 : uint16_t {