Classes
class	MuonPhaseIITestDefaults

Functions
def	SetupArgParser ()

def	GeoModelMdtTestCfg (flags, name="GeoModelMdtTest", **kwargs)

def	GeoModelRpcTestCfg (flags, name="GeoModelRpcTest", **kwargs)

def	GeoModelTgcTestCfg (flags, name="GeoModelTgcTest", **kwargs)

def	GeoModelMmTestCfg (flags, name="GeoModelMmTest", **kwargs)

def	GeoModelsTgcTestCfg (flags, name="GeoModelsTgcTest", **kwargs)

def	GeoModelCscTestCfg (flags, name="GeoModelCscTest", **kwargs)

def	setupServicesCfg (flags)

def	NswGeoPlottingAlgCfg (flags, name="NswGeoPlotting", **kwargs)

def	configureDefaultTagsCfg (flags)

def	setupGeoR4TestCfg (args, flags=None)

def	executeTest (cfg)

Variables
def	args = SetupArgParser().parse_args()

	flags = initConfigFlags()

	NumThreads

	NumConcurrentEvents

	Files

	AtlasVersion

	GlobalTag

	ShowDataDeps

	ShowDataFlow

	MaxEvents

	evaluate

	cfg = SetupMuonStandaloneCA(flags)

def	chambToTest = 0 else []

def	chambToExclude = args.excludedChambers

	checkGeo
	Ensure consistent translation of the geometry. More...

	dumpGeo

	setVerbose

Function Documentation

◆ configureDefaultTagsCfg()

def testGeoModel.configureDefaultTagsCfg ( flags )

Definition at line 122 of file MuonPhaseII/MuonDetDescr/MuonGeoModelTestR4/python/testGeoModel.py.

 def configureDefaultTagsCfg(flags):    
     from AthenaCommon.Logging import logging
     log = logging.getLogger('GeometryConfiguration')
  
     if not flags.GeoModel.SQLiteDB:
         raise ValueError("Default tag configuration only works for SQLite")
     
     from AthenaConfiguration.TestDefaults import defaultGeometryTags
     flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN2    
     from AthenaConfiguration.Enums import LHCPeriod
     if flags.GeoModel.Run == LHCPeriod.Run3:   
         flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN3
     elif flags.GeoModel.Run == LHCPeriod.Run4:
           flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN4
     else:
         raise ValueError(f"Invalid run period {flags.GeoModel.Run}")
     from MuonConfig.MuonConfigUtils import configureCondTag
     configureCondTag(flags)
  
     log.info(f"Setup {flags.GeoModel.AtlasVersion} geometry loading {flags.GeoModel.SQLiteDBFullPath}")
     log.info(f"Use conditions tag {flags.IOVDb.GlobalTag}")
     
  

◆ executeTest()

def testGeoModel.executeTest ( cfg )

Definition at line 252 of file MuonPhaseII/MuonDetDescr/MuonGeoModelTestR4/python/testGeoModel.py.

 def executeTest(cfg):
     cfg.printConfig(withDetails=True, summariseProps=True)
     if not cfg.run().isSuccess(): exit(1)
  

◆ GeoModelCscTestCfg()

def testGeoModel.GeoModelCscTestCfg	(		flags,
			name = `"GeoModelCscTest"`,
		**	kwargs
	)

Definition at line 71 of file MuonDetDescr/MuonGeoModelTest/python/testGeoModel.py.

 def GeoModelCscTestCfg(flags, name = "GeoModelCscTest", **kwargs):
     result = ComponentAccumulator()
     if not flags.Detector.GeometryCSC: return result
     the_alg = CompFactory.MuonGM.GeoModelCscTest(name, **kwargs)
     result.addEventAlgo(the_alg)
     return result
  

◆ GeoModelMdtTestCfg()

def testGeoModel.GeoModelMdtTestCfg	(		flags,
			name = `"GeoModelMdtTest"`,
		**	kwargs
	)

Definition at line 35 of file MuonDetDescr/MuonGeoModelTest/python/testGeoModel.py.

 def GeoModelMdtTestCfg(flags, name = "GeoModelMdtTest", **kwargs):
     result = ComponentAccumulator()
     if not flags.Detector.GeometryMDT: return result
     from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
     result.merge(MDTCablingConfigCfg(flags))
     the_alg = CompFactory.MuonGM.GeoModelMdtTest(name, **kwargs)
     result.addEventAlgo(the_alg)
     return result
  

◆ GeoModelMmTestCfg()

def testGeoModel.GeoModelMmTestCfg	(		flags,
			name = `"GeoModelMmTest"`,
		**	kwargs
	)

Definition at line 57 of file MuonDetDescr/MuonGeoModelTest/python/testGeoModel.py.

 def GeoModelMmTestCfg(flags,name = "GeoModelMmTest", **kwargs):
     result = ComponentAccumulator()
     if not flags.Detector.GeometryMM: return result
     the_alg = CompFactory.MuonGM.GeoModelMmTest(name, **kwargs)
     result.addEventAlgo(the_alg)
     return result
  

◆ GeoModelRpcTestCfg()

def testGeoModel.GeoModelRpcTestCfg	(		flags,
			name = `"GeoModelRpcTest"`,
		**	kwargs
	)

Definition at line 44 of file MuonDetDescr/MuonGeoModelTest/python/testGeoModel.py.

 def GeoModelRpcTestCfg(flags,name = "GeoModelRpcTest", **kwargs):
     result = ComponentAccumulator()
     if not flags.Detector.GeometryRPC: return result
     the_alg = CompFactory.MuonGM.GeoModelRpcTest(name, **kwargs)
     result.addEventAlgo(the_alg)
     return result
  

◆ GeoModelsTgcTestCfg()

def testGeoModel.GeoModelsTgcTestCfg	(		flags,
			name = `"GeoModelsTgcTest"`,
		**	kwargs
	)

Definition at line 64 of file MuonDetDescr/MuonGeoModelTest/python/testGeoModel.py.

 def GeoModelsTgcTestCfg(flags, name = "GeoModelsTgcTest", **kwargs):
     result = ComponentAccumulator()
     if not flags.Detector.GeometrysTGC: return result
     the_alg = CompFactory.MuonGM.GeoModelsTgcTest(name, **kwargs)
     result.addEventAlgo(the_alg)
     return result
  

◆ GeoModelTgcTestCfg()

def testGeoModel.GeoModelTgcTestCfg	(		flags,
			name = `"GeoModelTgcTest"`,
		**	kwargs
	)

Definition at line 51 of file MuonDetDescr/MuonGeoModelTest/python/testGeoModel.py.

 def GeoModelTgcTestCfg(flags,name = "GeoModelTgcTest", **kwargs):
     result = ComponentAccumulator()
     if not flags.Detector.GeometryTGC: return result
     the_alg = CompFactory.MuonGM.GeoModelTgcTest(name, **kwargs)
     result.addEventAlgo(the_alg)
     return result

◆ NswGeoPlottingAlgCfg()

def testGeoModel.NswGeoPlottingAlgCfg	(		flags,
			name = `"NswGeoPlotting"`,
		**	kwargs
	)

Definition at line 111 of file MuonPhaseII/MuonDetDescr/MuonGeoModelTestR4/python/testGeoModel.py.

 def NswGeoPlottingAlgCfg(flags, name="NswGeoPlotting", **kwargs):
     result = ComponentAccumulator()
     kwargs.setdefault("TestActsSurface", True)
     kwargs.setdefault("plotTgc", flags.Detector.GeometryTGC)
     kwargs.setdefault("plotStgc", flags.Detector.GeometrysTGC)
     kwargs.setdefault("plotMm", flags.Detector.GeometryMM)
     
     the_alg = CompFactory.MuonGMR4.NswGeoPlottingAlg(name, **kwargs)
     result.addEventAlgo(the_alg, primary = True)
     return result
  

◆ SetupArgParser()

def testGeoModel.SetupArgParser ( )

Definition at line 6 of file MuonDetDescr/MuonGeoModelTest/python/testGeoModel.py.

 def SetupArgParser():
     from AthenaConfiguration.TestDefaults import defaultConditionsTags, defaultGeometryTags, defaultTestFiles
  
     from argparse import ArgumentParser
  
     parser = ArgumentParser()
     parser.add_argument("--threads", type=int, help="number of threads", default=1)
     parser.add_argument("--inputFile", "-i", default=defaultTestFiles.EVNT, 
                         help="Input file to run on ", nargs="+")
     parser.add_argument("--geoTag", default=defaultGeometryTags.RUN3, help="Geometry tag to use", choices=[defaultGeometryTags.RUN2_BEST_KNOWLEDGE ,
                                                                                                            defaultGeometryTags.RUN3])
     parser.add_argument("--condTag", default=defaultConditionsTags.RUN3_MC, help="Conditions tag to use",
                                                                             choices=[defaultConditionsTags.RUN3_MC,
                                                                                      defaultConditionsTags.RUN3_DATA,
                                                                                      defaultConditionsTags.RUN2_DATA,
                                                                                      defaultConditionsTags.RUN2_MC])
     parser.add_argument("--chambers", default=["all"
     ], nargs="+", help="Chambers to check. If string is all, all chambers will be checked")
     parser.add_argument("--excludedChambers", default=[], nargs="+", help="Chambers to exclude. If string contains 'none', all chambers will be checked. Note: adding a chamber to --excludedChambers will overwrite it being in --chambers.")
     parser.add_argument("--outRootFile", default="LegacyGeoModelDump.root", help="Output ROOT file to dump the geomerty")
     parser.add_argument("--noMdt", help="Disable the Mdts from the geometry", action='store_true', default = False)
     parser.add_argument("--noRpc", help="Disable the Rpcs from the geometry", action='store_true', default = False)
     parser.add_argument("--noTgc", help="Disable the Tgcs from the geometry", action='store_true', default = False)
     parser.add_argument("--noMM", help="Disable the MMs from the geometry", action='store_true', default = False)
     parser.add_argument("--noSTGC", help="Disable the sTgcs from the geometry", action='store_true', default = False)
     
     return parser
  
  

◆ setupGeoR4TestCfg()

def testGeoModel.setupGeoR4TestCfg	(	args,
		flags = `None`
	)

Definition at line 145 of file MuonPhaseII/MuonDetDescr/MuonGeoModelTestR4/python/testGeoModel.py.

 def setupGeoR4TestCfg(args,  flags = None):
     
     if flags is None:
         from AthenaConfiguration.AllConfigFlags import initConfigFlags
         flags = initConfigFlags()
     flags.Concurrency.NumThreads = args.threads
     flags.Concurrency.NumConcurrentEvents = args.threads
     flags.Exec.MaxEvents = args.nEvents
     flags.Exec.SkipEvents = args.skipEvents
     from os import path, system, listdir
     flags.Input.Files = []
     
     for fileArg in args.inputFile:
         if path.isdir(fileArg):
             flags.Input.Files += [ "{dir}/{file}".format(dir=fileArg, file=y) for y in listdir(fileArg) ]
         else:
             if fileArg[fileArg.rfind(".")+1 :]not in ["txt", "conf"]:
                  flags.Input.Files+=[fileArg]
             else:
                 with open(fileArg) as inStream:
                    flags.Input.Files+=[ line.strip() for line in inStream if line[0]!='#'] 
  
     flags.Exec.FPE= 500
     flags.Exec.EventPrintoutInterval = 500
     
     if args.defaultGeoFile == "RUN3":
         flags.GeoModel.SQLiteDBFullPath =  MuonPhaseIITestDefaults.GEODB_R3
     elif args.defaultGeoFile == "RUN4":
         flags.GeoModel.SQLiteDBFullPath =  MuonPhaseIITestDefaults.GEODB_R4
     elif args.defaultGeoFile == "RUN3MSOnly":
         flags.GeoModel.SQLiteDBFullPath = MuonPhaseIITestDefaults.GEODB_R3MSOnly
     elif args.defaultGeoFile == "RUN4MSOnly":
         flags.GeoModel.SQLiteDBFullPath = MuonPhaseIITestDefaults.GEODB_R4MSOnly
     elif args.defaultGeoFile == "ITkR3MS":
         flags.GeoModel.SQLiteDBFullPath = MuonPhaseIITestDefaults.GEODB_ITk_R3MS
     elif args.geoModelFile.startswith("root://"):
         if not path.exists("Geometry/{geoTag}.db".format(geoTag=args.geoTag)):
             print ("Copy geometry file from EOS {source}".format(source = args.geoModelFile))
             system("mkdir Geometry/")
             system("xrdcp {source} Geometry/{geoTag}.db".format(source = args.geoModelFile,
                                                                 geoTag=args.geoTag))
                                 
         args.geoModelFile = "Geometry/{geoTag}.db".format(geoTag=args.geoTag)
     else:
         flags.GeoModel.SQLiteDBFullPath = args.geoModelFile
  
     flags.GeoModel.SQLiteDB = True
     configureDefaultTagsCfg(flags)
     
     flags.Detector.GeometryBpipe = False
     
     flags.Detector.GeometryBCM = False
     flags.Detector.GeometryPixel = False
     flags.Detector.GeometrySCT = False
     flags.Detector.GeometryTRT = False
     
     flags.Detector.GeometryPLR = False
     flags.Detector.GeometryBCMPrime = False
     flags.Detector.GeometryITkPixel = False
     flags.Detector.GeometryITkStrip = False
     
     flags.Detector.GeometryHGTD = False
     
     flags.Detector.GeometryLAr = False
     flags.Detector.GeometryTile = False
     flags.Detector.GeometryMBTS = False
     flags.Detector.GeometryCalo = False
     
     flags.Detector.GeometryCSC = False
     if args.noSTGC:
         flags.Detector.GeometrysTGC = False
     if args.noMM:
         flags.Detector.GeometryMM = False
     if args.noTgc:
         flags.Detector.GeometryTGC = False
     if args.noRpc:
         flags.Detector.GeometryRPC = False    
     if args.noMdt:
         flags.Detector.GeometryMDT = False
  
     flags.Scheduler.CheckDependencies = True
     flags.Scheduler.ShowDataDeps = True
     flags.Scheduler.ShowDataFlow = True
     flags.Scheduler.ShowControlFlow = True
     flags.Scheduler.EnableVerboseViews = True
     flags.Scheduler.AutoLoadUnmetDependencies = True
     #flags.PerfMon.doFullMonMT = True
     flags.lock()
     flags.dump(evaluate = True)
     cfg = setupServicesCfg(flags)
  
     from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
     cfg.merge(MuonGeoModelCfg(flags))
  
  
     if not flags.Muon.usePhaseIIGeoSetup:
         print ("WARNING: New Muon plugin is not part of the Geometry file {geoDBFile}".format(geoDBFile=args.geoModelFile))
     else:
         from ActsAlignmentAlgs.AlignmentAlgsConfig import ActsGeometryContextAlgCfg
         cfg.merge(ActsGeometryContextAlgCfg(flags))
  
     cfg.getService("MessageSvc").verboseLimit = 10000000
     cfg.getService("MessageSvc").debugLimit = 10000000
  
     return flags, cfg
  

◆ setupServicesCfg()

def testGeoModel.setupServicesCfg ( flags )

Definition at line 61 of file MuonPhaseII/MuonDetDescr/MuonGeoModelTestR4/python/testGeoModel.py.

 def setupServicesCfg(flags):
     from AthenaConfiguration.MainServicesConfig import MainServicesCfg
     result = MainServicesCfg(flags)
     
     from AthenaConfiguration.Enums import Format
     if flags.Input.Format is Format.POOL:
         from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
         result.merge(PoolReadCfg(flags))
     elif flags.Input.Format == Format.BS:
         from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
         result.merge(ByteStreamReadCfg(flags)) 
  
     from PerfMonComps.PerfMonCompsConfig import PerfMonMTSvcCfg
     result.merge(PerfMonMTSvcCfg(flags))
     from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
     result.merge(MuonIdHelperSvcCfg(flags))
     return result
  