diff --git a/InnerDetector/InDetConfig/python/InDetConfigFlags.py b/InnerDetector/InDetConfig/python/InDetConfigFlags.py
index 4fe02f365f3efd1ac9228ec2ddc160d1af15da8b..d7f373aaf1e4becce4a40a53f261c3d4437a335d 100644
--- a/InnerDetector/InDetConfig/python/InDetConfigFlags.py
+++ b/InnerDetector/InDetConfig/python/InDetConfigFlags.py
@@ -9,23 +9,22 @@ def createInDetConfigFlags():
 
   icf.addFlag("InDet.doDBMstandalone",False)
   icf.addFlag("InDet.doSplitReco", False) # Turn running of the truth seeded pseudo tracking only for pileup on and off. Only makes sense to run on RDO file where SplitDigi was used!
+  icf.addFlag("InDet.doTruth", lambda f: f.Input.isMC) # Turn running of truth matching on and off (by default on for MC off for data)
 
   icf.addFlag("InDet.Tracking.doRefit", False) # Turn running of refitting on and off
+  icf.addFlag("InDet.Tracking.doHighPileup", False) # Turn running of high pile-up reconstruction on and off
+  icf.addFlag("InDet.Tracking.doBackTracking", True) # Turn running of backtracking on and off
+  icf.addFlag("InDet.Tracking.doLowPt", False) # Turn running of doLowPt second pass on and off
+  icf.addFlag("InDet.Tracking.doVeryLowPt", False) # Turn running of doVeryLowPt thrid pass on and off
+  icf.addFlag("InDet.Tracking.doForwardTracks", True) # Turn running of doForwardTracks pass on and off
+  icf.addFlag("InDet.Tracking.doTrackSegmentsDisappearing", True)
+  icf.addFlag("InDet.Tracking.doLowPtLargeD0", False) # Turn running of doLargeD0 second pass down to 100 MeV on and off Turn running of doLargeD0 second pass on and off
+  icf.addFlag("InDet.Tracking.doLargeD0", False)
+  icf.addFlag("InDet.Tracking.doR3LargeD0", True)
+  icf.addFlag("InDet.Tracking.storeSeparateLargeD0Container", True)
+  icf.addFlag("InDet.Tracking.cutLevel", 19) # Control cuts and settings for different lumi to limit CPU and disk space
+  icf.addFlag("InDet.Tracking.doBremRecovery", True) # Turn on running of Brem Recover in tracking
 
-  icf.addFlag("InDet.doHighPileup", False) # Turn running of high pile-up reconstruction on and off
-  icf.addFlag("InDet.doTruth", lambda f: f.Input.isMC) # Turn running of truth matching on and off (by default on for MC off for data)
-  icf.addFlag("InDet.doBackTracking", True) # Turn running of backtracking on and off
-  icf.addFlag("InDet.doLowPt", False) # Turn running of doLowPt second pass on and off
-  icf.addFlag("InDet.doVeryLowPt", False) # Turn running of doVeryLowPt thrid pass on and off
-  icf.addFlag("InDet.doForwardTracks", True) # Turn running of doForwardTracks pass on and off
-  icf.addFlag("InDet.doTrackSegmentsDisappearing", True)
-  icf.addFlag("InDet.doLowPtLargeD0", False) # Turn running of doLargeD0 second pass down to 100 MeV on and off Turn running of doLargeD0 second pass on and off
-  icf.addFlag("InDet.doLargeD0", False)
-  icf.addFlag("InDet.doR3LargeD0", True)
-  icf.addFlag("InDet.storeSeparateLargeD0Container", True)
-  icf.addFlag("InDet.useExistingTracksAsInput", False) # Use already processed Track from a (D)ESD input file. This flag is related with ProcessedESDTracks InDetKey
-  icf.addFlag("InDet.cutLevel", 19) # Control cuts and settings for different lumi to limit CPU and disk space
-  icf.addFlag("InDet.doBremRecovery", True) # Turn on running of Brem Recover in tracking
   icf.addFlag("InDet.doCaloSeededBrem", True) # Brem Recover in tracking restricted to Calo ROIs
   icf.addFlag("InDet.doHadCaloSeededSSS", False) # Use Recover SSS to Calo ROIs
   icf.addFlag("InDet.doCaloSeededAmbi", lambda prevFlags: prevFlags.Detector.EnableCalo) # Use Calo ROIs to seed specific cuts for the ambi
diff --git a/InnerDetector/InDetConfig/python/TRTExtensionConfig.py b/InnerDetector/InDetConfig/python/TRTExtensionConfig.py
index 0efd89a6d199a834ef9e28d2d97d0798ecdb4c74..6c1f4825b281e2a9fcf7c33961714cabc04c6c4e 100644
--- a/InnerDetector/InDetConfig/python/TRTExtensionConfig.py
+++ b/InnerDetector/InDetConfig/python/TRTExtensionConfig.py
@@ -102,7 +102,7 @@ def InDetExtensionProcessorCfg(flags, SiTrackCollection=None, ExtendedTrackColle
     kwargs.setdefault("TrackSummaryTool", InDetTrackSummaryTool)
     kwargs.setdefault("ScoringTool", InDetExtenScoringTool)
     kwargs.setdefault("suppressHoleSearch", False)
-    kwargs.setdefault("tryBremFit", flags.InDet.doBremRecovery)
+    kwargs.setdefault("tryBremFit", flags.InDet.Tracking.doBremRecovery)
     kwargs.setdefault("caloSeededBrem", flags.InDet.doCaloSeededBrem)
     kwargs.setdefault("pTminBrem", flags.InDet.Tracking.Pass.minPTBrem)
     kwargs.setdefault("RefitPrds", not (flags.InDet.refitROT or (flags.InDet.trtExtensionType == 'DAF')))
diff --git a/InnerDetector/InDetConfig/python/TrackRecoConfig.py b/InnerDetector/InDetConfig/python/TrackRecoConfig.py
index 400a90139a6a86fd146d6135cfc7776169e098b9..c807df178e3275750125b154642adb968b9b14ca 100644
--- a/InnerDetector/InDetConfig/python/TrackRecoConfig.py
+++ b/InnerDetector/InDetConfig/python/TrackRecoConfig.py
@@ -249,6 +249,9 @@ def InDetTrackRecoCfg(flags):
     from InDetConfig.SiliconPreProcessing import InDetRecPreProcessingSiliconCfg
     result.merge(InDetRecPreProcessingSiliconCfg(flags))
 
+    if flags.InDet.Tracking.doHighPileup:
+        flags = flags.cloneAndReplace("InDet.Tracking.Pass", "InDet.Tracking.HighPileupPass")
+
     from InDetConfig.TrackingSiPatternConfig import TrackingSiPatternCfg
     result.merge(TrackingSiPatternCfg(flags, [], "ResolvedTracks", "SiSPSeededTracks"))
 
@@ -273,7 +276,7 @@ def InDetTrackRecoCfg(flags):
                                           "TRTSegments"))
 
     # BackTracking
-    if flags.InDet.doBackTracking:
+    if flags.InDet.Tracking.doBackTracking:
         from InDetConfig.BackTrackingConfig import BackTrackingCfg
         result.merge(BackTrackingCfg(flags,
                                      InputCombinedInDetTracks,
@@ -281,8 +284,10 @@ def InDetTrackRecoCfg(flags):
         InputCombinedInDetTracks += ["ResolvedTRTSeededTracks"]
 
     # LRT
-    if flags.InDet.doLargeD0 or flags.InDet.doR3LargeD0:
-        if flags.InDet.doR3LargeD0:
+    if flags.InDet.Tracking.doLargeD0 or flags.InDet.Tracking.doR3LargeD0 or flags.InDet.Tracking.doLowPtLargeD0:
+        if flags.InDet.Tracking.doLowPtLargeD0:
+            flagsLRT = flags.cloneAndReplace("InDet.Tracking.Pass", "InDet.Tracking.LowPtLargeD0Pass")
+        elif flags.InDet.Tracking.doR3LargeD0:
             flagsLRT = flags.cloneAndReplace("InDet.Tracking.Pass", "InDet.Tracking.R3LargeD0Pass")
         else:
             flagsLRT = flags.cloneAndReplace("InDet.Tracking.Pass", "InDet.Tracking.LargeD0Pass")
@@ -295,7 +300,7 @@ def InDetTrackRecoCfg(flags):
                                                     ExtendedTracksMap="ExtendedTracksMapLargeD0",
                                                     doPhase=False))
             LRTTrackContainer = "ExtendedLargeD0Tracks"
-        if flags.InDet.storeSeparateLargeD0Container:
+        if flags.InDet.Tracking.storeSeparateLargeD0Container:
             if flags.InDet.doTruth:
                 from InDetConfig.TrackTruthConfig import InDetTrackTruthCfg
                 result.merge(InDetTrackTruthCfg(flagsLRT,
@@ -310,7 +315,7 @@ def InDetTrackRecoCfg(flags):
             InputCombinedInDetTracks += [LRTTrackContainer]
 
     # Low pt
-    if flags.InDet.doLowPt:
+    if flags.InDet.Tracking.doLowPt:
         flagsLowPt = flags.cloneAndReplace("InDet.Tracking.Pass", "InDet.Tracking.LowPtPass")
         result.merge(TrackingSiPatternCfg(flagsLowPt, InputCombinedInDetTracks, "ResolvedLowPtTracks", "SiSpSeededLowPtTracks"))
         LowPtTrackContainer = "ResolvedLowPtTracks"
@@ -324,7 +329,7 @@ def InDetTrackRecoCfg(flags):
         InputCombinedInDetTracks += [LowPtTrackContainer]
 
     # Very low pt
-    if flags.InDet.doVeryLowPt:
+    if flags.InDet.Tracking.doVeryLowPt:
         flagsVeryLowPt = flags.cloneAndReplace("InDet.Tracking.Pass", "InDet.Tracking.VeryLowPtPass")
         result.merge(TrackingSiPatternCfg(flagsVeryLowPt, InputCombinedInDetTracks, "ResolvedVeryLowPtTracks", "SiSpSeededLowPtTracks"))
         InputCombinedInDetTracks += ["ResolvedVeryLowPtTracks"]
@@ -337,11 +342,11 @@ def InDetTrackRecoCfg(flags):
         InputCombinedInDetTracks += ["TRTStandaloneTracks"]
 
     # Forward tracklets
-    if flags.InDet.doForwardTracks:
+    if flags.InDet.Tracking.doForwardTracks:
         # Add tracks that are not saved to the InputCombinedInDetTracks
         InputForwardInDetTracks = []
         InputForwardInDetTracks += InputCombinedInDetTracks
-        if flags.InDet.storeSeparateLargeD0Container:
+        if flags.InDet.Tracking.storeSeparateLargeD0Container:
             InputForwardInDetTracks += ["ExtendedLargeD0Tracks"]
 
         flagsForward = flags.cloneAndReplace("InDet.Tracking.Pass", "InDet.Tracking.ForwardTracksPass")
@@ -359,13 +364,13 @@ def InDetTrackRecoCfg(flags):
                                             TrackContainerName="ResolvedForwardTracks",
                                             OutputTrackParticleContainer="InDetForwardTrackParticles"))
 
-    if flags.InDet.doTrackSegmentsDisappearing:
+    if flags.InDet.Tracking.doTrackSegmentsDisappearing:
         InputPixelInDetTracks = []
         InputPixelInDetTracks += InputCombinedInDetTracks
         # Add tracks that are not saved to the InputCombinedInDetTracks
-        if flags.InDet.doForwardTracks:
+        if flags.InDet.Tracking.doForwardTracks:
             InputPixelInDetTracks += ["ResolvedForwardTracks"]
-        if flags.InDet.storeSeparateLargeD0Container:
+        if flags.InDet.Tracking.storeSeparateLargeD0Container:
             InputPixelInDetTracks += ["ExtendedLargeD0Tracks"]
 
         flagsDisappearing = flags.cloneAndReplace("InDet.Tracking.Pass", "InDet.Tracking.DisappearingPass")
diff --git a/InnerDetector/InDetConfig/python/TrackingCommonConfig.py b/InnerDetector/InDetConfig/python/TrackingCommonConfig.py
index 666b4fcb7efb57f2a6722ae23b3c9f79b77d4836..5d900cc65f837bc81efe17fd582e176f16c66fa7 100644
--- a/InnerDetector/InDetConfig/python/TrackingCommonConfig.py
+++ b/InnerDetector/InDetConfig/python/TrackingCommonConfig.py
@@ -481,8 +481,7 @@ def InDetTrackSummaryToolSharedHitsCfg(flags, name='InDetTrackSummaryToolSharedH
         kwargs.setdefault("InDetSummaryHelperTool", InDetSummaryHelperSharedHits)
 
     if 'TRT_ElectronPidTool' not in kwargs:
-        if not flags.Detector.EnableTRT or flags.InDet.doHighPileup \
-            or  flags.InDet.useExistingTracksAsInput: # TRT_RDOs (used by the TRT_LocalOccupancy tool) are not present in ESD
+        if not flags.Detector.EnableTRT or flags.InDet.Tracking.doHighPileup:
             kwargs.setdefault("TRT_ElectronPidTool", None)
         else:
             from InDetConfig.TRT_ElectronPidToolsConfig import TRT_ElectronPidToolCfg
@@ -653,7 +652,7 @@ def KalmanFitterCfg(flags, name='KalmanFitter',**kwargs) :
     acc = ComponentAccumulator()
 
     kwargs.setdefault('ForwardKalmanFitterHandle', InDetFKF())
-    if flags.InDet.doBremRecovery:
+    if flags.InDet.Tracking.doBremRecovery:
         kwargs.setdefault('DynamicNoiseAdjustorHandle', InDetDNAdjustor())
         kwargs.setdefault('BrempointAnalyserHandle', InDetDNASeparator())
         kwargs.setdefault('DoDNAForElectronsOnly', True)
@@ -1175,7 +1174,7 @@ def InDetAmbiScoringToolBaseCfg(flags, name='InDetAmbiScoringTool', **kwargs) :
         InDetTRTDriftCircleCutForPatternReco = acc.popToolsAndMerge(InDetTRTDriftCircleCutForPatternRecoCfg(flags))
         kwargs.setdefault("DriftCircleCutTool", InDetTRTDriftCircleCutForPatternReco )
 
-    have_calo_rois = flags.InDet.doBremRecovery and flags.InDet.doCaloSeededBrem and flags.Detector.EnableCalo
+    have_calo_rois = flags.InDet.Tracking.doBremRecovery and flags.InDet.doCaloSeededBrem and flags.Detector.EnableCalo
     if have_calo_rois:
         alg = acc.getPrimaryAndMerge(ROIInfoVecAlgCfg(flags))
         kwargs.setdefault("CaloROIInfoName", alg.WriteKey )
@@ -1353,7 +1352,7 @@ def InDetNNScoringToolBaseCfg(flags, name='InDetNNScoringTool', **kwargs) :
     acc = ComponentAccumulator()
     the_name=makeName(name,kwargs)
 
-    have_calo_rois = flags.InDet.doBremRecovery and flags.InDet.doCaloSeededBrem and flags.Detector.EnableCalo
+    have_calo_rois = flags.InDet.Tracking.doBremRecovery and flags.InDet.doCaloSeededBrem and flags.Detector.EnableCalo
     if have_calo_rois :
         alg = acc.popToolsAndMerge(ROIInfoVecAlgCfg(flags))
         kwargs.setdefault("CaloROIInfoName", alg.WriteKey )
diff --git a/InnerDetector/InDetConfig/python/TrackingPassFlags.py b/InnerDetector/InDetConfig/python/TrackingPassFlags.py
index 419e4a283f314b7cfd8856d5f0eb4ebc4ce5cdb3..88b7d00682e415195223bd2a67c509c6b0f81a1e 100644
--- a/InnerDetector/InDetConfig/python/TrackingPassFlags.py
+++ b/InnerDetector/InDetConfig/python/TrackingPassFlags.py
@@ -16,177 +16,177 @@ def select( selInd, valuesmap ):
     raise RuntimeError("No value can be selected from ranges {} given key {}".format( valuesmap.keys(), selInd ))
 
 def minPT_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-1':   0.1 * Units.GeV,
     '2-13': 0.4 * Units.GeV,
     '14-':  0.5 * Units.GeV } )
 
 def minSecondaryPT_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-1':   0.4 * Units.GeV,
     '2-18': 1.0 * Units.GeV,
     '19-': 3.0 * Units.GeV } )
 
 def minTRTonlyPt_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-1':   0.4 * Units.GeV,
     '2-5': 1.0 * Units.GeV,
     '6-': 2.0 * Units.GeV, } )
 
 def minClusters_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-14':  7,
     '15-':  8 } )
 
 def maxHoles_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-7':  3,
     '8-':  2 } )
 
 def maxPixelHoles_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-7':  2,
     '8-':  1 } )
 
 def maxPrimaryImpact_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-15':  10.0 * Units.mm,
     '16-':  5.0 * Units.mm } )
 
 def maxZImpact_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-8':  320.0 * Units.mm,
     '9-16':  250 * Units.mm,
     '17-':  200.0 * Units.mm } )
 
 def nHolesMax_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-11':  3,
     '12-':  2 } )
 
 def nHolesGapMax_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-11':  3,
     '12-':  2 } )
 
 def Xi2max_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-11':  15.0,
     '12-':  9.0 } )
 
 def Xi2maxNoAdd_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-11':  35.0,
     '12-':  25.0 } )
 
 def seedFilterLevel_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-4':  1,
     '5-':  2 } )
 
 def maxdImpactPPSSeeds_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-3':  1.7,
     '4-':  2.0 } )
 
 def maxdImpactSSSSeeds_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-3':  1000.0,
     '4-16':  20.0,
     '17-': 5.0 * Units.mm } )
 
 def doZBoundary_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-9':  False,
     '10-':  True } )
 
 def TRTSegFinderPtBins_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-1':  70,
     '2-':  50 } )
 
 def excludeUsedTRToutliers_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-5':  False,
     '6-':  True } )
 
 def useParameterizedTRTCuts_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
                    {'-2':  False,
                     '3-':  True } )
 
 def useNewParameterizationTRT_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-2':  False,
     '3-':  True } )
 
 def minSecondaryTRTonTrk_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-6':  10,
     '7-':  15 } )
 
 def minSecondaryTRTPrecFrac_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-6':  0.0,
     '7-':  0.3 } )
 
 def maxSecondaryHoles_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-6':  2,
     '7-':  1 } )
 
 def maxSecondaryPixelHoles_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-6':  2,
     '7-':  1 } )
 
 def maxSecondarySCTHoles_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-6':  2,
     '7-':  1 } )
 
 def maxSecondaryDoubleHoles_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-6':  1,
     '7-':  0 } )
 
 def rejectShortExtensions_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-6':  False,
     '7-':  True } )
 
 def SiExtensionCuts_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-6':  False,
     '7-':  True } )
 
 def RoISeededBackTracking_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-12':  False,
     '13-':  True } )
 
 def roadWidth_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-16':  20.0,
     '17-':  12.0 } )
 
 def keepAllConfirmedPixelSeeds_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-17':  False,
     '18-':  True } )
 
 def minRoIClusterEt_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-18':  0.0,
     '19-':  6000. * Units.MeV } )
 
 def maxSeedsPerSP_Pixels_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-17':  5,
     '18-':   1 } )
 
 def maxSeedsPerSP_Strips_ranges( inflags ):
-    return select( inflags.InDet.cutLevel,
+    return select( inflags.InDet.Tracking.cutLevel,
     {'-17':  5,
     '18-':   5 } )
 
@@ -834,28 +834,28 @@ def createHeavyIonTrackingPassFlags():
     # CutLevel 3 MinBias
     # CutLevel 4  # ==CutLevel 2 with loosened hole cuts and chi^2 cuts
     # CutLevel 5 # ==CutLevel 3 with loosened hole cuts and chi^2 cuts    
-    icf.seedFilterLevel = lambda pcf: 2 if pcf.InDet.cutLevel >= 2 else 1
+    icf.seedFilterLevel = lambda pcf: 2 if pcf.InDet.Tracking.cutLevel >= 2 else 1
     
     icf.maxdImpactSSSSeeds =  lambda pcf: \
-                              20. if pcf.InDet.cutLevel >= 2 else 1000.
+                              20. if pcf.InDet.Tracking.cutLevel >= 2 else 1000.
     
     icf.minPT              = lambda pcf: \
-                             0.3 *Units.GeV  if pcf.InDet.cutLevel in [3, 5] else 0.5 * Units.GeV
+                             0.3 *Units.GeV  if pcf.InDet.Tracking.cutLevel in [3, 5] else 0.5 * Units.GeV
     icf.useParameterizedTRTCuts = lambda pcf: \
-                                  False if pcf.InDet.cutLevel >= 3 else True #Make these false on all HI cut levels >=3, since standard cut levels set it true from levels >=3
+                                  False if pcf.InDet.Tracking.cutLevel >= 3 else True #Make these false on all HI cut levels >=3, since standard cut levels set it true from levels >=3
     icf.useNewParameterizationTRT = lambda pcf: \
-                                    False if pcf.InDet.cutLevel >= 3 else True
+                                    False if pcf.InDet.Tracking.cutLevel >= 3 else True
 
     #set this to 1.7 for all HI cut levels >=4, since standard cut levels set it to 2.0 from levels >=4. Not sure it has any effect, since we don't usually run mixed seeds (also true for HI?)
     icf.maxdImpactPPSSeeds = lambda pcf: \
-                             1.7 if pcf.InDet.cutLevel >= 4 else True
+                             1.7 if pcf.InDet.Tracking.cutLevel >= 4 else True
     
-    icf.maxHoles = lambda pcf: 2 if pcf.InDet.cutLevel in [4, 5] else 0
-    icf.maxPixelHoles = lambda pcf: 1 if pcf.InDet.cutLevel in [4, 5] else 0
-    icf.maxSctHoles = lambda pcf: 1 if pcf.InDet.cutLevel in [4, 5] else 0
+    icf.maxHoles = lambda pcf: 2 if pcf.InDet.Tracking.cutLevel in [4, 5] else 0
+    icf.maxPixelHoles = lambda pcf: 1 if pcf.InDet.Tracking.cutLevel in [4, 5] else 0
+    icf.maxSctHoles = lambda pcf: 1 if pcf.InDet.Tracking.cutLevel in [4, 5] else 0
     icf.maxDoubleHoles   = 0    
-    icf.Xi2max           = lambda pcf: 9. if pcf.InDet.cutLevel in [4, 5] else 6.
-    icf.Xi2maxNoAdd      = lambda pcf: 25. if pcf.InDet.cutLevel in [4, 5] else 10.        
+    icf.Xi2max           = lambda pcf: 9. if pcf.InDet.Tracking.cutLevel in [4, 5] else 6.
+    icf.Xi2maxNoAdd      = lambda pcf: 25. if pcf.InDet.Tracking.cutLevel in [4, 5] else 10.
     icf.radMax           = 600. * Units.mm # restrict to pixels + first SCT layer
     icf.useTRT           = False
 
@@ -1082,9 +1082,9 @@ if __name__ == "__main__":
   l.setLevel(WARNING)
   ConfigFlags.loadAllDynamicFlags()
 
-  assert ConfigFlags.InDet.cutLevel == 19 , "default cut level is wrong"
+  assert ConfigFlags.InDet.Tracking.cutLevel == 19 , "default cut level is wrong"
   assert ConfigFlags.InDet.Tracking.Pass.minRoIClusterEt == 6000.0 * Units.MeV, "wrong cut value {} ".format(ConfigFlags.InDet.Tracking.Pass.minRoIClusterEt)
-  ConfigFlags.InDet.cutLevel = 2
+  ConfigFlags.InDet.Tracking.cutLevel = 2
   assert ConfigFlags.InDet.Tracking.Pass.minRoIClusterEt == 0.0, "wrong cut value {} ".format(ConfigFlags.InDet.Tracking.Pass.minRoIClusterEt)
   assert ConfigFlags.InDet.Tracking.BeamGasPass.minRoIClusterEt == 0.0, "wrong cut value {}, not following cutLevel setting ".format(ConfigFlags.InDet.Tracking.BeamGasPass.minRoIClusterEt)
 
diff --git a/InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py b/InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py
index b5fcb6ffc9fcdddbad214f6639c781d4e5d0cae3..f4dfb11750574d8b33c7db76e120ec3b394f8430 100644
--- a/InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py
+++ b/InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py
@@ -200,7 +200,7 @@ def SiTrackMaker_xkCfg(flags, name="InDetSiTrackMaker", InputCollections = None,
     kwargs.setdefault("Xi2maxMultiTracks", flags.InDet.Tracking.Pass.Xi2max)
     kwargs.setdefault("useSSSseedsFilter", flags.InDet.doSSSfilter)
     kwargs.setdefault("doMultiTracksProd", True)
-    kwargs.setdefault("useBremModel", flags.InDet.doBremRecovery and flags.InDet.Tracking.Pass.extension == "" and flags.Detector.EnableCalo)
+    kwargs.setdefault("useBremModel", flags.InDet.Tracking.doBremRecovery and flags.InDet.Tracking.Pass.extension == "" and flags.Detector.EnableCalo)
     kwargs.setdefault("doCaloSeededBrem", flags.InDet.doCaloSeededBrem and flags.Detector.EnableCalo)
     if kwargs["useBremModel"] and kwargs["doCaloSeededBrem"]:
         from InDetConfig.InDetRecCaloSeededROISelectionConfig import CaloClusterROI_SelectorCfg
@@ -494,7 +494,7 @@ def DenseEnvironmentsAmbiguityProcessorToolCfg(flags, name="InDetAmbiguityProces
     kwargs.setdefault("InputClusterSplitProbabilityName", 'SplitProb'+flags.InDet.Tracking.Pass.extension)
     kwargs.setdefault("OutputClusterSplitProbabilityName", 'InDetAmbiguityProcessorSplitProb'+flags.InDet.Tracking.Pass.extension)
     kwargs.setdefault("SuppressHoleSearch", False)
-    kwargs.setdefault("tryBremFit", flags.InDet.doBremRecovery and flags.InDet.Tracking.Pass.extension == "")
+    kwargs.setdefault("tryBremFit", flags.InDet.Tracking.doBremRecovery and flags.InDet.Tracking.Pass.extension == "")
     kwargs.setdefault("caloSeededBrem", flags.InDet.doCaloSeededBrem and flags.InDet.Tracking.Pass.extension != "DBM")
     kwargs.setdefault("pTminBrem", flags.InDet.Tracking.Pass.minPTBrem)
     kwargs.setdefault("RefitPrds", True)
@@ -540,7 +540,7 @@ def SimpleAmbiguityProcessorToolCfg(flags, name = "InDetAmbiguityProcessor", Clu
     kwargs.setdefault("InputClusterSplitProbabilityName", ClusterSplitProbContainer)
     kwargs.setdefault("OutputClusterSplitProbabilityName", 'InDetAmbiguityProcessorSplitProb'+flags.InDet.Tracking.Pass.extension)
     kwargs.setdefault("SuppressHoleSearch", False)
-    kwargs.setdefault("tryBremFit", flags.InDet.doBremRecovery and flags.InDet.Tracking.Pass.extension == "")
+    kwargs.setdefault("tryBremFit", flags.InDet.Tracking.doBremRecovery and flags.InDet.Tracking.Pass.extension == "")
     kwargs.setdefault("caloSeededBrem", flags.InDet.doCaloSeededBrem and flags.InDet.Tracking.Pass.extension != "DBM")
     kwargs.setdefault("pTminBrem", flags.InDet.Tracking.Pass.minPTBrem)
     kwargs.setdefault("RefitPrds", True)
diff --git a/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedReconstructionConfig.py b/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedReconstructionConfig.py
index 8c1865d51a6fde5dd13f894483b486106dd4ee3c..dd6ccf63f6014e27639eba74c67fe4bbb5a9b6fe 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedReconstructionConfig.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedReconstructionConfig.py
@@ -310,7 +310,7 @@ def MuonCombinedReconstructionCfg(flags):
     result.merge( MuonCombinedInDetCandidateAlgCfg(flags) )
     result.merge( MuonCombinedMuonCandidateAlgCfg(flags) )
 
-    if flags.Detector.GeometryID and flags.InDet.doR3LargeD0:
+    if flags.Detector.GeometryID and flags.InDet.Tracking.doR3LargeD0:
         result.merge( MuonCombinedInDetCandidateAlg_LRTCfg(flags) )
 
     if flags.MuonCombined.doStatisticalCombination or flags.MuonCombined.doCombinedFit:
@@ -323,7 +323,7 @@ def MuonCombinedReconstructionCfg(flags):
         result.merge(MuonInsideOutRecoAlgCfg(flags, name="MuonInsideOutRecoAlg") ) 
         if flags.MuonCombined.doMuGirlLowBeta:
             result.merge(MuGirlStauAlgCfg)
-        if flags.Detector.GeometryID and flags.InDet.doR3LargeD0: 
+        if flags.Detector.GeometryID and flags.InDet.Tracking.doR3LargeD0:
             result.merge( MuGirlAlg_LRTCfg(flags) )
 
     if flags.MuonCombined.doCaloTrkMuId:
@@ -371,7 +371,7 @@ if __name__=="__main__":
     ConfigFlags.Detector.GeometrySCT   = True 
     ConfigFlags.Detector.GeometryTRT   = True  
     ConfigFlags.Output.ESDFileName=args.output
-    ConfigFlags.InDet.doR3LargeD0 = False # Not working with this input
+    ConfigFlags.InDet.Tracking.doR3LargeD0 = False # Not working with this input
     if args.debug:
         from AthenaCommon.Debugging import DbgStage
         if args.debug not in DbgStage.allowed_values:
diff --git a/Reconstruction/RecoTools/TrackToCalo/python/CaloExtensionBuilderAlgCfg.py b/Reconstruction/RecoTools/TrackToCalo/python/CaloExtensionBuilderAlgCfg.py
index fb4be91968025d9a11173566d99c5675a2c3ccab..164e4fc6117bba8095088ef3398d9b8c53354934 100644
--- a/Reconstruction/RecoTools/TrackToCalo/python/CaloExtensionBuilderAlgCfg.py
+++ b/Reconstruction/RecoTools/TrackToCalo/python/CaloExtensionBuilderAlgCfg.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 from AthenaConfiguration.ComponentFactory import CompFactory
 
 def CaloExtensionBuilderAlgCfg(flags, name="CaloExtensionBuilderAlg", **kwargs):
@@ -30,6 +30,6 @@ def CaloExtensionBuilderAlgLRTCfg(flags, name="CaloExtensionBuilderAlg_LRT", **k
 
 def CaloExtensionBuilderCfg(flags):
     result = CaloExtensionBuilderAlgCfg(flags)
-    if flags.Detector.GeometryID and flags.InDet.doR3LargeD0 and flags.InDet.storeSeparateLargeD0Container:
+    if flags.Detector.GeometryID and flags.InDet.Tracking.doR3LargeD0 and flags.InDet.Tracking.storeSeparateLargeD0Container:
         result.merge(CaloExtensionBuilderAlgLRTCfg(flags))
     return result
diff --git a/Reconstruction/egamma/egammaConfig/python/egammaSteeringConfig.py b/Reconstruction/egamma/egammaConfig/python/egammaSteeringConfig.py
index 3182ac01dacc11e199c94f134cfe81235d5477a5..d1196290d7c6fc1bbc2eaa2b282ac7167d7dc847 100644
--- a/Reconstruction/egamma/egammaConfig/python/egammaSteeringConfig.py
+++ b/Reconstruction/egamma/egammaConfig/python/egammaSteeringConfig.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 
 __doc__ = """
           Instantiate the
@@ -45,7 +45,7 @@ def EGammaSteeringCfg(flags,
         acc.merge(egammaxAODThinningCfg(flags))
 
     # LRT Reconstruction
-    if flags.Detector.GeometryID and flags.InDet.doR3LargeD0:
+    if flags.Detector.GeometryID and flags.InDet.Tracking.doR3LargeD0:
         from egammaConfig.egammaLRTReconstructionConfig import (
             egammaLRTReconstructionCfg)
         acc.merge(egammaLRTReconstructionCfg(flags))