InnerDetector/InDetConfig/python/VertexFindingFlags.py

@@ -164,10 +164,10 @@ def createPriVertexingFlags():
     flags.addFlag("maxAbsEta", 9999.0)
     flags.addFlag("maxD0", 4.0 * Units.mm)
     flags.addFlag("maxNPixelHoles", 1)
-    flags.addFlag("maxSigmaD0", 5.0)
-    flags.addFlag("maxSigmaZ0SinTheta", 10.0)
+    flags.addFlag("maxSigmaD0", 5.0 * Units.mm)
+    flags.addFlag("maxSigmaZ0SinTheta", 10.0 * Units.mm)
     flags.addFlag("maxZ0", 1000.0 * Units.mm)
-    flags.addFlag("maxZ0SinTheta", 1000.0)
+    flags.addFlag("maxZ0SinTheta", 1000.0 * Units.mm)
     flags.addFlag("minNInnermostLayerHits", 0)
     flags.addFlag("minNPixelHits", 1)
     flags.addFlag("minNSctHits", 4)
@@ -175,6 +175,7 @@ def createPriVertexingFlags():
     flags.addFlag("minNTrtHits", 0)
     flags.addFlag("minPt", 500.0 * Units.MeV)
     flags.addFlag("maxZinterval", 3)
+    # MaxTracks cuts are specific to the IterativeFinding config
     flags.addFlag("doMaxTracksCut", True)
     flags.addFlag("MaxTracks", 3000)
     # string to store the setup for primary vertexing.
@@ -195,5 +196,13 @@ def createITkPriVertexingFlags():
     flags = createPriVertexingFlags()
 
     flags.minNTrtHits = 0
+    flags.minPt = 900.0 * Units.MeV
+    flags.maxD0 = 1.0 * Units.mm
+    flags.maxSigmaD0 = 0.35 * Units.mm
+    flags.maxSigmaZ0SinTheta = 2.5 * Units.mm
+    flags.minNPixelHits = 3
+    flags.minNSctHits = 0
+    flags.minNSiHits = 7
+    flags.maxZinterval = 0.5
 
     return flags

InnerDetector/InDetDigitization/FastSiDigitization/FastSiDigitization/PixelFastDigitizationTool.h

 /*
-  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////
@@ -86,58 +86,58 @@ public:
 private:
 
 
-  TimedHitCollection<SiHit>* m_thpcsi;
+  TimedHitCollection<SiHit>* m_thpcsi{};
 
   ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""};  //!< Random number service
 
-  std::string                m_randomEngineName;         //!< Name of the random number stream
+  StringProperty                m_randomEngineName{this, "RndmEngine", "FastPixelDigitization"};         //!< Name of the random number stream
 
-  const PixelID* m_pixel_ID;                             //!< Handle to the ID helper
+  const PixelID* m_pixel_ID{};                             //!< Handle to the ID helper
 
-  ToolHandle<InDet::ClusterMakerTool>  m_clusterMaker;   //!< ToolHandle to ClusterMaker
+  PublicToolHandle<InDet::ClusterMakerTool>  m_clusterMaker{this, "ClusterMaker", "InDet::ClusterMakerTool/FatrasClusterMaker"};   //!< ToolHandle to ClusterMaker
   ToolHandle<ISiLorentzAngleTool> m_lorentzAngleTool{this, "LorentzAngleTool", "PixelLorentzAngleTool", "Tool to retreive Lorentz angle"};
-  bool                                  m_pixUseClusterMaker; //!< use the pixel cluster maker or not
+  BooleanProperty                                  m_pixUseClusterMaker{this, "PixelUseClusterMaker", true}; //!< use the pixel cluster maker or not
 
-  InDet::PixelClusterContainer*         m_pixelClusterContainer;               //!< the PixelClusterContainer
-  std::string                           m_pixel_SiClustersName;
+  InDet::PixelClusterContainer*         m_pixelClusterContainer{};               //!< the PixelClusterContainer
+  StringProperty                           m_pixel_SiClustersName{this, "PixelClusterContainerName", "PixelClusters"};
 
-  ServiceHandle<PileUpMergeSvc> m_mergeSvc;      /**< PileUp Merge service */
-  int                       m_HardScatterSplittingMode; /**< Process all SiHit or just those from signal or background events */
-  bool                      m_HardScatterSplittingSkipper;
+  ServiceHandle<PileUpMergeSvc> m_mergeSvc{this, "MergeSvc", "PileUpMergeSvc"};      /**< PileUp Merge service */
+  IntegerProperty    m_HardScatterSplittingMode{this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting"}; /**< Process all SiHit or just those from signal or background events */
+  bool                      m_HardScatterSplittingSkipper{false};
 
   typedef std::multimap<IdentifierHash, InDet::PixelCluster*> Pixel_detElement_RIO_map;
-  Pixel_detElement_RIO_map* m_pixelClusterMap;
-
-  std::string                           m_prdTruthNamePixel;
-  PRD_MultiTruthCollection*             m_pixPrdTruth;              //!< the PRD truth map for Pixel measurements
-
-  ToolHandle< InDet::PixelGangedAmbiguitiesFinder > m_gangedAmbiguitiesFinder;
-
-  std::string m_inputObjectName;     //! name of the sub event  hit collections.
-
-  std::vector<SiHitCollection*> m_siHitCollList;
-
-  double                                m_pixTanLorentzAngleScalor; //!< scale the lorentz angle effect
-  bool                                  m_pixEmulateSurfaceCharge;  //!< emulate the surface charge
-  double                                m_pixSmearPathLength;       //!< the 2. model parameter: smear the path
-  bool                                  m_pixSmearLandau;           //!< if true : landau else: gauss
-  double                                m_pixMinimalPathCut;        //!< the 1. model parameter: minimal 3D path in pixel
-  double                                m_pixPathLengthTotConv;     //!< from path length to tot
-  bool                                  m_pixModuleDistortion;       //!< simulationn of module bowing
-  std::vector<double>                   m_pixPhiError;              //!< phi error when not using the ClusterMaker
-  std::vector<double>                   m_pixEtaError;              //!< eta error when not using the ClusterMaker
-  int                                   m_pixErrorStrategy;         //!< error strategy for the  ClusterMaker
-  double                                m_pixDiffShiftBarrX; //Shift of the track to improve cluster size description
-  double                                m_pixDiffShiftBarrY; //Shift of the track to improve cluster size description
-  double                                m_pixDiffShiftEndCX; //Shift of the track to improve cluster size description
-  double                                m_pixDiffShiftEndCY; //Shift of the track to improve cluster size description
-  double                                m_ThrConverted;
-
-  bool m_mergeCluster; //!< enable the merging of neighbour Pixel clusters >
-  short m_splitClusters; //!< merging parameter used to define two clusters as neighbour >
-  bool m_acceptDiagonalClusters; //!< merging parameter used to define two clusters as neighbour >
-  std::string                           m_pixelClusterAmbiguitiesMapName;
-  InDet::PixelGangedClusterAmbiguities* m_ambiguitiesMap;
+  Pixel_detElement_RIO_map* m_pixelClusterMap{};
+
+  StringProperty                           m_prdTruthNamePixel{this, "TruthNamePixel", "PRD_MultiTruthPixel"};
+  PRD_MultiTruthCollection*             m_pixPrdTruth{};              //!< the PRD truth map for Pixel measurements
+
+  PublicToolHandle< InDet::PixelGangedAmbiguitiesFinder > m_gangedAmbiguitiesFinder{this, "gangedAmbiguitiesFinder", "InDet::PixelGangedAmbiguitiesFinder"};
+
+  StringProperty m_inputObjectName{this, "InputObjectName", "PixelHits"};     //! name of the sub event  hit collections.
+
+  std::vector<SiHitCollection*> m_siHitCollList{};
+
+  double                                m_pixTanLorentzAngleScalor{1.}; //!< scale the lorentz angle effect
+  BooleanProperty                m_pixEmulateSurfaceCharge{this, "PixelEmulateSurfaceCharge", true};  //!< emulate the surface charge
+  DoubleProperty                  m_pixSmearPathLength{this, "PixelSmearPathSigma", 0.01};       //!< the 2. model parameter: smear the path
+  BooleanProperty                m_pixSmearLandau{this, "PixelSmearLandau", true};           //!< if true : landau else: gauss
+  DoubleProperty                  m_pixMinimalPathCut{this, "PixelMinimalPathLength", 0.06};        //!< the 1. model parameter: minimal 3D path in pixel
+  DoubleProperty                  m_pixPathLengthTotConv{this, "PixelPathLengthTotConversion", 125.};     //!< from path length to tot
+  BooleanProperty                m_pixModuleDistortion{this, "PixelEmulateModuleDistortion", true};       //!< simulationn of module bowing
+  DoubleArrayProperty         m_pixPhiError{this, "PixelErrorPhi", {} };              //!< phi error when not using the ClusterMaker
+  DoubleArrayProperty         m_pixEtaError{this, "PixelErrorEta", {} };              //!< eta error when not using the ClusterMaker
+  IntegerProperty                  m_pixErrorStrategy{this, "PixelErrorStrategy", 2};         //!< error strategy for the  ClusterMaker
+  DoubleProperty                  m_pixDiffShiftBarrX{this, "PixDiffShiftBarrX", 0.005}; //Shift of the track to improve cluster size description
+  DoubleProperty                  m_pixDiffShiftBarrY{this, "PixDiffShiftBarrY", 0.005}; //Shift of the track to improve cluster size description
+  DoubleProperty                  m_pixDiffShiftEndCX{this, "PixDiffShiftEndCX", 0.008}; //Shift of the track to improve cluster size description
+  DoubleProperty                  m_pixDiffShiftEndCY{this, "PixDiffShiftEndCY", 0.008}; //Shift of the track to improve cluster size description
+  DoubleProperty                  m_ThrConverted{this, "ThrConverted", 50000};
+
+  bool m_mergeCluster{true}; //!< enable the merging of neighbour Pixel clusters >
+  short m_splitClusters{0}; //!< merging parameter used to define two clusters as neighbour >
+  bool m_acceptDiagonalClusters{true}; //!< merging parameter used to define two clusters as neighbour >
+  StringProperty                    m_pixelClusterAmbiguitiesMapName{this, "PixelClusterAmbiguitiesMapName", "PixelClusterAmbiguitiesMap"};
+  InDet::PixelGangedClusterAmbiguities* m_ambiguitiesMap{};
   ServiceHandle<InDetDD::IPixelReadoutManager> m_pixelReadout
   {this, "PixelReadoutManager", "PixelReadoutManager", "Pixel readout manager" };
 
@@ -157,7 +157,7 @@ private:
 
   PixelFastDigitizationTool& operator=(const PixelFastDigitizationTool&);
 
-  ToolHandle<Trk::IModuleStepper>       m_digitizationStepper;
+  PublicToolHandle<Trk::IModuleStepper>       m_digitizationStepper{this, "DigitizationStepper", "Trk::PlanarModuleStepper"};
 
   Trk::DigitizationModule * buildDetectorModule(const InDetDD::SiDetectorElement* ) const;
 

InnerDetector/InDetDigitization/FastSiDigitization/FastSiDigitization/SCT_FastDigitizationTool.h

@@ -2,7 +2,7 @@
 
 
 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef FASTSIDIGITZATION_SCT_FASTDIGITZATIONTOOL_H
@@ -102,48 +102,47 @@ public:
 private:
 
   StatusCode digitize(const EventContext& ctx);
-  StatusCode createOutputContainers();
   bool NeighbouringClusters(const std::vector<Identifier>& potentialClusterRDOList,  const InDet::SCT_Cluster *existingCluster) const;
   void Diffuse(HepGeom::Point3D<double>& localEntry, HepGeom::Point3D<double>& localExit, double shiftX, double shiftY ) const;
 
-  std::string m_inputObjectName;     //! name of the sub event  hit collections.
+  StringProperty m_inputObjectName{this, "InputObjectName", "SCT_Hits", "Input Object name"};     //! name of the sub event  hit collections.
 
   std::vector<SiHitCollection*> m_siHitCollList;
 
-  const SCT_ID* m_sct_ID;                              //!< Handle to the ID helper
-  ServiceHandle<PileUpMergeSvc> m_mergeSvc;            //!< PileUp Merge service
-  int                       m_HardScatterSplittingMode; /**< Process all SiHit or just those from signal or background events */
-  bool                      m_HardScatterSplittingSkipper;
+  const SCT_ID* m_sct_ID{};                              //!< Handle to the ID helper
+  ServiceHandle<PileUpMergeSvc> m_mergeSvc{this, "MergeSvc", "PileUpMergeSvc", "Merge service"};            //!< PileUp Merge service
+  IntegerProperty      m_HardScatterSplittingMode{this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting"}; /**< Process all SiHit or just those from signal or background events */
+  bool                      m_HardScatterSplittingSkipper{false};
 
   ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""};  //!< Random number service
-  std::string                   m_randomEngineName;    //!< Name of the random number stream
+  StringProperty      m_randomEngineName{this, "RndmEngine", "FastSCT_Digitization"};    //!< Name of the random number stream
 
-  TimedHitCollection<SiHit>* m_thpcsi;
+  TimedHitCollection<SiHit>* m_thpcsi{};
 
-  ToolHandle<InDet::ClusterMakerTool>  m_clusterMaker;
+  PublicToolHandle<InDet::ClusterMakerTool>  m_clusterMaker{this, "ClusterMaker", "InDet::ClusterMakerTool"};
   ToolHandle<ISiLorentzAngleTool> m_lorentzAngleTool{this, "LorentzAngleTool", "SiLorentzAngleTool/SCTLorentzAngleTool", "Tool to retreive Lorentz angle"};
 
   typedef std::multimap<IdentifierHash, InDet::SCT_Cluster*> SCT_detElement_RIO_map;
-  SCT_detElement_RIO_map* m_sctClusterMap;
+  SCT_detElement_RIO_map* m_sctClusterMap{};
 
-  SG::WriteHandle<InDet::SCT_ClusterContainer>  m_sctClusterContainer; //!< the SCT_ClusterContainer
-  SG::WriteHandle<PRD_MultiTruthCollection>     m_sctPrdTruth;         //!< the PRD truth map for SCT measurements
+  SG::WriteHandleKey<InDet::SCT_ClusterContainer>  m_sctClusterContainerKey{this, "SCT_ClusterContainerName", "SCT_Clusters"}; //!< the SCT_ClusterContainer
+  SG::WriteHandleKey<PRD_MultiTruthCollection>     m_sctPrdTruthKey{this, "TruthNameSCT", "PRD_MultiTruthSCT"};         //!< the PRD truth map for SCT measurements
   SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> m_SCTDetEleCollKey{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};
 
-  double m_sctSmearPathLength;       //!< the 2. model parameter: smear the path
-  bool m_sctSmearLandau;           //!< if true : landau else: gauss
-  bool m_sctEmulateSurfaceCharge;  //!< emulate the surface charge
-  double m_sctTanLorentzAngleScalor; //!< scale the lorentz angle effect
-  bool m_sctAnalogStripClustering; //!< not being done in ATLAS: analog strip clustering
-  int m_sctErrorStrategy;         //!< error strategy for the  ClusterMaker
-  bool m_sctRotateEC;
-
-  bool m_mergeCluster; //!< enable the merging of neighbour SCT clusters >
-  double m_DiffusionShiftX_barrel;
-  double m_DiffusionShiftY_barrel;
-  double m_DiffusionShiftX_endcap;
-  double m_DiffusionShiftY_endcap;
-  double m_sctMinimalPathCut;        //!< the 1. model parameter: minimal 3D path in strip
+  DoubleProperty m_sctSmearPathLength{this, "SCT_SmearPathSigma", 0.01};       //!< the 2. model parameter: smear the path
+  BooleanProperty m_sctSmearLandau{this, "SCT_SmearLandau", true};           //!< if true : landau else: gauss
+  BooleanProperty m_sctEmulateSurfaceCharge{this, "EmulateSurfaceCharge", true};  //!< emulate the surface charge
+  DoubleProperty m_sctTanLorentzAngleScalor{this, "SCT_ScaleTanLorentzAngle", 1.}; //!< scale the lorentz angle effect
+  BooleanProperty m_sctAnalogStripClustering{this, "SCT_AnalogClustering", false}; //!< not being done in ATLAS: analog strip clustering
+  IntegerProperty m_sctErrorStrategy{this, "SCT_ErrorStrategy", 2};         //!< error strategy for the  ClusterMaker
+  BooleanProperty m_sctRotateEC{this, "SCT_RotateEndcapClusters", true};
+
+  bool m_mergeCluster{true}; //!< enable the merging of neighbour SCT clusters >
+  DoubleProperty m_DiffusionShiftX_barrel{this, "DiffusionShiftX_barrel",4 };
+  DoubleProperty m_DiffusionShiftY_barrel{this, "DiffusionShiftY_barrel", 4};
+  DoubleProperty m_DiffusionShiftX_endcap{this, "DiffusionShiftX_endcap", 15};
+  DoubleProperty m_DiffusionShiftY_endcap{this, "DiffusionShiftY_endcap", 15};
+  DoubleProperty m_sctMinimalPathCut{this, "SCT_MinimalPathLength", 90.};        //!< the 1. model parameter: minimal 3D path in strip
 
   Amg::Vector3D stepToStripBorder(const InDetDD::SiDetectorElement& sidetel,
                                   //const Trk::Surface& surface,

InnerDetector/InDetDigitization/FastSiDigitization/python/FastSiDigitizationConfigDb.py

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 
 from AthenaCommon.CfgGetter import addTool
-addTool("FastSiDigitization.FastSiDigitizationConfig.PixelFastDigitizationTool"              , "PixelFastDigitizationTool")
-addTool("FastSiDigitization.FastSiDigitizationConfig.PixelFastDigitizationToolHS"            , "PixelFastDigitizationToolHS")
-addTool("FastSiDigitization.FastSiDigitizationConfig.PixelFastDigitizationToolPU"            , "PixelFastDigitizationToolPU")
-addTool("FastSiDigitization.FastSiDigitizationConfig.PixelFastDigitizationToolSplitNoMergePU", "PixelFastDigitizationToolSplitNoMergePU")
-addTool("FastSiDigitization.FastSiDigitizationConfig.getFastPixelRange"                      , "FastPixelRange")
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.PixelFastDigitizationTool"              , "PixelFastDigitizationTool")
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.PixelFastDigitizationToolHS"            , "PixelFastDigitizationToolHS")
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.PixelFastDigitizationToolPU"            , "PixelFastDigitizationToolPU")
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.PixelFastDigitizationToolSplitNoMergePU", "PixelFastDigitizationToolSplitNoMergePU")
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.getFastPixelRange"                      , "FastPixelRange")
 
-addTool("FastSiDigitization.FastSiDigitizationConfig.FastClusterMakerTool"                   , "FastClusterMakerTool")
-addTool("FastSiDigitization.FastSiDigitizationConfig.SCT_FastDigitizationTool"               , "SCT_FastDigitizationTool")
-addTool("FastSiDigitization.FastSiDigitizationConfig.SCT_FastDigitizationToolHS"             , "SCT_FastDigitizationToolHS")
-addTool("FastSiDigitization.FastSiDigitizationConfig.SCT_FastDigitizationToolPU"             , "SCT_FastDigitizationToolPU")
-addTool("FastSiDigitization.FastSiDigitizationConfig.SCT_FastDigitizationToolSplitNoMergePU" , "SCT_FastDigitizationToolSplitNoMergePU")
-addTool("FastSiDigitization.FastSiDigitizationConfig.getFastSCTRange"                        , "FastSCTRange" )
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.FastClusterMakerTool"                   , "FastClusterMakerTool")
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.SCT_FastDigitizationTool"               , "SCT_FastDigitizationTool")
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.SCT_FastDigitizationToolHS"             , "SCT_FastDigitizationToolHS")
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.SCT_FastDigitizationToolPU"             , "SCT_FastDigitizationToolPU")
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.SCT_FastDigitizationToolSplitNoMergePU" , "SCT_FastDigitizationToolSplitNoMergePU")
+addTool("FastSiDigitization.FastSiDigitizationConfigLegacy.getFastSCTRange"                        , "FastSCTRange" )

InnerDetector/InDetDigitization/FastSiDigitization/python/FastSiDigitizationConfigLegacy.py

+# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+
+# The earliest bunch crossing time for which interactions will be sent
+# to the Fast Pixel Digitization code.
+def FastPixel_FirstXing():
+    FirstXing = 0
+    from AthenaCommon.BeamFlags import jobproperties
+    if jobproperties.Beam.estimatedLuminosity()> 0.5e33:
+        FirstXing = 0
+    return FirstXing
+# The latest bunch crossing time for which interactions will be sent
+# to the Fast Pixel Digitization code.
+def FastPixel_LastXing():
+    LastXing = 0
+    from AthenaCommon.BeamFlags import jobproperties
+    if jobproperties.Beam.estimatedLuminosity()> 0.5e33:
+        if jobproperties.Beam.bunchSpacing.get_Value() > 50 :
+            LastXing = 0
+        else :
+            LastXing = 0
+    return LastXing
+# The earliest bunch crossing time for which interactions will be sent
+# to the Fast SCT Digitization code.
+def FastSCT_FirstXing():
+    return 0
+# The latest bunch crossing time for which interactions will be sent
+# to the Fast SCT Digitization code.
+def FastSCT_LastXing():
+    return 0
+
+def FastClusterMakerTool(name="FastClusterMakerTool", **kwargs):
+    from Digitization.DigitizationFlags import digitizationFlags
+    from AtlasGeoModel.CommonGMJobProperties import CommonGeometryFlags as commonGeoFlags
+    from AtlasGeoModel.InDetGMJobProperties import InDetGeometryFlags as geoFlags
+    #################################
+    # Config pixel conditions setup #
+    #################################
+    from IOVDbSvc.CondDB import conddb
+    from AthenaCommon.AppMgr import ToolSvc
+    from AthenaCommon.AlgSequence import AthSequencer
+    condSeq = AthSequencer("AthCondSeq")
+    #################
+    # Module status #
+    #################
+    if not hasattr(condSeq, "PixelConfigCondAlg"):
+        from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelConfigCondAlg
+        IdMappingDat="PixelCabling/Pixels_Atlas_IdMapping_2016.dat"
+        # ITk:
+        if geoFlags.isSLHC():
+            IdMappingDat = "ITk_Atlas_IdMapping.dat"
+            if "BrlIncl4.0_ref" == commonGeoFlags.GeoType():
+                IdMappingDat = "ITk_Atlas_IdMapping_InclBrl4.dat"
+            elif "IBrlExt4.0ref" == commonGeoFlags.GeoType():
+                IdMappingDat = "ITk_Atlas_IdMapping_IExtBrl4.dat"
+            elif "BrlExt4.0_ref" == commonGeoFlags.GeoType():
+                IdMappingDat = "ITk_Atlas_IdMapping_ExtBrl4.dat"
+            elif "BrlExt3.2_ref" == commonGeoFlags.GeoType():
+                IdMappingDat = "ITk_Atlas_IdMapping_ExtBrl32.dat"
+        elif (geoFlags.isIBL() is False):
+            IdMappingDat="PixelCabling/Pixels_Atlas_IdMapping.dat"
+        else:
+            # Planar IBL
+            if (geoFlags.IBLLayout() == "planar"):
+                if (geoFlags.isDBM() is True):
+                    IdMappingDat="PixelCabling/Pixels_Atlas_IdMapping_inclIBL_DBM.dat"
+                else:
+                    IdMappingDat="PixelCabling/Pixels_Atlas_IdMapping_inclIBL.dat"
+            # Hybrid IBL plus DBM
+            elif (geoFlags.IBLLayout() == "3D"):
+                IdMappingDat="PixelCabling/Pixels_Atlas_IdMapping_Run2.dat"
+        
+        condSeq += PixelConfigCondAlg(name="PixelConfigCondAlg", 
+                                      ReadDeadMapKey = "",
+                                      CablingMapFileName=IdMappingDat)
+
+    if not hasattr(condSeq, "PixelDeadMapCondAlg"):
+        from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDeadMapCondAlg
+        condSeq += PixelDeadMapCondAlg(name="PixelDeadMapCondAlg",ReadKey="")
+
+    #FIXME: at some point we should move away from being dependent on the experimentalDigi flags.
+    if 'doFastSCT_Digi' in digitizationFlags.experimentalDigi() and 'doFastPixelDigi' not in digitizationFlags.experimentalDigi():
+        # Set empty Folder
+        if commonGeoFlags.Run()=="RUN3":
+            if not hasattr(condSeq, 'PixelChargeLUTCalibCondAlg'):
+                from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelChargeLUTCalibCondAlg
+                condSeq += PixelChargeLUTCalibCondAlg(name="PixelChargeLUTCalibCondAlg", ReadKey="")
+        else:
+            if not hasattr(condSeq, 'PixelChargeCalibCondAlg'):
+                from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelChargeCalibCondAlg
+                condSeq += PixelChargeCalibCondAlg(name="PixelChargeCalibCondAlg", ReadKey="")
+
+    else:
+        #####################
+        # Calibration Setup #
+        #####################
+        if commonGeoFlags.Run()=="RUN3":
+            if not conddb.folderRequested("/PIXEL/ChargeCalibration"):
+                conddb.addFolder("PIXEL_OFL", "/PIXEL/ChargeCalibration", className="CondAttrListCollection")
+            if not hasattr(condSeq, 'PixelChargeLUTCalibCondAlg'):
+                from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelChargeLUTCalibCondAlg
+                condSeq += PixelChargeLUTCalibCondAlg(name="PixelChargeLUTCalibCondAlg", ReadKey="/PIXEL/ChargeCalibration")
+        else:
+            if not conddb.folderRequested("/PIXEL/PixCalib"):
+                conddb.addFolderSplitOnline("PIXEL", "/PIXEL/Onl/PixCalib", "/PIXEL/PixCalib", className="CondAttrListCollection")
+            if not hasattr(condSeq, 'PixelChargeCalibCondAlg'):
+                from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelChargeCalibCondAlg
+                condSeq += PixelChargeCalibCondAlg(name="PixelChargeCalibCondAlg", ReadKey="/PIXEL/PixCalib")
+
+        #####################
+        # Cabling map Setup #
+        #####################
+        if (conddb.dbmc=="OFLP200" and geoFlags.isIBL() is True) and not conddb.folderRequested("/PIXEL/HitDiscCnfg"):
+            conddb.addFolderSplitMC("PIXEL","/PIXEL/HitDiscCnfg","/PIXEL/HitDiscCnfg", className="AthenaAttributeList")
+
+            if not hasattr(condSeq, 'PixelHitDiscCnfgAlg'):
+                from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelHitDiscCnfgAlg
+                condSeq += PixelHitDiscCnfgAlg(name="PixelHitDiscCnfgAlg")
+
+        if not conddb.folderRequested("/PIXEL/ReadoutSpeed"):
+            conddb.addFolderSplitMC("PIXEL","/PIXEL/ReadoutSpeed","/PIXEL/ReadoutSpeed", className="AthenaAttributeList")
+
+        if not hasattr(condSeq, 'PixelReadoutSpeedAlg'):
+            from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelReadoutSpeedAlg
+            condSeq += PixelReadoutSpeedAlg(name="PixelReadoutSpeedAlg")
+
+        if not hasattr(condSeq, 'PixelCablingCondAlg'):
+            from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelCablingCondAlg
+            condSeq += PixelCablingCondAlg(name="PixelCablingCondAlg", ReadKey="")
+
+        if not conddb.folderRequested('/PIXEL/PixdEdx'):
+            conddb.addFolder("PIXEL_OFL", "/PIXEL/PixdEdx", className="AthenaAttributeList")
+
+        if not conddb.folderRequested("/PIXEL/PixReco"):
+            conddb.addFolder("PIXEL_OFL", "/PIXEL/PixReco", className="DetCondCFloat")
+
+        if not conddb.folderRequested("/Indet/PixelDist"):
+            conddb.addFolder("INDET", "/Indet/PixelDist", className="DetCondCFloat")
+
+        if not hasattr(condSeq, 'PixelOfflineCalibCondAlg'):
+            from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelOfflineCalibCondAlg
+            condSeq += PixelOfflineCalibCondAlg(name="PixelOfflineCalibCondAlg", ReadKey="/PIXEL/PixReco")
+            PixelOfflineCalibCondAlg.InputSource = 2
+
+        if not hasattr(ToolSvc, "PixelLorentzAngleTool"):
+            from SiLorentzAngleTool.PixelLorentzAngleToolSetup import PixelLorentzAngleToolSetup
+            PixelLorentzAngleToolSetup()
+
+        if not hasattr(condSeq, 'PixelDistortionAlg'):
+            from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelDistortionAlg
+            condSeq += PixelDistortionAlg(name="PixelDistortionAlg")
+
+        if not hasattr(condSeq, 'PixeldEdxAlg'):
+            from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixeldEdxAlg
+            condSeq += PixeldEdxAlg(name="PixeldEdxAlg")
+            PixeldEdxAlg.ReadFromCOOL = True
+
+    from AthenaCommon import CfgMgr
+    return CfgMgr.InDet__ClusterMakerTool(name,**kwargs)
+
+def commonPixelFastDigitizationConfig(name,**kwargs):
+
+    kwargs.setdefault("ClusterMaker", "FastClusterMakerTool")
+
+    # Import Digitization job properties
+    from Digitization.DigitizationFlags import digitizationFlags
+    from AtlasGeoModel.CommonGMJobProperties import CommonGeometryFlags as commonGeoFlags
+    kwargs.setdefault("RndmEngine", "FastPixelDigitization")
+
+    if digitizationFlags.doXingByXingPileUp():
+        kwargs.setdefault("FirstXing", FastPixel_FirstXing())
+        kwargs.setdefault("LastXing",  FastPixel_LastXing() )
+    
+    #################################
+    # Config pixel conditions setup #
+    #################################
+    from AthenaCommon.AlgSequence import AthSequencer
+    condSeq = AthSequencer("AthCondSeq")
+    #################
+    # Module status #
+    #################
+    if not hasattr(condSeq, "PixelConfigCondAlg"):
+        from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelConfigCondAlg
+        from AtlasGeoModel.InDetGMJobProperties import InDetGeometryFlags as geoFlags
+        IdMappingDat="PixelCabling/Pixels_Atlas_IdMapping_2016.dat"
+        # ITk:
+        if geoFlags.isSLHC():
+            IdMappingDat = "ITk_Atlas_IdMapping.dat"
+            if "BrlIncl4.0_ref" == commonGeoFlags.GeoType():
+                IdMappingDat = "ITk_Atlas_IdMapping_InclBrl4.dat"
+            elif "IBrlExt4.0ref" == commonGeoFlags.GeoType():
+                IdMappingDat = "ITk_Atlas_IdMapping_IExtBrl4.dat"
+            elif "BrlExt4.0_ref" == commonGeoFlags.GeoType():
+                IdMappingDat = "ITk_Atlas_IdMapping_ExtBrl4.dat"
+            elif "BrlExt3.2_ref" == commonGeoFlags.GeoType():
+                IdMappingDat = "ITk_Atlas_IdMapping_ExtBrl32.dat"
+        elif (geoFlags.isIBL() is False):
+            IdMappingDat="PixelCabling/Pixels_Atlas_IdMapping.dat"
+        else:
+            # Planar IBL
+            if (geoFlags.IBLLayout() == "planar"):
+                if (geoFlags.isDBM() is True):
+                    IdMappingDat="PixelCabling/Pixels_Atlas_IdMapping_inclIBL_DBM.dat"
+                else:
+                    IdMappingDat="PixelCabling/Pixels_Atlas_IdMapping_inclIBL.dat"
+            # Hybrid IBL plus DBM
+            elif (geoFlags.IBLLayout() == "3D"):
+                IdMappingDat="PixelCabling/Pixels_Atlas_IdMapping_Run2.dat"
+        
+        condSeq += PixelConfigCondAlg(name="PixelConfigCondAlg", 
+                                      ReadDeadMapKey = "",
+                                      CablingMapFileName=IdMappingDat)
+        
+    # SiLorentzAngleTool for PixelFastDigitizationTool
+    from AthenaCommon.AppMgr import ToolSvc
+    if not hasattr(ToolSvc, "PixelLorentzAngleTool"):
+        from SiLorentzAngleTool.PixelLorentzAngleToolSetup import PixelLorentzAngleToolSetup
+        PixelLorentzAngleToolSetup()
+    kwargs.setdefault("LorentzAngleTool", ToolSvc.PixelLorentzAngleTool)
+
+    from AthenaCommon import CfgMgr
+    return CfgMgr.PixelFastDigitizationTool(name,**kwargs)
+
+def commonSCT_FastDigitizationConfig(name,**kwargs):
+
+    # Setup the DCS folders and tool used in the sctSiliconConditionsTool
+    from SCT_ConditionsTools.SCT_DCSConditionsToolSetup import SCT_DCSConditionsToolSetup
+    sct_DCSConditionsToolSetup = SCT_DCSConditionsToolSetup()
+    sct_DCSConditionsToolSetup.setup()
+
+    kwargs.setdefault("ClusterMaker", "FastClusterMakerTool")
+
+    # Import Digitization job properties
+    from Digitization.DigitizationFlags import digitizationFlags
+    kwargs.setdefault("RndmEngine", "FastSCT_Digitization")
+
+    if digitizationFlags.doXingByXingPileUp():
+        kwargs.setdefault("FirstXing", FastSCT_FirstXing())
+        kwargs.setdefault("LastXing",  FastSCT_LastXing() )
+
+    # Set up SCT_SiliconConditionsTool
+    from SCT_ConditionsTools.SCT_SiliconConditionsToolSetup import SCT_SiliconConditionsToolSetup
+    sct_SiliconConditionsToolSetup = SCT_SiliconConditionsToolSetup()
+    sct_SiliconConditionsToolSetup.setDcsTool(sct_DCSConditionsToolSetup.getTool())
+    sct_SiliconConditionsToolSetup.setup()
+    # Set up SCT_SiPropertiesTool
+    from SiPropertiesTool.SCT_SiPropertiesToolSetup import SCT_SiPropertiesToolSetup
+    sct_SiPropertiesToolSetup = SCT_SiPropertiesToolSetup()
+    sct_SiPropertiesToolSetup.setSiliconTool(sct_SiliconConditionsToolSetup.getTool())
+    sct_SiPropertiesToolSetup.setup()
+
+    # SiLorentzAngleTool for SCT_FastDigitizationTool
+    from SiLorentzAngleTool.SCTLorentzAngleToolSetup import SCTLorentzAngleToolSetup
+    sctLorentzAngleToolSetup = SCTLorentzAngleToolSetup()
+    kwargs.setdefault("LorentzAngleTool", sctLorentzAngleToolSetup.SCTLorentzAngleTool)
+
+    from AthenaCommon import CfgMgr
+    return CfgMgr.SCT_FastDigitizationTool(name,**kwargs)
+
+######################################################################################
+def PixelFastDigitizationTool(name="PixelFastDigitizationTool", **kwargs):
+    kwargs.setdefault("HardScatterSplittingMode", 0)
+    return commonPixelFastDigitizationConfig(name, **kwargs)
+
+######################################################################################
+def PixelFastDigitizationToolHS(name="PixelFastDigitizationToolHS", **kwargs):
+    kwargs.setdefault("HardScatterSplittingMode", 1)
+    return commonPixelFastDigitizationConfig(name, **kwargs)
+
+######################################################################################
+def PixelFastDigitizationToolPU(name="PixelFastDigitizationToolPU", **kwargs):
+    kwargs.setdefault("PixelClusterContainerName", "Pixel_PU_Clusters")
+    kwargs.setdefault("TruthNamePixel", "PRD_MultiTruthPixel_PU")
+    kwargs.setdefault("HardScatterSplittingMode", 2)
+    return commonPixelFastDigitizationConfig(name, **kwargs)
+
+######################################################################################
+def PixelFastDigitizationToolSplitNoMergePU(name="PixelFastDigitizationToolSplitNoMergePU", **kwargs):
+    kwargs.setdefault("InputObjectName", "PileupPixelHits")
+    kwargs.setdefault("PixelClusterContainerName", "PixelFast_PU_Clusters")
+    kwargs.setdefault("TruthNamePixel", "PRD_MultiTruthPixel_PU")
+    kwargs.setdefault("HardScatterSplittingMode", 0)
+    kwargs.setdefault("PixelClusterAmbiguitiesMapName", "PixelClusterAmbiguitiesMapPU")
+    return commonPixelFastDigitizationConfig(name, **kwargs)
+
+######################################################################################
+def SCT_FastDigitizationTool(name="SCT_FastDigitizationTool", **kwargs):
+    kwargs.setdefault("HardScatterSplittingMode", 0)
+    return commonSCT_FastDigitizationConfig(name,**kwargs)
+
+######################################################################################
+def SCT_FastDigitizationToolHS(name="SCT_FastDigitizationToolHS",**kwargs):
+    kwargs.setdefault("HardScatterSplittingMode", 1)
+    return commonSCT_FastDigitizationConfig(name,**kwargs)
+
+######################################################################################
+def SCT_FastDigitizationToolPU(name="SCT_FastDigitizationToolPU",**kwargs):
+    kwargs.setdefault("SCT_ClusterContainerName", "SCT_PU_Clusters")
+    kwargs.setdefault("TruthNameSCT", "PRD_MultiTruthSCT_PU")
+    kwargs.setdefault("HardScatterSplittingMode", 2)
+    return commonSCT_FastDigitizationConfig(name,**kwargs)
+
+######################################################################################
+def SCT_FastDigitizationToolSplitNoMergePU(name="SCT_FastDigitizationToolSplitNoMergePU",**kwargs):
+    kwargs.setdefault("InputObjectName", "PileupSCT_Hits")
+    kwargs.setdefault("SCT_ClusterContainerName", "SCT_PU_Clusters")
+    kwargs.setdefault("TruthNameSCT", "PRD_MultiTruthSCT_PU")
+    kwargs.setdefault("HardScatterSplittingMode", 0)
+    return commonSCT_FastDigitizationConfig(name,**kwargs)
+
+######################################################################################
+def getFastPixelRange(name="FastPixelRange" , **kwargs):
+    kwargs.setdefault('FirstXing', FastPixel_FirstXing() )
+    kwargs.setdefault('LastXing',  FastPixel_LastXing() )
+    kwargs.setdefault('CacheRefreshFrequency', 1.0 ) #default 0 no dataproxy reset
+    kwargs.setdefault('ItemList', ["SiHitCollection#PixelHits"] )
+    from AthenaCommon import CfgMgr
+    return CfgMgr.PileUpXingFolder(name, **kwargs)
+
+######################################################################################
+def getFastSCTRange(name="FastSCTRange" , **kwargs):
+    #this is the time of the xing in ns
+    kwargs.setdefault('FirstXing', FastSCT_FirstXing() )
+    kwargs.setdefault('LastXing',  FastSCT_LastXing()  )
+    kwargs.setdefault('CacheRefreshFrequency', 1.0 ) #default 0 no dataproxy reset
+    kwargs.setdefault('ItemList', ["SiHitCollection#SCT_Hits"] )
+    from AthenaCommon import CfgMgr
+    return CfgMgr.PileUpXingFolder(name, **kwargs)

InnerDetector/InDetDigitization/FastSiDigitization/src/PixelFastDigitizationTool.cxx

@@ -68,69 +68,8 @@ using namespace InDet;
 PixelFastDigitizationTool::PixelFastDigitizationTool(const std::string &type, const std::string &name,
                                                      const IInterface* parent):
 
-  PileUpToolBase(type, name, parent),
-  m_thpcsi(nullptr),
-  m_randomEngineName("FastPixelDigitization"),
-  m_pixel_ID(nullptr),
-  m_clusterMaker("InDet::ClusterMakerTool/FatrasClusterMaker"),
-  m_pixUseClusterMaker(true),
-  m_pixelClusterContainer(nullptr),
-  m_pixel_SiClustersName("PixelClusters"),
-  m_mergeSvc("PileUpMergeSvc",name),
-  m_HardScatterSplittingMode(0),
-  m_HardScatterSplittingSkipper(false),
-  m_pixelClusterMap(nullptr),
-  m_prdTruthNamePixel("PRD_MultiTruthPixel"),
-  m_pixPrdTruth(nullptr),
-  //  m_pixelCondSummarySvc("PixelConditionsSummarySvc", name),
-  m_gangedAmbiguitiesFinder("InDet::PixelGangedAmbiguitiesFinder"),
-  m_inputObjectName("PixelHits"),
-  m_pixTanLorentzAngleScalor(1.),
-  m_pixEmulateSurfaceCharge(true),
-  m_pixSmearPathLength(0.01),
-  m_pixSmearLandau(true),
-  m_pixMinimalPathCut(0.06),// Optimized choice of threshold (old 0.02)
-  m_pixPathLengthTotConv(125.),
-  m_pixModuleDistortion(true), // default: false
-  m_pixErrorStrategy(2),
-  m_pixDiffShiftBarrX(0.005),
-  m_pixDiffShiftBarrY(0.005),
-  m_pixDiffShiftEndCX(0.008),
-  m_pixDiffShiftEndCY(0.008),
-  m_ThrConverted(50000),
-  m_mergeCluster(true),
-  m_splitClusters(0),
-  m_acceptDiagonalClusters(true),
-  m_pixelClusterAmbiguitiesMapName("PixelClusterAmbiguitiesMap"),
-  m_ambiguitiesMap(nullptr),
-  m_digitizationStepper("Trk::PlanarModuleStepper")
+  PileUpToolBase(type, name, parent)
 {
-  declareProperty("RndmEngine"                     , m_randomEngineName,         "Random engine name");
-  declareProperty("ClusterMaker"                   , m_clusterMaker);
-  declareProperty("PixelUseClusterMaker"           , m_pixUseClusterMaker);
-  declareProperty("PixelClusterContainerName"      , m_pixel_SiClustersName);
-  declareProperty("MergeSvc"                       , m_mergeSvc,                 "Merge service" );
-  declareProperty("TruthNamePixel"                 , m_prdTruthNamePixel);
-  //declareProperty("PixelConditionsSummarySvc"      , m_pixelCondSummarySvc,      "Name of the pixel conditions service");
-  declareProperty("gangedAmbiguitiesFinder"        , m_gangedAmbiguitiesFinder);
-  declareProperty("InputObjectName"                , m_inputObjectName,          "Input Object name" );
-  declareProperty("PixelEmulateSurfaceCharge"      , m_pixEmulateSurfaceCharge);
-  declareProperty("PixelSmearPathSigma"            , m_pixSmearPathLength);
-  declareProperty("PixelSmearLandau"               , m_pixSmearLandau);
-  declareProperty("PixelMinimalPathLength"         , m_pixMinimalPathCut);
-  declareProperty("PixelPathLengthTotConversion"   , m_pixPathLengthTotConv);
-  declareProperty("PixelEmulateModuleDistortion"   , m_pixModuleDistortion);
-  declareProperty("PixelErrorPhi"                  , m_pixPhiError);
-  declareProperty("PixelErrorEta"                  , m_pixEtaError);
-  declareProperty("PixelErrorStrategy"             , m_pixErrorStrategy);
-  declareProperty("PixelClusterAmbiguitiesMapName" , m_pixelClusterAmbiguitiesMapName);
-  declareProperty("HardScatterSplittingMode"       , m_HardScatterSplittingMode, "Control pileup & signal splitting" );
-  declareProperty("DigitizationStepper",     m_digitizationStepper);
-  declareProperty("PixDiffShiftBarrX", m_pixDiffShiftBarrX);
-  declareProperty("PixDiffShiftBarrY", m_pixDiffShiftBarrY);
-  declareProperty("PixDiffShiftEndCX", m_pixDiffShiftEndCX);
-  declareProperty("PixDiffShiftEndCY", m_pixDiffShiftEndCY);
-  declareProperty("ThrConverted", m_ThrConverted);
 }
 
 PixelFastDigitizationTool::~PixelFastDigitizationTool() {

InnerDetector/InDetDigitization/FastSiDigitization/src/SCT_FastDigitizationTool.cxx

@@ -54,51 +54,8 @@ SCT_FastDigitizationTool::SCT_FastDigitizationTool(const std::string& type,
                                                    const std::string& name,
                                                    const IInterface* parent) :
 
-  PileUpToolBase(type, name, parent),
-  m_inputObjectName("SCT_Hits"),
-  m_sct_ID(nullptr),
-  m_mergeSvc("PileUpMergeSvc",name),
-  m_HardScatterSplittingMode(0),
-  m_HardScatterSplittingSkipper(false),
-  m_randomEngineName("FastSCT_Digitization"),
-  m_thpcsi(nullptr),
-  m_clusterMaker("InDet::ClusterMakerTool"),
-  m_sctClusterMap(nullptr),
-  m_sctClusterContainer("SCT_Clusters"),
-  m_sctPrdTruth("PRD_MultiTruthSCT"),
-  m_sctSmearPathLength(0.01),
-  m_sctSmearLandau(true),
-  m_sctEmulateSurfaceCharge(true),
-  m_sctTanLorentzAngleScalor(1.),
-  m_sctAnalogStripClustering(false),
-  m_sctErrorStrategy(2),
-  m_sctRotateEC(true),
-  m_mergeCluster(true),
-  m_DiffusionShiftX_barrel(4),
-  m_DiffusionShiftY_barrel(4),
-  m_DiffusionShiftX_endcap(15),
-  m_DiffusionShiftY_endcap(15),
-  m_sctMinimalPathCut(90.)
+  PileUpToolBase(type, name, parent)
 {
-  declareProperty("InputObjectName"               , m_inputObjectName,          "Input Object name" );
-  declareProperty("MergeSvc"                      , m_mergeSvc,                 "Merge service" );
-  declareProperty("RndmEngine"                    , m_randomEngineName,         "Random Number Engine used in SCT digitization" );
-  declareProperty("ClusterMaker"                  , m_clusterMaker);
-  declareProperty("SCT_ClusterContainerName"      , m_sctClusterContainer);
-  declareProperty("TruthNameSCT"                  , m_sctPrdTruth);
-  declareProperty("SCT_SmearPathSigma"            , m_sctSmearPathLength);
-  declareProperty("SCT_SmearLandau"               , m_sctSmearLandau);
-  declareProperty("EmulateSurfaceCharge"          , m_sctEmulateSurfaceCharge);
-  declareProperty("SCT_ScaleTanLorentzAngle"      , m_sctTanLorentzAngleScalor);
-  declareProperty("SCT_AnalogClustering"          , m_sctAnalogStripClustering);
-  declareProperty("SCT_ErrorStrategy"             , m_sctErrorStrategy);
-  declareProperty("SCT_RotateEndcapClusters"      , m_sctRotateEC);
-  declareProperty("SCT_MinimalPathLength"         , m_sctMinimalPathCut);
-  declareProperty("DiffusionShiftX_barrel", m_DiffusionShiftX_barrel);
-  declareProperty("DiffusionShiftY_barrel", m_DiffusionShiftY_barrel);
-  declareProperty("DiffusionShiftX_endcap", m_DiffusionShiftX_endcap);
-  declareProperty("DiffusionShiftY_endcap", m_DiffusionShiftY_endcap);
-  declareProperty("HardScatterSplittingMode"      , m_HardScatterSplittingMode, "Control pileup & signal splitting" );
 }
 
 //----------------------------------------------------------------------
@@ -121,6 +78,8 @@ StatusCode SCT_FastDigitizationTool::initialize()
     {
       ATH_MSG_DEBUG ( "Input objects: '" << m_inputObjectName << "'" );
     }
+  ATH_CHECK(m_sctClusterContainerKey.initialize());
+  ATH_CHECK(m_sctPrdTruthKey.initialize());
 
   // retrieve the offline cluster maker : for pixel and/or sct
   if (!m_clusterMaker.empty())
@@ -192,44 +151,8 @@ StatusCode SCT_FastDigitizationTool::processBunchXing(int bunchXing,
 }
 
 
-StatusCode SCT_FastDigitizationTool::createOutputContainers()
-{
-  if (!m_sctClusterContainer.isValid())
-    {
-      m_sctClusterContainer = std::make_unique<InDet::SCT_ClusterContainer>(m_sct_ID->wafer_hash_max());
-      if(!m_sctClusterContainer.isValid())
-        {
-          ATH_MSG_FATAL( "[ --- ] Could not create SCT_ClusterContainer");
-          return StatusCode::FAILURE;
-        }
-    }
-  m_sctClusterContainer->cleanup();
-
-  // --------------------------------------
-  // symlink the SCT Container
-  InDet::SiClusterContainer* symSiContainer=nullptr;
-  CHECK(evtStore()->symLink(m_sctClusterContainer.ptr(),symSiContainer));
-  ATH_MSG_DEBUG( "[ hitproc ] SCT_ClusterContainer symlinked to SiClusterContainer in StoreGate" );
-  // --------------------------------------
-
-  // truth info
-  if (!m_sctPrdTruth.isValid())
-    {
-      m_sctPrdTruth = std::make_unique<PRD_MultiTruthCollection>();
-      if (!m_sctPrdTruth.isValid())
-        {
-          ATH_MSG_FATAL("Could not record collection " << m_sctPrdTruth.name());
-          return StatusCode::FAILURE;
-        }
-    }
-
-  return StatusCode::SUCCESS;
-}
-
 StatusCode SCT_FastDigitizationTool::processAllSubEvents(const EventContext& ctx) {
 
-  CHECK(this->createOutputContainers());
-
   //  get the container(s)
   using TimedHitCollList = PileUpMergeSvc::TimedList<SiHitCollection>::type;
 
@@ -281,8 +204,6 @@ StatusCode SCT_FastDigitizationTool::processAllSubEvents(const EventContext& ctx
 
 StatusCode SCT_FastDigitizationTool::mergeEvent(const EventContext& ctx)
 {
-  CHECK(this->createOutputContainers());
-
   if (m_thpcsi != nullptr)
     {
       CHECK(this->digitize(ctx));
@@ -304,7 +225,16 @@ StatusCode SCT_FastDigitizationTool::mergeEvent(const EventContext& ctx)
 
 StatusCode SCT_FastDigitizationTool::digitize(const EventContext& ctx)
 {
-   // Set the RNG to use for this event.
+  // truth info
+  SG::WriteHandle< PRD_MultiTruthCollection > sctPrdTruth(m_sctPrdTruthKey, ctx);
+  sctPrdTruth = std::make_unique< PRD_MultiTruthCollection >();
+  if ( !sctPrdTruth.isValid() ) {
+    ATH_MSG_FATAL( "Could not record collection " << sctPrdTruth.name() );
+    return StatusCode::FAILURE;
+  }
+  ATH_MSG_DEBUG( "PRD_MultiTruthCollection " << sctPrdTruth.name() << " registered in StoreGate" );
+
+  // Set the RNG to use for this event.
   ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_randomEngineName);
   const std::string rngName = name()+m_randomEngineName;
   rngWrapper->setSeed( rngName, ctx );
@@ -825,13 +755,13 @@ StatusCode SCT_FastDigitizationTool::digitize(const EventContext& ctx)
 
 
                     //Store HepMcParticleLink connected to the cluster removed from the collection
-                    std::pair<PRD_MultiTruthCollection::iterator,PRD_MultiTruthCollection::iterator> saved_hit = m_sctPrdTruth->equal_range(existingCluster->identify());
+                    std::pair<PRD_MultiTruthCollection::iterator,PRD_MultiTruthCollection::iterator> saved_hit = sctPrdTruth->equal_range(existingCluster->identify());
                     for (PRD_MultiTruthCollection::iterator this_hit = saved_hit.first; this_hit != saved_hit.second; ++this_hit)
                       {
                         hit_vector.push_back(this_hit->second);
                       }
                     //Delete all the occurency of the currentCluster from the multi map
-                    if (saved_hit.first != saved_hit.second) m_sctPrdTruth->erase(existingCluster->identify());
+                    if (saved_hit.first != saved_hit.second) sctPrdTruth->erase(existingCluster->identify());
 
                     delete existingCluster;
                     ATH_MSG_VERBOSE("Merged two clusters.");
@@ -924,7 +854,7 @@ StatusCode SCT_FastDigitizationTool::digitize(const EventContext& ctx)
               const int barcode( currentSiHit->particleLink().barcode());
               if ( barcode !=0 && barcode != m_vetoThisBarcode )
                 {
-                  m_sctPrdTruth->insert(std::make_pair(potentialCluster->identify(), currentSiHit->particleLink()));
+                  sctPrdTruth->insert(std::make_pair(potentialCluster->identify(), currentSiHit->particleLink()));
                   ATH_MSG_DEBUG("Truth map filled with cluster" << potentialCluster << " and link = " << currentSiHit->particleLink());
                 }
             }
@@ -935,7 +865,7 @@ StatusCode SCT_FastDigitizationTool::digitize(const EventContext& ctx)
 
 
           for(const HepMcParticleLink& p: hit_vector){
-            m_sctPrdTruth->insert(std::make_pair(potentialCluster->identify(), p ));
+            sctPrdTruth->insert(std::make_pair(potentialCluster->identify(), p ));
           }
 
           hit_vector.clear();
@@ -951,6 +881,21 @@ StatusCode SCT_FastDigitizationTool::digitize(const EventContext& ctx)
 
 StatusCode SCT_FastDigitizationTool::createAndStoreRIOs(const EventContext& ctx)
 {
+  SG::WriteHandle<InDet::SCT_ClusterContainer> sctClusterContainer(m_sctClusterContainerKey, ctx);
+  sctClusterContainer = std::make_unique<InDet::SCT_ClusterContainer>(m_sct_ID->wafer_hash_max());
+  if(!sctClusterContainer.isValid()) {
+    ATH_MSG_FATAL( "[ --- ] Could not create SCT_ClusterContainer");
+    return StatusCode::FAILURE;
+  }
+  sctClusterContainer->cleanup();
+
+  // --------------------------------------
+  // symlink the SCT Container
+  InDet::SiClusterContainer* symSiContainer=nullptr;
+  CHECK(evtStore()->symLink(sctClusterContainer.ptr(),symSiContainer));
+  ATH_MSG_DEBUG( "[ hitproc ] SCT_ClusterContainer symlinked to SiClusterContainer in StoreGate" );
+  // --------------------------------------
+
   // Get SCT_DetectorElementCollection
   SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
   const InDetDD::SiDetectorElementCollection* elements(sctDetEle.retrieve());
@@ -978,7 +923,7 @@ StatusCode SCT_FastDigitizationTool::createAndStoreRIOs(const EventContext& ctx)
               sctCluster->setHashAndIndex(clusterCollection->identifyHash(),clusterCollection->size());
               clusterCollection->push_back(sctCluster);
             }
-          if (m_sctClusterContainer->addCollection(clusterCollection, clusterCollection->identifyHash()).isFailure())
+          if (sctClusterContainer->addCollection(clusterCollection, clusterCollection->identifyHash()).isFailure())
             {
               ATH_MSG_WARNING( "Could not add collection to Identifiable container !" );
             }

InnerDetector/InDetDigitization/FastTRT_Digitization/FastTRT_Digitization/TRTFastDigitizationTool.h

@@ -93,11 +93,10 @@ private:
   StatusCode setNumericalConstants();    // once per event (pileup-dependent constants) 
 
   StatusCode produceDriftCircles(const EventContext& ctx, CLHEP::HepRandomEngine* rndmEngine);
-  StatusCode createOutputContainers();
 
   Identifier getIdentifier( int hitID, IdentifierHash &hash, Identifier &layer_id, bool &status ) const;
 
-  StatusCode createAndStoreRIOs(CLHEP::HepRandomEngine* rndmEngine);
+  StatusCode createAndStoreRIOs(const EventContext& ctx, CLHEP::HepRandomEngine* rndmEngine);
 
   static double getDriftRadiusFromXYZ( const TimedHitPtr< TRTUncompressedHit > &hit );
   HepGeom::Point3D< double > getGlobalPosition( const TimedHitPtr< TRTUncompressedHit > &hit );
@@ -113,43 +112,43 @@ private:
   double particleMass( int i ) const;
 
   // Tools and Services
-  ToolHandle< ITRT_DriftFunctionTool > m_trtDriftFunctionTool;
-  bool m_useTrtElectronPidTool;                                           // false: use Tina's parametrization
-  ToolHandle< Trk::ITRT_ElectronPidTool > m_trtElectronPidTool;
-  ToolHandle< ITRT_StrawStatusSummaryTool > m_trtStrawStatusSummaryTool; // Argon / Xenon
-  ServiceHandle< PileUpMergeSvc > m_mergeSvc;                             // PileUp Merge service
+  PublicToolHandle< ITRT_DriftFunctionTool > m_trtDriftFunctionTool{this, "TRT_DriftFunctionTool", "TRT_DriftFunctionTool/FatrasTrtDriftFunctionTool"};
+  bool m_useTrtElectronPidTool{true};                                           // false: use Tina's parametrization
+  PublicToolHandle< Trk::ITRT_ElectronPidTool > m_trtElectronPidTool{this, "TRT_ElectronPidTool", "InDet::TRT_ElectronPidToolRun2/InDetTRT_ElectronPidTool"};
+  ToolHandle< ITRT_StrawStatusSummaryTool > m_trtStrawStatusSummaryTool{this, "TRT_StrawStatusSummaryTool", "InDetTRTStrawStatusSummaryTool"}; // Argon / Xenon
+  ServiceHandle< PileUpMergeSvc > m_mergeSvc{this, "MergeSvc", "PileUpMergeSvc"};                             // PileUp Merge service
   ServiceHandle<IAthRNGSvc> m_rndmSvc{this, "RndmSvc", "AthRNGSvc", ""};  //!< Random number service
-  std::string m_randomEngineName;                                         // Name of the random number stream
+  StringProperty m_randomEngineName{this, "RandomStreamName", "FatrasRnd"};                                         // Name of the random number stream
 
   // INPUT
-  std::string m_trtHitCollectionKey;
+  StringProperty m_trtHitCollectionKey{this, "trtHitCollectionName", "TRTUncompressedHits"};
   std::vector< TRTUncompressedHitCollection * > m_trtHitCollList;
 
   // OUTPUT 
-  SG::WriteHandle< InDet::TRT_DriftCircleContainer > m_trtDriftCircleContainer;
-  SG::WriteHandle< PRD_MultiTruthCollection > m_trtPrdTruth;
+  SG::WriteHandleKey< InDet::TRT_DriftCircleContainer > m_trtDriftCircleContainerKey{this, "trtDriftCircleContainer", "TRT_DriftCircles"};
+  SG::WriteHandleKey< PRD_MultiTruthCollection > m_trtPrdTruthKey{this, "trtPrdMultiTruthCollection", "PRD_MultiTruthTRT"};
 
-  TimedHitCollection< TRTUncompressedHit > *m_thpctrt;
+  TimedHitCollection< TRTUncompressedHit > *m_thpctrt{};
   std::multimap< Identifier, InDet::TRT_DriftCircle * > m_driftCircleMap;
 
   // Helpers
-  const InDetDD::TRT_DetectorManager *m_trt_manager;
-  const TRT_ID *m_trt_id;                                                 // TRT Id Helper
+  const InDetDD::TRT_DetectorManager *m_trt_manager{};
+  const TRT_ID *m_trt_id{};                                                 // TRT Id Helper
 
   // Split configuration
-  int m_HardScatterSplittingMode;                                         // Process all TRT_Hits or just those from signal or background events
-  bool m_HardScatterSplittingSkipper;
+  IntegerProperty m_HardScatterSplittingMode{this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting"};                                         // Process all TRT_Hits or just those from signal or background events
+  bool m_HardScatterSplittingSkipper{false};
 
-  bool m_useEventInfo;  // get mu from EventInfo ?
+  BooleanProperty m_useEventInfo{this, "useEventInfo", false};  // get mu from EventInfo ?
   SG::ReadHandleKey<xAOD::EventInfo> m_EventInfoKey
     { this, "EventInfoKey", "EventInfo", "SG key for EventInfo" };
-  float m_NCollPerEvent;
+  FloatProperty m_NCollPerEvent{this, "NCollPerEvent", 30};
 
   // numerical constants. Might wish to move these to a DB in the future
-  double m_trtTailFraction = 0.0;            // fraction in tails 
-  double m_trtSigmaDriftRadiusTail = 0.0;    // sigma of one TRT straw in R
-  double m_trtHighProbabilityBoostBkg;
-  double m_trtHighProbabilityBoostEle;
+  double m_trtTailFraction{0.0};            // fraction in tails 
+  double m_trtSigmaDriftRadiusTail{0.0};    // sigma of one TRT straw in R
+  double m_trtHighProbabilityBoostBkg{1.};
+  double m_trtHighProbabilityBoostEle{1.};
   double m_cFit[ 8 ][ 5 ]{};             // efficiency and resolution
 
 };

InnerDetector/InDetDigitization/FastTRT_Digitization/python/FastTRT_DigitizationConfig.py

+# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+from Digitization.PileUpMergeSvcConfig import PileUpMergeSvcCfg, PileUpXingFolderCfg
+
+# The earliest bunch crossing time for which interactions will be sent
+# to the FastTRT Digitization code.
+def FastTRT_FirstXing():
+    return -50
+
+
+# The latest bunch crossing time for which interactions will be sent
+# to the FastTRT Digitization code.
+def FastTRT_LastXing():
+    return 50
+
+
+def FastTRTRangeCfg(flags, name="FastTRTRange", **kwargs):
+    #this is the time of the xing in ns
+    kwargs.setdefault('FirstXing', FastTRT_FirstXing() )
+    kwargs.setdefault('LastXing', FastTRT_LastXing() )
+    kwargs.setdefault('CacheRefreshFrequency', 1.0 ) #default 0 no dataproxy reset
+    kwargs.setdefault('ItemList', ["TRTUncompressedHitCollection#TRTUncompressedHits"] )
+    return PileUpXingFolderCfg(flags, name, **kwargs)
+
+
+def BasicTRTFastDigitizationToolCfg(flags, name, **kwargs):
+    acc = ComponentAccumulator()
+    from IOVDbSvc.IOVDbSvcConfig import addFolders, addFoldersSplitOnline
+    acc.merge(addFoldersSplitOnline(flags, "TRT", "/TRT/Onl/Calib/errors", "/TRT/Calib/errors"))
+    acc.merge(addFoldersSplitOnline(flags, "TRT","/TRT/Onl/Calib/PID_vector", "/TRT/Calib/PID_vector"))
+    acc.merge(addFolders(flags, "TRT_OFL", "/TRT/Calib/ToT/ToTVectors"))
+    acc.merge(addFolders(flags, "TRT_OFL", "/TRT/Calib/ToT/ToTValue"))
+    if flags.Digitization.DoXingByXingPileUp:
+        kwargs.setdefault("FirstXing", FastTRT_FirstXing())
+        kwargs.setdefault("LastXing",  FastTRT_LastXing())
+    from RngComps.RandomServices import AthRNGSvcCfg
+    kwargs.setdefault("RndmSvc", acc.getPrimaryAndMerge(AthRNGSvcCfg(flags)).name)
+    kwargs.setdefault("RandomStreamName", "FastTRTDigitization")
+    tool = CompFactory.TRTFastDigitizationTool(name,**kwargs)
+    acc.setPrivateTools(tool)
+    return acc
+
+
+def TRTFastDigitizationToolCfg(flags, name="TRTFastDigitizationTool",**kwargs):
+    acc = ComponentAccumulator()
+    intervals = []
+    if not flags.Digitization.DoXingByXingPileUp:
+        intervals += [acc.popToolsAndMerge(FastTRTRangeCfg(flags))]
+    kwargs.setdefault("MergeSvc", acc.getPrimaryAndMerge(PileUpMergeSvcCfg(flags, Intervals=intervals)).name)
+    kwargs.setdefault("trtDriftCircleContainer", "TRT_DriftCircles")
+    kwargs.setdefault("trtPrdMultiTruthCollection", "PRD_MultiTruthTRT")
+    kwargs.setdefault("HardScatterSplittingMode", 0)
+    acc.setPrivateTools(BasicTRTFastDigitizationToolCfg(flags, name,**kwargs))
+    return acc
+
+
+def TRTFastDigitizationToolHS(flags, name="TRTFastDigitizationToolHS",**kwargs):
+    acc = ComponentAccumulator()
+    intervals = []
+    if not flags.Digitization.DoXingByXingPileUp:
+        intervals += [acc.popToolsAndMerge(FastTRTRangeCfg(flags))]
+    kwargs.setdefault("MergeSvc", acc.getPrimaryAndMerge(PileUpMergeSvcCfg(flags, Intervals=intervals)).name)
+    kwargs.setdefault("OnlyUseContainerName", True)
+    kwargs.setdefault("trtDriftCircleContainer", "TRT_DriftCircles")
+    kwargs.setdefault("trtPrdMultiTruthCollection", "PRD_MultiTruthTRT")
+    kwargs.setdefault("HardScatterSplittingMode", 1)
+    acc.setPrivateTools(BasicTRTFastDigitizationToolCfg(flags, name,**kwargs))
+    return acc
+
+
+def TRTFastDigitizationToolPU(flags, name="TRTFastDigitizationToolPU",**kwargs):
+    acc = ComponentAccumulator()
+    intervals = []
+    if not flags.Digitization.DoXingByXingPileUp:
+        intervals += [acc.popToolsAndMerge(FastTRTRangeCfg(flags))]
+    kwargs.setdefault("MergeSvc", acc.getPrimaryAndMerge(PileUpMergeSvcCfg(flags, Intervals=intervals)).name)
+    kwargs.setdefault("trtDriftCircleContainer", "TRT_PU_DriftCircles")
+    kwargs.setdefault("trtPrdMultiTruthCollection", "PRD_MultiTruthTRT_PU")
+    kwargs.setdefault("HardScatterSplittingMode", 2)
+    acc.setPrivateTools(BasicTRTFastDigitizationToolCfg(flags, name,**kwargs))
+    return acc
+
+
+def TRTFastDigitizationToolSplitNoMergePU(flags, name="TRTFastDigitizationToolSplitNoMergePU",**kwargs):
+    acc = ComponentAccumulator()
+    intervals = []
+    if not flags.Digitization.DoXingByXingPileUp:
+        intervals += [acc.popToolsAndMerge(FastTRTRangeCfg(flags))]
+    kwargs.setdefault("MergeSvc", acc.getPrimaryAndMerge(PileUpMergeSvcCfg(flags, Intervals=intervals)).name)
+    kwargs.setdefault("trtHitCollectionName", "PileupTRTUncompressedHits")
+    kwargs.setdefault("trtDriftCircleContainer", "TRT_PU_DriftCircles")
+    kwargs.setdefault("trtPrdMultiTruthCollection", "PRD_MultiTruthTRT_PU")
+    kwargs.setdefault("HardScatterSplittingMode", 0)
+    acc.setPrivateTools(BasicTRTFastDigitizationToolCfg(flags, name,**kwargs))
+    return acc

InnerDetector/InDetDigitization/FastTRT_Digitization/python/FastTRT_DigitizationConfigLegacy.py

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 
 # The earliest bunch crossing time for which interactions will be sent
 # to the FastTRT Digitization code.
@@ -30,13 +30,8 @@ def BasicTRTFastDigitizationTool(name, **kwargs):
         conddb.addFolder( "TRT_OFL", "/TRT/Calib/ToT/ToTVectors") 
     if not conddb.folderRequested( "/TRT/Calib/ToT/ToTValue"):
         conddb.addFolder( "TRT_OFL", "/TRT/Calib/ToT/ToTValue")
-    #choose random number service
-    from Digitization.DigitizationFlags import digitizationFlags
-    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc() )
-    streamName = kwargs.setdefault("RandomStreamName", "FastTRTDigitization")
-    # set rndm seeds
-    if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName):
-        digitizationFlags.rndmSeedList.addSeed(streamName, 45123, 94345 )
+
+    kwargs.setdefault("RandomStreamName", "FastTRTDigitization")
 
     from Digitization.DigitizationFlags import digitizationFlags
     if digitizationFlags.doXingByXingPileUp():

InnerDetector/InDetDigitization/FastTRT_Digitization/src/TRTFastDigitizationTool.cxx

@@ -53,37 +53,8 @@ static const unsigned int maskHT=0x04020100;
 TRTFastDigitizationTool::TRTFastDigitizationTool( const std::string &type,
                                                   const std::string &name,
                                                   const IInterface *parent )
-  : PileUpToolBase( type, name, parent ),
-    m_trtDriftFunctionTool( "TRT_DriftFunctionTool/FatrasTrtDriftFunctionTool" ),
-    m_useTrtElectronPidTool( true ),
-    m_trtElectronPidTool( "InDet::TRT_ElectronPidToolRun2/InDetTRT_ElectronPidTool" ),
-    m_trtStrawStatusSummaryTool( "InDetTRTStrawStatusSummaryTool", this ),
-    m_mergeSvc( "PileUpMergeSvc", name ),
-    m_randomEngineName( "FatrasRnd" ),
-    m_trtHitCollectionKey( "TRTUncompressedHits" ),
-    m_trtDriftCircleContainer( "TRT_DriftCircles" ),
-    m_trtPrdTruth( "PRD_MultiTruthTRT" ),
-    m_thpctrt( nullptr ),
-    m_trt_manager( nullptr ),
-    m_trt_id( nullptr ),
-    m_HardScatterSplittingMode( 0 ),
-    m_HardScatterSplittingSkipper( false ),
-    m_useEventInfo( false ),
-    m_NCollPerEvent( 30 ),
-    m_trtHighProbabilityBoostBkg(1.), 
-    m_trtHighProbabilityBoostEle(1.)
+  : PileUpToolBase( type, name, parent )
 {
-  declareProperty( "TRT_DriftFunctionTool",       m_trtDriftFunctionTool );
-  declareProperty( "TRT_ElectronPidTool",         m_trtElectronPidTool );
-  declareProperty( "TRT_StrawStatusSummaryTool",   m_trtStrawStatusSummaryTool );
-  declareProperty( "MergeSvc",                    m_mergeSvc );
-  declareProperty( "RandomStreamName",            m_randomEngineName );
-  declareProperty( "trtHitCollectionName",        m_trtHitCollectionKey );
-  declareProperty( "trtDriftCircleContainer",     m_trtDriftCircleContainer );
-  declareProperty( "trtPrdMultiTruthCollection",  m_trtPrdTruth );
-  declareProperty( "HardScatterSplittingMode",    m_HardScatterSplittingMode, "Control pileup & signal splitting" );
-  declareProperty( "useEventInfo",                m_useEventInfo);
-  declareProperty( "NCollPerEvent",               m_NCollPerEvent);
 }
 
 
@@ -115,6 +86,9 @@ StatusCode TRTFastDigitizationTool::initialize()
     ATH_MSG_DEBUG( "Input hits: " << m_trtHitCollectionKey );
   }
 
+  ATH_CHECK(m_trtPrdTruthKey.initialize());
+  ATH_CHECK(m_trtDriftCircleContainerKey.initialize());
+
   CHECK( m_trtDriftFunctionTool.retrieve() );
 
   if ( m_useTrtElectronPidTool ) {
@@ -278,6 +252,15 @@ StatusCode TRTFastDigitizationTool::setNumericalConstants() {
 
 StatusCode TRTFastDigitizationTool::produceDriftCircles(const EventContext& ctx, CLHEP::HepRandomEngine* rndmEngine) {
 
+  // Create OUTPUT PRD_MultiTruthCollection for TRT measurements
+  SG::WriteHandle< PRD_MultiTruthCollection > trtPrdTruth(m_trtPrdTruthKey, ctx);
+  trtPrdTruth = std::make_unique< PRD_MultiTruthCollection >();
+  if ( !trtPrdTruth.isValid() ) {
+    ATH_MSG_FATAL( "Could not record collection " << trtPrdTruth.name() );
+    return StatusCode::FAILURE;
+  }
+  ATH_MSG_DEBUG( "PRD_MultiTruthCollection " << trtPrdTruth.name() << " registered in StoreGate" );
+
   if(m_useEventInfo){
 
      SG::ReadHandle<xAOD::EventInfo> eventInfoContainer(m_EventInfoKey, ctx);
@@ -422,7 +405,7 @@ StatusCode TRTFastDigitizationTool::produceDriftCircles(const EventContext& ctx,
       if ( hit->particleLink().isValid() ) {
         const int barcode( hit->particleLink().barcode() );
         if ( barcode !=0 && barcode != m_vetoThisBarcode ) {
-          m_trtPrdTruth->insert( std::make_pair( trtDriftCircle->identify(), hit->particleLink() ) );
+          trtPrdTruth->insert( std::make_pair( trtDriftCircle->identify(), hit->particleLink() ) );
           ATH_MSG_DEBUG( "Truth map filled with cluster " << trtDriftCircle << " and link = " << hit->particleLink() );
         }
       }
@@ -441,8 +424,6 @@ StatusCode TRTFastDigitizationTool::processAllSubEvents(const EventContext& ctx)
 
   ATH_MSG_DEBUG( "TRTFastDigitizationTool::processAllSubEvents()" );
 
-  CHECK( this->createOutputContainers() );
-
   using HitCollectionTimedList = PileUpMergeSvc::TimedList<TRTUncompressedHitCollection>::type;
 
   HitCollectionTimedList hitCollectionTimedList;
@@ -473,49 +454,19 @@ StatusCode TRTFastDigitizationTool::processAllSubEvents(const EventContext& ctx)
   CLHEP::HepRandomEngine *rndmEngine = rngWrapper->getEngine(ctx);
 
   // Process the Hits straw by straw: get the iterator pairs for given straw
-  CHECK( this->produceDriftCircles(ctx, rndmEngine) );
+  CHECK( this->produceDriftCircles(ctx, rndmEngine ) );
 
-  CHECK( this->createAndStoreRIOs(rndmEngine) );
+  CHECK( this->createAndStoreRIOs(ctx, rndmEngine) );
   ATH_MSG_DEBUG ( "createAndStoreRIOs() succeeded" );
 
   return StatusCode::SUCCESS;
 }
 
 
-StatusCode TRTFastDigitizationTool::createOutputContainers() {
-
-  ATH_MSG_DEBUG( "TRTFastDigitizationTool::createOutputContainers()" );
-
-  // Create OUTPUT TRT_DriftCircleContainer and register it in StoreGate
-  if ( !m_trtDriftCircleContainer.isValid() ) {
-    m_trtDriftCircleContainer = std::make_unique< InDet::TRT_DriftCircleContainer >( m_trt_id->straw_layer_hash_max() );
-    if ( !m_trtDriftCircleContainer.isValid() ) {
-      ATH_MSG_FATAL( "Could not create TRT_DriftCircleContainer" );
-      return StatusCode::FAILURE;
-    }
-  }
-  ATH_MSG_DEBUG( "InDet::TRT_DriftCircleContainer " << m_trtDriftCircleContainer.name() << " registered in StoreGate" );
-
-  // Create OUTPUT PRD_MultiTruthCollection for TRT measurements
-  if ( !m_trtPrdTruth.isValid() ) {
-    m_trtPrdTruth = std::make_unique< PRD_MultiTruthCollection >();
-    if ( !m_trtPrdTruth.isValid() ) {
-      ATH_MSG_FATAL( "Could not record collection " << m_trtPrdTruth.name() );
-      return StatusCode::FAILURE;
-    }
-  }
-  ATH_MSG_DEBUG( "PRD_MultiTruthCollection " << m_trtPrdTruth.name() << " registered in StoreGate" );
-
-  return StatusCode::SUCCESS;
-}
-
-
 StatusCode TRTFastDigitizationTool::mergeEvent(const EventContext& ctx) {
 
   ATH_MSG_DEBUG( "TRTFastDigitizationTool::mergeEvent()" );
 
-  CHECK( this->createOutputContainers() );
-
   // Set the RNG to use for this event.
   ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_randomEngineName);
   const std::string rngName = name()+m_randomEngineName;
@@ -532,15 +483,24 @@ StatusCode TRTFastDigitizationTool::mergeEvent(const EventContext& ctx) {
   for(TRTUncompressedHitCollection* ptr : m_trtHitCollList) delete ptr;
   m_trtHitCollList.clear();
 
-  CHECK( this->createAndStoreRIOs(rndmEngine) );
+  CHECK( this->createAndStoreRIOs(ctx, rndmEngine) );
   ATH_MSG_DEBUG ( "createAndStoreRIOs() succeeded" );
 
   return StatusCode::SUCCESS;
 }
 
 
-StatusCode TRTFastDigitizationTool::createAndStoreRIOs(CLHEP::HepRandomEngine* rndmEngine)
+StatusCode TRTFastDigitizationTool::createAndStoreRIOs(const EventContext& ctx, CLHEP::HepRandomEngine* rndmEngine)
 {
+  // Create OUTPUT TRT_DriftCircleContainer and register it in StoreGate
+  SG::WriteHandle<InDet::TRT_DriftCircleContainer > trtDriftCircleContainer(m_trtDriftCircleContainerKey, ctx);
+  trtDriftCircleContainer = std::make_unique< InDet::TRT_DriftCircleContainer >( m_trt_id->straw_layer_hash_max() );
+  if ( !trtDriftCircleContainer.isValid() ) {
+    ATH_MSG_FATAL( "Could not create TRT_DriftCircleContainer" );
+    return StatusCode::FAILURE;
+  }
+  ATH_MSG_DEBUG( "InDet::TRT_DriftCircleContainer " << trtDriftCircleContainer.name() << " registered in StoreGate" );
+
   using DriftCircleMapItr = std::multimap<Identifier, InDet::TRT_DriftCircle *>::iterator;
   using HashMapItr = std::multimap<IdentifierHash, InDet::TRT_DriftCircle *>::iterator;
 
@@ -611,7 +571,7 @@ StatusCode TRTFastDigitizationTool::createAndStoreRIOs(CLHEP::HepRandomEngine* r
       trtDriftCircleCollection->push_back( trtDriftCircle );
     }
 
-    if ( m_trtDriftCircleContainer->addCollection( trtDriftCircleCollection, hash ).isFailure() ) {
+    if ( trtDriftCircleContainer->addCollection( trtDriftCircleCollection, hash ).isFailure() ) {
       ATH_MSG_WARNING( "Could not add collection to Identifyable container" );
     }
   }

Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedReconstructionConfig.py

@@ -6,18 +6,17 @@ from AthenaConfiguration.Enums import BeamType
 
 
 def MuonCaloTagAlgCfg(flags, name="MuonCaloTagAlg", **kwargs):
+    result = ComponentAccumulator()
     from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCaloTagToolCfg
-    tools = []
-    result = MuonCaloTagToolCfg(flags)
-    tools.append(result.popPrivateTools())
-    kwargs.setdefault("MuonCombinedInDetExtensionTools", tools)
-    result.addPublicTool(kwargs['MuonCombinedInDetExtensionTools'][0])  # Ugh
+    tool = result.popToolsAndMerge(MuonCaloTagToolCfg(flags))
+    # needs to be made public for some reason?
+    result.addPublicTool(tool)
+    kwargs.setdefault("MuonCombinedInDetExtensionTools", [tool])
     kwargs.setdefault("TagMap", "caloTagMap")
     kwargs.setdefault("CombinedTrackCollection", "")
     kwargs.setdefault("METrackCollection", "")
     kwargs.setdefault("usePRDs", False)
-    alg = CompFactory.MuonCombinedInDetExtensionAlg(name, **kwargs)
-    result.addEventAlgo(alg, primary=True)
+    result.addEventAlgo(CompFactory.MuonCombinedInDetExtensionAlg(name, **kwargs))
     return result
 
 

Simulation/Digitization/python/DigitizationConfigFlags.py

@@ -132,6 +132,8 @@ def createDigitizationCfgFlags():
     flags.addFlag("Digitization.PU.NumberOfCavern", 0.0)
     # Repeating pattern to determine which events to simulate when using Stepping Cache
     flags.addFlag("Digitization.PU.SignalPatternForSteppingCache", [])
+    # Which sub-systems should use Fast Digitization
+    flags.addFlag("Digitization.DoFastDigi", [])
 
     return flags