@@ -154,6 +154,15 @@ class Digitizer
   /// Set the timeframe identifier that enters the sector seeding
   void setSeedingTimeframe(ULong64_t timeframe) { mSeedingTimeframe = timeframe; }
 
+  /// Fill the random rings of the sector seeding, if not done yet
+  void initSectorSeeding();
+
+  /// Use copies of the sector-seeding random rings of another digitizer
+  void setSectorSeedingFrom(const Digitizer& other);
+
+  /// Whether flush() also flushes the process-wide debug streamer
+  void setFlushDebugStreamer(bool flush) { mFlushDebugStreamer = flush; }
+
  private:
   ElectronTransport& electronTransport();
   GEMAmplification& gemAmplification();
@@ -165,6 +174,7 @@ class Digitizer
   ULong64_t mSeed = 0;                                   //!< Base seed for sector seeding
   ULong64_t mSeedingTimeframe = 0;                       //!< Timeframe identifier for sector seeding
   bool mUseSectorSeeding = false;                        //!< Whether sector seeding is used
+  bool mFlushDebugStreamer = true;                       //!< Whether flush() flushes the debug streamer
 
   DigitContainer mDigitContainer;        ///< Container for the Digits
   std::vector<float> mSignalArray;       //!< Workspace for the shaped signal of one electron
 
@@ -31,6 +31,7 @@
 
 #include <fairlogger/Logger.h>
 #include <TRandom3.h>
+#include <mutex>
 
 ClassImp(o2::tpc::Digitizer);
 
@@ -42,6 +43,13 @@ Digitizer::Digitizer() = default;
 
 namespace
 {
+/// serialises the calls that read calibrations through the CDBInterface, which is not thread safe
+std::mutex& calibrationMutex()
+{
+  static std::mutex mutex;
+  return mutex;
+}
+
 // splitmix64 finaliser, to derive well separated seeds from the base seed
 ULong64_t mixSeed(ULong64_t x)
 {
@@ -80,17 +88,35 @@ void Digitizer::setUseSectorSeeding(ULong64_t seed)
   mSeed = seed;
 }
 
+void Digitizer::initSectorSeeding()
+{
+  if (mUseSectorSeeding && !mGEMAmplification) {
+    // the rings are filled once, in the construction order of the singletons
+    TRandom3 rng(toTRandom3Seed(mixSeed(mSeed)));
+    mGEMAmplification = std::make_unique<GEMAmplification>(&rng);
+    mElectronTransport = std::make_unique<ElectronTransport>(&rng);
+    mSAMPAProcessing = std::make_unique<SAMPAProcessing>(&rng);
+    mDigitContainer.setSAMPAProcessing(mSAMPAProcessing.get());
+  }
+}
+
+void Digitizer::setSectorSeedingFrom(const Digitizer& other)
+{
+  mUseSectorSeeding = other.mUseSectorSeeding;
+  mSeed = other.mSeed;
+  if (other.mGEMAmplification) {
+    mGEMAmplification = std::make_unique<GEMAmplification>(*other.mGEMAmplification);
+    mElectronTransport = std::make_unique<ElectronTransport>(*other.mElectronTransport);
+    mSAMPAProcessing = std::make_unique<SAMPAProcessing>(*other.mSAMPAProcessing);
+    mDigitContainer.setSAMPAProcessing(mSAMPAProcessing.get());
+  }
+}
+
 void Digitizer::init()
 {
+  std::lock_guard<std::mutex> lock(calibrationMutex());
   if (mUseSectorSeeding) {
-    if (!mGEMAmplification) {
-      // the rings are filled once, in the construction order of the singletons
-      TRandom3 rng(toTRandom3Seed(mixSeed(mSeed)));
-      mGEMAmplification = std::make_unique<GEMAmplification>(&rng);
-      mElectronTransport = std::make_unique<ElectronTransport>(&rng);
-      mSAMPAProcessing = std::make_unique<SAMPAProcessing>(&rng);
-      mDigitContainer.setSAMPAProcessing(mSAMPAProcessing.get());
-    }
+    initSectorSeeding();
     const ULong64_t sectorSeed = mixSeed(mSeed ^ mixSeed(static_cast<ULong64_t>(mSector) + 1));
     TRandom3 rng(toTRandom3Seed(mixSeed(sectorSeed ^ mixSeed(mSeedingTimeframe))));
     mGEMAmplification->setRandomRingPositions(rng);
@@ -230,7 +256,7 @@ void Digitizer::flush(std::vector<o2::tpc::Digit>& digits,
   SAMPAProcessing& sampaProcessing = this->sampaProcessing();
   mDigitContainer.fillOutputContainer(digits, labels, commonModeOutput, mSector, sampaProcessing.getTimeBinFromTime(mEventTime - mOutputDigitTimeOffset), mIsContinuous, finalFlush);
   // flushing debug output to file
-  if (((finalFlush && mIsContinuous) || (!mIsContinuous)) && mSpaceCharge) {
+  if (mFlushDebugStreamer && ((finalFlush && mIsContinuous) || (!mIsContinuous)) && mSpaceCharge) {
     o2::utils::DebugStreamer::instance()->flush();
   }
 }
@@ -289,7 +315,10 @@ void Digitizer::setStartTime(double time)
   // note that negative times w.r.t start of timeframe/data-taking == mOutputDigitTimeOffset
   // will yield the 0-th bin (due to casting logic in sampaProcessing)
   SAMPAProcessing& sampaProcessing = this->sampaProcessing();
-  sampaProcessing.updateParameters(mVDrift);
+  {
+    std::lock_guard<std::mutex> lock(calibrationMutex());
+    sampaProcessing.updateParameters(mVDrift);
+  }
   const auto timediff = time - mOutputDigitTimeOffset;
   const auto starttimebin = sampaProcessing.getTimeBinFromTime(timediff);
   mDigitContainer.setStartTime(starttimebin);
 
@@ -34,6 +34,7 @@
 #include "TPCCalibration/VDriftHelper.h"
 #include "TPCSimulation/Digitizer.h"
 #include "TPCSpaceCharge/SpaceCharge.h"
+#include "CommonUtils/DebugStreamer.h"
 #include <TChain.h>
 #include <TFile.h>
 #include <TROOT.h>
@@ -45,7 +46,6 @@
 #include <exception>
 #include <filesystem>
 #include <memory>
-#include <mutex>
 #include <optional>
 #include <string>
 #include <thread>
@@ -80,7 +80,7 @@ struct DigitizerWorker {
   std::string fileName() const { return "tpc_driftime_digits_lane" + std::to_string(id) + ".root"; }
 
   /// Digitize one sector and write it to the worker's digit file, in the format of the chunked writer of the lane spec
-  void processSector(const steer::DigitizationContext& context, int sector, ULong64_t timeframe, bool withMCTruth, std::mutex& cdbMutex)
+  void processSector(const steer::DigitizationContext& context, int sector, ULong64_t timeframe, bool withMCTruth)
   {
     std::unique_ptr<TFile> file(TFile::Open(fileName().c_str(), "UPDATE"));
     if (!file || file->IsZombie()) {
@@ -102,7 +102,7 @@ struct DigitizerWorker {
       }
       fill("TPCCommonMode_" + std::to_string(sector), &buffers.commonMode);
     };
-    digitizeSector(digitizer, context, chains, sector, timeframe, buffers, onFlush, &cdbMutex);
+    digitizeSector(digitizer, context, chains, sector, timeframe, buffers, onFlush);
     tree->SetEntries(flushCounter);
     file->Write("", TObject::kOverwrite);
     file->Close();
@@ -121,12 +121,7 @@ class TPCDPLDigitizerMTTask : public o2::base::BaseDPLDigitizer
 
     mWithMCTruth = o2::conf::DigiParams::Instance().mctruth;
     const auto triggeredMode = ic.options().get<bool>("TPCtriggered");
-    mRecalcDistortions = !(ic.options().get<bool>("do-not-recalculate-distortions"));
-    SC::setNThreads(ic.options().get<int>("n-threads-distortions"));
-    mUseCalibrationsFromCCDB = ic.options().get<bool>("TPCuseCCDB");
-    mMeanLumiDistortions = ic.options().get<float>("meanLumiDistortions");
-    mMeanLumiDistortionsDerivative = ic.options().get<float>("meanLumiDistortionsDerivative");
-    LOG(info) << "TPC calibrations from CCDB: " << mUseCalibrationsFromCCDB;
+    mConditions.init(ic, mDistortionType);
 
     // the workers share no random numbers: each digitizer seeds every sector from DigiParams.seed
     const auto seed = o2::conf::DigiParams::Instance().seed;
@@ -142,6 +137,8 @@ class TPCDPLDigitizerMTTask : public o2::base::BaseDPLDigitizer
       worker->digitizer.setContinuousReadout(!triggeredMode);
       worker->digitizer.setDistortionScaleType(mDistortionType);
       worker->digitizer.setUseSectorSeeding(sectorSeed);
+      // the main thread flushes the process-wide debug streamer after the workers
+      worker->digitizer.setFlushDebugStreamer(false);
     }
 
     // the merger picks up every lane file in the directory, so files of an earlier run must not survive
@@ -157,80 +154,33 @@ class TPCDPLDigitizerMTTask : public o2::base::BaseDPLDigitizer
 
   void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj)
   {
-    if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
-      return;
-    }
     // the maps are set on the first digitizer; the others share them once they are final
-    auto& digitizer = mWorkers[0]->digitizer;
-    if (matcher == ConcreteDataMatcher(o2::header::gDataOriginTPC, "TPCDIST", 0)) {
-      LOGP(info, "Updating distortion map");
-      digitizer.setUseSCDistortions(static_cast<SC*>(obj));
-      if (mMeanLumiDistortions >= 0) {
-        digitizer.setMeanLumiDistortions(mMeanLumiDistortions);
-      }
-    }
-    if (matcher == ConcreteDataMatcher(o2::header::gDataOriginTPC, "TPCDISTDERIV", 0)) {
-      LOGP(info, "Updating reference distortion map");
-      digitizer.setSCDistortionsDerivative(static_cast<SC*>(obj));
-      if (mMeanLumiDistortionsDerivative >= 0) {
-        digitizer.setMeanLumiDistortionsDerivative(mMeanLumiDistortionsDerivative);
-      }
-    }
-    if (matcher == ConcreteDataMatcher(o2::header::gDataOriginTPC, "TPCGASPARAM", 0)) {
-      LOGP(info, "TPC gas param updated");
-      ParameterGas::Instance().printKeyValues(true, true);
-    }
-    if (matcher == ConcreteDataMatcher(o2::header::gDataOriginTPC, "TPCGEMPARAM", 0)) {
-      LOGP(info, "TPC GEM param updated");
-      ParameterGEM::Instance().printKeyValues(true, true);
-    }
+    mConditions.finaliseCCDB(matcher, obj, mWorkers[0]->digitizer);
   }
 
   void run(framework::ProcessingContext& pc)
   {
     LOG(info) << "Processing multithreaded TPC digitization";
 
-    auto& cdb = o2::tpc::CDBInterface::instance();
-    cdb.setUseDefaults(!mUseCalibrationsFromCCDB);
-    // whatever are global settings for CCDB usage, we have to extract the TPC vdrift from CCDB for anchored simulations
-    mTPCVDriftHelper.extractCCDBInputs(pc);
-    pc.inputs().get<ParameterGas*>("gasparam");
-    pc.inputs().get<ParameterGEM*>("gemparam");
     auto& primary = mWorkers[0]->digitizer;
-    if (mDistortionType) {
-      pc.inputs().get<SC*>("tpcdistortions");
-      if (mDistortionType == 2) {
-        pc.inputs().get<SC*>("tpcdistortionsderiv");
-        primary.setLumiScaleFactor();
-        if (mRecalcDistortions) {
-          // done once, with the threads of SpaceCharge, for all workers
-          primary.recalculateDistortions();
-        }
+    mConditions.update(pc, primary, [this](float vdrift, float tdriftOffset) {
+      for (auto& worker : mWorkers) {
+        worker->digitizer.setVDrift(vdrift);
+        worker->digitizer.setTDriftOffset(tdriftOffset);
       }
+    });
+    if (mDistortionType) {
       for (size_t i = 1; i < mWorkers.size(); ++i) {
         mWorkers[i]->digitizer.setSCDistortionsFrom(primary);
       }
     }
-
-    if (mTPCVDriftHelper.isUpdated()) {
-      const auto& vd = mTPCVDriftHelper.getVDriftObject();
-      LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
-           vd.corrFact, vd.refVDrift, vd.timeOffsetCorr, vd.refTimeOffset, mTPCVDriftHelper.getSourceName());
-      for (auto& worker : mWorkers) {
-        worker->digitizer.setVDrift(vd.getVDrift());
-        worker->digitizer.setTDriftOffset(vd.getTimeOffset());
+    if (!mSeedingShared) {
+      // the rings depend only on the seed, so they are filled once and copied
+      primary.initSectorSeeding();
+      for (size_t i = 1; i < mWorkers.size(); ++i) {
+        mWorkers[i]->digitizer.setSectorSeedingFrom(primary);
       }
-      mTPCVDriftHelper.acknowledgeUpdate();
-    }
-
-    if (std::filesystem::exists("ThresholdMap.root")) {
-      LOG(info) << "TPC: Using zero suppression map from 'ThresholdMap.root'";
-      cdb.setThresholdMapFromFile("ThresholdMap.root");
-    }
-
-    if (std::filesystem::exists("GainMap.root")) {
-      LOG(info) << "TPC: Using gain map from 'GainMap.root'";
-      cdb.setGainMapFromFile("GainMap.root");
+      mSeedingShared = true;
     }
 
     // the sectors of this timeframe; all inputs carry the same collision context
@@ -266,6 +216,11 @@ class TPCDPLDigitizerMTTask : public o2::base::BaseDPLDigitizer
     if (!contextRef) {
       return;
     }
+    // the chunked digit files and the dynamic sector scheduling hold one timeframe per process
+    if (mProcessedTimeframe) {
+      LOG(fatal) << "TPC: the multithreaded digitizer supports only one timeframe per process";
+    }
+    mProcessedTimeframe = true;
     auto context = pc.inputs().get<o2::steer::DigitizationContext*>(*contextRef);
     const ULong64_t timeframe = DataRefUtils::getHeader<o2::header::DataHeader*>(*contextRef)->tfCounter;
     LOG(info) << "TPC: Processing " << sectors.size() << " sectors with " << context->getEventRecords().size() << " collisions";
@@ -278,16 +233,15 @@ class TPCDPLDigitizerMTTask : public o2::base::BaseDPLDigitizer
       context->initSimChains(o2::detectors::DetID::TPC, mWorkers[i]->chains);
     }
 
+    // the sectors go to the workers dynamically
     std::atomic<size_t> nextSector{0};
-    // serialises CDBInterface access; the CCDB timestamp must not change while the workers run
-    std::mutex cdbMutex;
     std::vector<std::thread> threads;
     for (size_t i = 0; i < nWorkers; ++i) {
       threads.emplace_back([&, worker = mWorkers[i].get()]() {
         try {
           for (size_t is = nextSector++; is < sectors.size(); is = nextSector++) {
             LOG(info) << "TPC: Worker " << worker->id << " processing sector " << sectors[is];
-            worker->processSector(*context, sectors[is], timeframe, mWithMCTruth, cdbMutex);
+            worker->processSector(*context, sectors[is], timeframe, mWithMCTruth);
           }
         } catch (...) {
           worker->error = std::current_exception();
@@ -298,6 +252,9 @@ class TPCDPLDigitizerMTTask : public o2::base::BaseDPLDigitizer
     for (auto& thread : threads) {
       thread.join();
     }
+    if (auto* streamer = o2::utils::DebugStreamer::instance()) {
+      streamer->flush();
+    }
     for (size_t i = 0; i < nWorkers; ++i) {
       if (mWorkers[i]->error) {
         std::rethrow_exception(mWorkers[i]->error);
@@ -310,15 +267,13 @@ class TPCDPLDigitizerMTTask : public o2::base::BaseDPLDigitizer
 
  private:
   std::vector<std::unique_ptr<DigitizerWorker>> mWorkers;
-  o2::tpc::VDriftHelper mTPCVDriftHelper{};
+  TPCDigitizerConditions mConditions;
+  bool mSeedingShared = false;      ///< whether the workers got the random rings of the first one
+  bool mProcessedTimeframe = false; ///< whether a timeframe was digitized
   int mNThreads = 1;
   int mDistortionType = 0;
   bool mWriteGRP = true;
   bool mWithMCTruth = true;
-  bool mUseCalibrationsFromCCDB = false;
-  bool mRecalcDistortions = false;
-  float mMeanLumiDistortions = -1;
-  float mMeanLumiDistortionsDerivative = -1;
 };
 
 o2::framework::DataProcessorSpec getTPCDigitizerMTSpec(int nThreads, std::vector<int> const& sectors, int distortionType)
@@ -327,15 +282,7 @@ o2::framework::DataProcessorSpec getTPCDigitizerMTSpec(int nThreads, std::vector
   for (auto sector : sectors) {
     inputs.emplace_back("collisioncontext" + std::to_string(sector), "SIM", "COLLISIONCONTEXT", static_cast<o2::header::DataHeader::SubSpecificationType>(sector), Lifetime::Timeframe);
   }
-  o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
-  inputs.emplace_back("gasparam", o2::header::gDataOriginTPC, "TPCGASPARAM", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::ParGas)));
-  inputs.emplace_back("gemparam", o2::header::gDataOriginTPC, "TPCGEMPARAM", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::ParGEM)));
-  if (distortionType) {
-    inputs.emplace_back("tpcdistortions", o2::header::gDataOriginTPC, "TPCDIST", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::DistortionMapMC), {}, 1)); // time-dependent
-    if (distortionType == 2) {
-      inputs.emplace_back("tpcdistortionsderiv", o2::header::gDataOriginTPC, "TPCDISTDERIV", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::DistortionMapDerivMC), {}, 1)); // time-dependent
-    }
-  }
+  TPCDigitizerConditions::addInputs(inputs, distortionType);
   std::vector<OutputSpec> outputs{{"TPC", "ROMode", 0, Lifetime::Timeframe}};
 
   // the name must not match "TPCDigitizer.*", whose completion policy would process the sectors one by one
@@ -344,14 +291,7 @@ o2::framework::DataProcessorSpec getTPCDigitizerMTSpec(int nThreads, std::vector
     inputs,
     outputs,
     AlgorithmSpec{adaptFromTask<TPCDPLDigitizerMTTask>(nThreads, distortionType)},
-    Options{
-      {"TPCtriggered", VariantType::Bool, false, {"Impose triggered RO mode (default: continuous)"}},
-      {"TPCuseCCDB", VariantType::Bool, false, {"true: load calibrations from CCDB; false: use random calibratoins"}},
-      {"meanLumiDistortions", VariantType::Float, -1.f, {"override lumi of distortion object if >=0"}},
-      {"meanLumiDistortionsDerivative", VariantType::Float, -1.f, {"override lumi of derivative distortion object if >=0"}},
-      {"do-not-recalculate-distortions", VariantType::Bool, false, {"Do not recalculate the distortions"}},
-      {"n-threads-distortions", VariantType::Int, 4, {"Number of threads used for the calculation of the distortions"}},
-    }};
+    TPCDigitizerConditions::options()};
 }
 
 } // namespace tpc