Prepare the TPC digitizer for concurrent digitizers

This makes several TPC digitizers usable side by side in one process, as a preparation for MT digitization.

- Each DigitContainer keeps its own copy of the dead channel map, because CDBInterface::getDeadChannelMap() rebuilds the shared map on every call.
- The one-time settings report moves from the flush path into updateCalibrations().
- Digitizer::setSCDistortionsFrom() shares the distortion maps and their scaling with another digitizer.
- digitizeSector() takes an optional mutex for the calls that read calibrations through the CDBInterface.
- The output is unchanged.

https://its.cern.ch/jira/browse/O2-7309

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: sawenzel

Detectors/TPC/simulation/include/TPCSimulation/DigitContainer.h

@@ -96,7 +96,8 @@ class DigitContainer
   std::unique_ptr<DigitTime::PrevDigitInfoArray> mPrevDigArr; ///< Keep track of ToT and ion tail cumul from last time bin
   o2::utils::DebugStreamer mStreamer;                         ///< Debug streamer
   const CalPad* mPadParams[3] = {nullptr, nullptr, nullptr};  //!< Ion tail fraction, ion tail slope and common mode k-values per pad
-  const CalDet<bool>* mDeadMap = nullptr;                     //!< Dead channel map
+  const CalDet<bool>* mDeadMap = nullptr;                     //!< Dead channel map, points to mDeadMapCopy if set
+  std::unique_ptr<CalDet<bool>> mDeadMapCopy;                 //!< Own copy of the dead channel map, which the CDBInterface rebuilds on each access
   bool mCMCEnabled = false;                                   //!< Common mode correction enabled in the FEE config (DigiMode Auto)
   bool mCalibrationsUpdated = false;                          //!< Whether updateCalibrations was called
   SAMPAProcessing* mSAMPAProcessing = nullptr;                //!< SAMPAProcessing used for the output, the singleton if not set

Detectors/TPC/simulation/include/TPCSimulation/Digitizer.h

@@ -143,6 +143,9 @@ class Digitizer
   /// in case of scaled distortions, the distortions can be recalculated to ensure consistent distortions and corrections
   void recalculateDistortions();
 
+  /// Use the distortion maps and scaling of another digitizer, which keeps ownership of the maps
+  void setSCDistortionsFrom(const Digitizer& other);
+
   /// Use digitizer-owned random rings filled from seed and positioned per sector and timeframe in init(),
   /// so that the digits of a sector do not depend on which sectors were processed before
   /// \param seed base seed, typically DigiParams.seed

Detectors/TPC/simulation/src/DigitContainer.cxx

@@ -14,6 +14,7 @@
 /// \author Andi Mathis, TU München, andreas.mathis@ph.tum.de
 
 #include "TPCSimulation/DigitContainer.h"
+#include <atomic>
 #include <memory>
 #include <fairlogger/Logger.h>
 #include "TPCBase/Mapper.h"
@@ -59,15 +60,6 @@ void DigitContainer::fillOutputContainer(std::vector<Digit>& output,
     mPrevDigArr = std::make_unique<DigitTime::PrevDigitInfoArray>();
   }
 
-  static bool reportedSettings = false;
-  if (!reportedSettings) {
-    reportSettings();
-    if (mDeadMap) {
-      LOGP(info, "Using dead map with {} masked pads", mDeadMap->getSum<int>());
-    }
-    reportedSettings = true;
-  }
-
   for (auto& time : mTimeBins) {
     /// the time bins between the last event and the timing of this event are uncorrelated and can be written out
     /// OR the readout is triggered (i.e. not continuous) and we can dump everything in any case, as long it is within one drift time interval
@@ -162,12 +154,25 @@ void DigitContainer::updateCalibrations()
   }
 
   // dead channel map
-  mDeadMap = eleParam.applyDeadMap ? &cdb.getDeadChannelMap() : nullptr;
+  mDeadMap = nullptr;
+  mDeadMapCopy.reset();
+  if (eleParam.applyDeadMap) {
+    mDeadMapCopy = std::make_unique<CalDet<bool>>(cdb.getDeadChannelMap());
+    mDeadMap = mDeadMapCopy.get();
+  }
 
   // common mode correction in the FEE, needed to resolve DigiMode Auto
   mCMCEnabled = (eleParam.DigiMode == DigitzationMode::Auto) && cdb.getFEEConfig().isCMCEnabled();
 
   mCalibrationsUpdated = true;
+
+  static std::atomic<bool> reportedSettings{false};
+  if (!reportedSettings.exchange(true)) {
+    reportSettings();
+    if (mDeadMap) {
+      LOGP(info, "Using dead map with {} masked pads", mDeadMap->getSum<int>());
+    }
+  }
 }
 
 void DigitContainer::reportSettings()

Detectors/TPC/simulation/src/Digitizer.cxx

@@ -295,6 +295,16 @@ void Digitizer::setStartTime(double time)
   mDigitContainer.setStartTime(starttimebin);
 }
 
+void Digitizer::setSCDistortionsFrom(const Digitizer& other)
+{
+  mSpaceChargeOwned.reset();
+  mSpaceCharge = other.mSpaceCharge;
+  mSpaceChargeDer = other.mSpaceChargeDer;
+  mUseSCDistortions = other.mUseSCDistortions;
+  mLumiScaleFactor = other.mLumiScaleFactor;
+  mUseScaledDistortions = other.mUseScaledDistortions;
+}
+
 void Digitizer::setLumiScaleFactor()
 {
   mLumiScaleFactor = (CorrMapParam::Instance().lumiInst - mSpaceCharge->getMeanLumi()) / mSpaceChargeDer->getMeanLumi();

Steer/DigitizerWorkflow/src/TPCSectorDigitization.cxx

@@ -42,16 +42,23 @@ std::string getBranchNameRight(int sector)
 
 std::vector<dataformats::RangeReference<int, int>> digitizeSector(Digitizer& digitizer, const steer::DigitizationContext& context,
                                                                   const std::vector<TChain*>& simChains, int sector, ULong64_t timeframe,
-                                                                  SectorFlushBuffers& buffers, const std::function<void()>& onFlush)
+                                                                  SectorFlushBuffers& buffers, const std::function<void()>& onFlush,
+                                                                  std::mutex* cdbMutex)
 {
+  // locks cdbMutex, if given, for calls that read calibrations through the CDBInterface
+  auto cdbLock = [cdbMutex]() { return cdbMutex ? std::unique_lock<std::mutex>(*cdbMutex) : std::unique_lock<std::mutex>(); };
+
   std::vector<dataformats::RangeReference<int, int>> events;
   const bool isContinuous = digitizer.isContinuousReadout();
   const auto& irecords = context.getEventRecords();
   const auto& eventParts = context.getEventParts();
 
   digitizer.setSector(sector);
   digitizer.setSeedingTimeframe(timeframe);
-  digitizer.init();
+  {
+    auto lock = cdbLock();
+    digitizer.init();
+  }
 
   size_t digitCounter = 0;
   auto flush = [&](bool finalFlush = false) {
@@ -69,6 +76,7 @@ std::vector<dataformats::RangeReference<int, int>> digitizeSector(Digitizer& dig
     double time = hbfu.getFirstIRofTF(o2::InteractionRecord(0, hbfu.orbitFirstSampled)).bc2ns() / 1000.;
     digitizer.setOutputDigitTimeOffset(time);
     if (!irecords.empty()) {
+      auto lock = cdbLock();
       digitizer.setStartTime(irecords[0].getTimeNS() / 1000.f);
     }
   }
@@ -80,6 +88,7 @@ std::vector<dataformats::RangeReference<int, int>> digitizeSector(Digitizer& dig
     LOG(info) << "TPC: Event time " << eventTime << " us";
     digitizer.setEventTime(eventTime);
     if (!isContinuous) {
+      auto lock = cdbLock();
       digitizer.setStartTime(eventTime);
     }
     size_t startSize = digitCounter;

Steer/DigitizerWorkflow/src/TPCSectorDigitization.h

@@ -13,6 +13,7 @@
 #define STEER_DIGITIZERWORKFLOW_TPCSECTORDIGITIZATION_H_
 
 #include <functional>
+#include <mutex>
 #include <vector>
 #include <RtypesCore.h>
 #include "CommonDataFormat/RangeReference.h"
@@ -43,11 +44,12 @@ struct SectorFlushBuffers {
 /// Digitize all collisions of one sector of a timeframe.
 /// After each flush the new output is in buffers and onFlush is called on the calling thread.
 /// The function makes no DPL calls. Concurrent calls need one Digitizer with sector seeding and one set of chains
-/// per thread; Digitizer::init() is called here and is not thread-safe across Digitizer instances.
+/// per thread, and a common cdbMutex, which serialises the calls that read calibrations through the CDBInterface.
 /// \return the digit groups, one per collision part in triggered mode, one for the timeframe in continuous mode
 std::vector<dataformats::RangeReference<int, int>> digitizeSector(Digitizer& digitizer, const steer::DigitizationContext& context,
                                                                   const std::vector<TChain*>& simChains, int sector, ULong64_t timeframe,
-                                                                  SectorFlushBuffers& buffers, const std::function<void()>& onFlush);
+                                                                  SectorFlushBuffers& buffers, const std::function<void()>& onFlush,
+                                                                  std::mutex* cdbMutex = nullptr);
 
 } // namespace tpc
 } // namespace o2