@@ -1008,7 +1008,8 @@ void* CcdbApi::extractFromTFile(TFile& file, TClass const* cl, const char* what)
   auto result = object;
   // We need to handle some specific cases as ROOT ties them deeply
   // to the file they are contained in
-  if (cl->InheritsFrom("TObject")) {
+  // IsTObject avoids InheritsFrom, which makes cling instantiate STL collection classes
+  if (cl->IsTObject()) {
     // make a clone
     // detach from the file
     auto tree = dynamic_cast<TTree*>((TObject*)object);
 
@@ -22,6 +22,7 @@
 #include <list>
 #include <cstddef>
 #include <atomic>
+#include <mutex>
 
 #if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
 #include <boost/interprocess/managed_external_buffer.hpp>
@@ -70,7 +71,8 @@ class ShmManager
 
   // create the local segment
   // this will occupy a subregion of an already created global shared mem segment
-  void occupySegment();
+  // (all of it for the single process of multithreaded Geant4, whose threads share it)
+  void occupySegment(bool wholeRegion = false);
 
   // simply attaches to the global segment
   bool attachToGlobalSegment();
@@ -88,7 +90,7 @@ class ShmManager
   // returns if pointer is part of the shm region under control of this manager
   bool isPointerOk(void* ptr) const
   {
-    return mBufferPtr && getPointerOffset(ptr) < SHMPOOLSIZE;
+    return mBufferPtr && getPointerOffset(ptr) < mPoolSize;
   }
 
   // returns if shared mem setup is correctly setup/operational
@@ -114,6 +116,8 @@ class ShmManager
   ShmMetaInfo* mSegInfoPtr = nullptr; // pointing to the meta information object
   bool mIsMaster = false;             // true if the manager who allocated the region
   bool mIsOperational = false;
+  size_t mPoolSize = SHMPOOLSIZE; // size of the region occupied by this process
+  std::mutex mAllocMutex;         // the boost buffer has no locking of its own; threads of multithreaded Geant4 share it
   // helper function
   void* tryAttach(bool& success);
   size_t getPointerOffset(void* ptr) const { return (size_t)((char*)ptr - (char*)mBufferPtr); }
 
@@ -178,7 +178,7 @@ bool ShmManager::attachToGlobalSegment()
   return b;
 }
 
-void ShmManager::occupySegment()
+void ShmManager::occupySegment(bool wholeRegion)
 {
   LOG(info) << "OCCUPYING A SEGMENT IN A SHARED REGION";
   // get information about the global shared mem in which to occupy a region
@@ -197,15 +197,17 @@ void ShmManager::occupySegment()
   if (b) {
     // read meta information in the segment to determine the id of this segment
     auto info = static_cast<o2::utils::ShmMetaInfo*>(addr);
-    const int segmentcounter = info->counter.fetch_add(1);
+    const int npools = wholeRegion ? (info->allocedbytes - sizeof(ShmMetaInfo)) / SHMPOOLSIZE : 1;
+    const int segmentcounter = info->counter.fetch_add(npools);
     LOG(info) << "SEGMENTCOUNT " << segmentcounter;
 
     const auto offset_in_bytes = sizeof(ShmMetaInfo) + segmentcounter * SHMPOOLSIZE;
     mBufferPtr = (void*)(((char*)addr) + offset_in_bytes);
+    mPoolSize = npools * SHMPOOLSIZE;
 
-    assert((unsigned long long)((char*)mBufferPtr - (char*)addr) + SHMPOOLSIZE <= info->allocedbytes);
+    assert((unsigned long long)((char*)mBufferPtr - (char*)addr) + mPoolSize <= info->allocedbytes);
 
-    boostmanagedbuffer = new boost::interprocess::wmanaged_external_buffer(create_only, mBufferPtr, SHMPOOLSIZE);
+    boostmanagedbuffer = new boost::interprocess::wmanaged_external_buffer(create_only, mBufferPtr, mPoolSize);
     boostallocator = new boost::interprocess::allocator<char, wmanaged_external_buffer::segment_manager>(
       boostmanagedbuffer->get_segment_manager());
 
@@ -225,6 +227,7 @@ ShmManager::~ShmManager()
 void* ShmManager::getmemblock(size_t size)
 {
   void* addr = nullptr;
+  std::lock_guard<std::mutex> lock(mAllocMutex);
   try {
     addr = (void*)boostallocator->allocate(size).get();
   } catch (const std::exception& e) {
@@ -235,6 +238,7 @@ void* ShmManager::getmemblock(size_t size)
 
 void ShmManager::freememblock(void* ptr, size_t s)
 {
+  std::lock_guard<std::mutex> lock(mAllocMutex);
   boostallocator->deallocate((char*)ptr, s);
 }
 
 
@@ -57,6 +57,7 @@ enum class FairMCApplicationState
  * @since 12.01.04
  */
 
+class FairModule;
 class FairMCApplication : public TVirtualMCApplication
 {
   public:
@@ -304,16 +305,24 @@ class FairMCApplication : public TVirtualMCApplication
 
     ClassDef(FairMCApplication, 4);
 
-  private:
-    /** Protected copy constructor */
+  protected:
+    /** Copy constructor, used to create the application of a worker thread */
     FairMCApplication(const FairMCApplication&);
+
+  private:
     /** Protected assignment operator */
     FairMCApplication& operator=(const FairMCApplication&);
 
     FairRunInfo fRunInfo;   //!
     Bool_t fGeometryIsInitialized;
 
     static FairMCApplication* fgMasterInstance;
+
+  protected:
+    /** True for the application on the master thread, false for a worker clone */
+    Bool_t IsMasterApplication() const { return !fgMasterInstance || fgMasterInstance == this; }
+    /** The worker clone of a module of the master application (the module itself on the master) */
+    FairModule* OwnModule(FairModule* module) const;
 };
 
 // inline functions
 
@@ -159,6 +159,10 @@ class FairModule : public TNamed
     Bool_t fGeoSaved;   //! flag for initialisation
     TVirtualMC* fMC;    //! cahed pointer to MC (available only after initialization)
 
+  public:
+    /** Sets the cached MC, for a module cloned for a worker thread before its MC existed */
+    void SetMC(TVirtualMC* mc) { fMC = mc; }
+
     ClassDef(FairModule, 4);
 };
 
 
@@ -613,6 +613,20 @@ TVirtualMCApplication* FairMCApplication::CloneForWorker() const
     return workerApplication;
 }
 
+//_____________________________________________________________________________
+FairModule* FairMCApplication::OwnModule(FairModule* module) const
+{
+    // the worker's clone of a module, found by name
+    if (!module || IsMasterApplication() || fModules->IndexOf(module) >= 0) {
+        return module;
+    }
+    auto clone = static_cast<FairModule*>(fModules->FindObject(module->GetName()));
+    if (!clone) {
+        LOG(fatal) << "FairMCApplication: no worker clone for module " << module->GetName();
+    }
+    return clone;
+}
+
 //_____________________________________________________________________________
 void FairMCApplication::InitOnWorker()
 {
@@ -1014,7 +1028,8 @@ void FairMCApplication::InitGeometry()
     while ((obj = fModIter->Next())) {
         detector = dynamic_cast<FairDetector*>(obj);
         module = dynamic_cast<FairModule*>(obj);
-        if (module) {
+        if (module && IsMasterApplication()) {
+            // media cuts are set once on the master; multithreaded Geant4 workers share them
             module->SetSpecialPhysicsCuts();
         }
         if (detector) {
@@ -1101,21 +1116,30 @@ void FairMCApplication::InitGeometry()
                     }
                     FairVolume* fNewV = new FairVolume(fv->GetName(), id);
                     fNewV->setModId(fv->getModId());
-                    fNewV->SetModule(fv->GetModule());
+                    fNewV->SetModule(OwnModule(fv->GetModule()));
                     fNewV->setCopyNo(fN->GetNumber());
                     fNewV->setMCid(id);
                     fVolMap.insert(pair<Int_t, FairVolume*>(id, fNewV));
                 }
             } else {
                 FairVolume* fNewV = new FairVolume(fv->GetName(), id);
                 fNewV->setModId(fv->getModId());
-                fNewV->SetModule(fv->GetModule());
+                fNewV->SetModule(OwnModule(fv->GetModule()));
                 fNewV->setCopyNo(1);
                 fNewV->setMCid(id);
                 fVolMap.insert(pair<Int_t, FairVolume*>(id, fNewV));
             }
-        } else {
+        } else if (IsMasterApplication()) {
             fVolMap.insert(pair<Int_t, FairVolume*>(id, fv));
+        } else {
+            // the volume object is shared with the master; a worker needs its own, pointing at its own module
+            FairVolume* fNewV = new FairVolume(fv->GetName(), id);
+            fNewV->setModId(fv->getModId());
+            fNewV->SetModule(OwnModule(fv->GetModule()));
+            fNewV->setCopyNo(fv->getCopyNo());
+            fNewV->setMCid(id);
+            fNewV->setGeoNode(fv->getGeoNode());
+            fVolMap.insert(pair<Int_t, FairVolume*>(id, fNewV));
         }
     }   // end off loop Fill sensitive volumes
 
 
@@ -186,7 +186,7 @@ void BarrelAlignmentSpec::init(InitContext& ic)
         mTRDTransformer->setApplyXOR();
       }
       auto prevShift = mTRDTransformer->isShiftApplied();
-      if (getenv("ALIEN_JDL_LPMPRODUCTIONTYPE") && std::strcmp(getenv("ALIEN_JDL_LPMPRODUCTIONTYPE"), "MC") == 0) {
+      if ((getenv("ALIEN_JDL_LPMPRODUCTIONTYPE") && std::strcmp(getenv("ALIEN_JDL_LPMPRODUCTIONTYPE"), "MC") == 0) || !ic.options().get<bool>("apply-shift")) {
         // apply artificial pad shift in case non-ideal alignment is used to compensate for shift in current alignment from real data
         mTRDTransformer->setApplyShift(false);
       }
@@ -365,6 +365,7 @@ DataProcessorSpec getBarrelAlignmentSpec(GTrackID::mask_t srcMP, GTrackID::mask_
   bool loadTPCCalib = false;
   Options opts{
     ConfigParamSpec{"apply-xor", o2::framework::VariantType::Bool, false, {"flip the 8-th bit of slope and position (for processing TRD CTFs from 2021 pilot beam)"}},
+    ConfigParamSpec{"apply-shift", o2::framework::VariantType::Bool, true, {"whether we apply the one pad shift for the TRD in data (never applied in MC)"}},
     ConfigParamSpec{"allow-afterburner-tracks", VariantType::Bool, false, {"allow using ITS-TPC afterburner tracks"}},
     ConfigParamSpec{"ignore-ccdb-alignment", VariantType::Bool, false, {"do not aplly CCDB alignment to ideal geometry"}},
     ConfigParamSpec{"initial-params-file", VariantType::String, "", {"initial parameters file"}},
 
@@ -35,6 +35,7 @@ o2_add_library(DetectorsBase
                        src/Stack.cxx
                        src/VMCSeederService.cxx
                        src/SimRandom.cxx
+                       src/MTWorkerHooks.cxx
                        src/GlobalParams.cxx
                        src/O2Tessellated.cxx
                        src/TGeoGeometryUtils.cxx
@@ -97,6 +98,13 @@ o2_add_test(
   PUBLIC_LINK_LIBRARIES O2::DetectorsBase
   LABELS detectorsbase)
 
+o2_add_test(
+  DetImplClone
+  SOURCES test/testDetImplClone.cxx
+  COMPONENT_NAME DetectorsBase
+  PUBLIC_LINK_LIBRARIES O2::DetectorsBase
+  LABELS detectorsbase)
+
 o2_add_test(
   O2Tessellated
   SOURCES test/testO2Tessellated.cxx
 
@@ -219,6 +219,9 @@ class Detector : public FairDetector
   // ... for things that should be setup in each simulation worker separately)
   virtual void initializeLate() = 0;
 
+  /// whether this detector may run in multithreaded Geant4, with one clone per worker thread
+  virtual bool isMTSafe() const { return false; }
+
   /// helper wrapper function to register a geometry volume given by name with FairRoot
   /// @returns The MonteCarlo ID for the volume
   int registerSensitiveVolumeAndGetVolID(std::string const& name);
@@ -334,6 +337,10 @@ class DetImpl : public o2::base::Detector
   // offer same constructors as base
   using Detector::Detector;
 
+  /// copy for a worker thread of multithreaded Geant4; the copy creates its own hit buffers in initializeLate
+  DetImpl(const DetImpl& rhs) : Detector(rhs) {}
+  DetImpl& operator=(const DetImpl&) = delete;
+
   // default implementation for getHitBranchNames
   std::string getHitBranchNames(int probe) const override
   {
 
@@ -0,0 +1,52 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_BASE_MTWORKERHOOKS_H
+#define ALICEO2_BASE_MTWORKERHOOKS_H
+
+#include <functional>
+#include <memory>
+#include <fairmq/FwdDecls.h>
+
+class TVirtualMCDecayer;
+
+namespace o2::data
+{
+class PrimaryChunk;
+}
+
+namespace o2::base
+{
+
+/// What the simulation setup provides to the transport threads of multithreaded Geant4.
+/// Installed once on the master thread before transport starts; each function is called on a worker thread.
+struct MTWorkerHooks {
+  /// Returns the next chunk of primaries for the calling thread, or nullptr when there is no more work
+  std::function<std::unique_ptr<o2::data::PrimaryChunk>()> fetchChunk;
+  /// Returns the calling thread's channel to the hit merger
+  std::function<fair::mq::Channel*()> dataChannel;
+  /// Creates the external decayer of the calling thread (empty if there is none)
+  std::function<TVirtualMCDecayer*()> makeDecayer;
+  /// Ends the event loop of the calling thread after the current event
+  std::function<void()> stopWorker;
+  /// Called on a worker thread at the start of each run, after its user actions exist
+  std::function<void()> beginRunOnWorker;
+  /// Called once on the master thread after initialisation and before the first transport
+  std::function<void()> beforeTransport;
+  /// Called on a worker thread at the start of each track
+  std::function<void()> beginTrack;
+
+  static MTWorkerHooks& instance();
+};
+
+} // namespace o2::base
+
+#endif