IDAlign_Skeleton Namespace Reference

Functions
	getT0SolveDB (runArgs)
	configureFlags (runArgs)
	fromRunArgs (runArgs)

Variables
	msg = logging.getLogger('IDAlign')
	jobPropertiesDisallowed

Function Documentation

configureFlags()

IDAlign_Skeleton.configureFlags

(

runArgs

)

Definition at line 65 of file IDAlign_Skeleton.py.

def configureFlags(runArgs):
    from AthenaConfiguration.AllConfigFlags import initConfigFlags
    flags = initConfigFlags()
 
    
    for IDpart in runArgs.excludeIDPart:
        setattr(flags.InDet.Align, f"align{IDpart}", False)
 
    
    if hasattr(runArgs, "localDatabase"): 
        flags.InDet.Align.localDataBase = os.path.abspath(runArgs.localDatabase)
    
    if runArgs.eosT0Dir != "":
        flags.InDet.Align.localDataBase = getT0SolveDB(runArgs)
        
    else:
        flags.InDet.Align.localDataBase = ""
 
    
    for tag in [tag for tag in dir(runArgs) if "Tag" in tag and tag != "globalTag"]:
        setattr(flags.InDet.Align, tag, getattr(runArgs, tag))
 
    if flags.InDet.Align.localDataBase:
        msg.info(f"Change IBLDist tag from '{flags.InDet.Align.IBLDistTag}' to 'InDetAlignIBLDIST-T0-Alignment'")
        msg.info(f"Change L1IDTag tag from '{flags.InDet.Align.L1IDTag}' to 'InDetAlignL1-T0-Alignment'")
        msg.info(f"Change L2PIXTag tag from '{flags.InDet.Align.L2PIXTag}' to 'InDetAlignL2PIX-T0-Alignment'")
        msg.info(f"Change L2SCTTag tag from '{flags.InDet.Align.L2SCTTag}' to 'InDetAlignL2SCT-T0-Alignment'")
        msg.info(f"Change L1TRTTag tag from '{flags.InDet.Align.L1TRTTag}' to 'InDetAlignL1TRT-T0-Alignment'")
 
        flags.InDet.Align.IBLDistTag = "InDetAlignIBLDIST-T0-Alignment"
        flags.InDet.Align.L1IDTag = "InDetAlignL1-T0-Alignment"
        flags.InDet.Align.L2PIXTag = "InDetAlignL2PIX-T0-Alignment"
        flags.InDet.Align.L2SCTTag = "InDetAlignL2SCT-T0-Alignment"
        flags.InDet.Align.L1TRTTag = "InDetAlignL1TRT-T0-Alignment"
 
    
    from InDetAlignConfig.IDAlignFlags import setL11AlignmentFlags, setL16AlignmentFlags, setL2AlignmentFlags, setL3AlignmentFlags
 
    if runArgs.alignLevel == 11:
        setL11AlignmentFlags(flags)
       
    elif runArgs.alignLevel == 16:
        setL16AlignmentFlags(flags)
        
    elif runArgs.alignLevel == 2:
        setL2AlignmentFlags(flags)
        
    elif runArgs.alignLevel == 3:
        setL3AlignmentFlags(flags)
 
    else:
        raise Exception(f"No valid alignment level has been selected: '{runArgs.alignLevel}'")
 
    
    from InDetConfig.ConfigurationHelpers import OnlyTrackingPreInclude
    OnlyTrackingPreInclude(flags)
 
    
    flags.InDet.Align.accumulate = runArgs.accumulate
    flags.InDet.Align.baseDir = os.path.abspath(runArgs.baseDir)
    flags.InDet.Align.inputTracksCollection = runArgs.inputTracksCollection
    flags.Input.Files = [os.path.abspath(inputFile) for inputFile in runArgs.inputRAWFile]
    
    if runArgs.accumulate:
        if hasattr(runArgs, "outputTFile"):
            flags.InDet.Align.outputTFile = runArgs.outputTFile
    
        if hasattr(runArgs, "outputMonitorFile"):
            flags.InDet.Align.doMonitoring = True
            flags.Output.HISTFileName = f"{flags.InDet.Align.baseDir}/Accumulate/{runArgs.outputMonitorFile}"
    
    if runArgs.solve:
        flags.InDet.Align.inputTFiles = [os.path.abspath(inputTFile) for inputTFile in runArgs.inputTFile]
        flags.InDet.Align.outputConditionFile = f"{flags.InDet.Align.baseDir}/Solve/{runArgs.outputConditionFile}"
        flags.IOVDb.DBConnection = f"sqlite://;schema={flags.InDet.Align.baseDir}/Solve/{runArgs.outputDBFile};dbname=CONDBR2"
 
    flags.Exec.MaxEvents = runArgs.maxEvents if not runArgs.solve else 1
    flags.Exec.SkipEvents = runArgs.skipEvents if hasattr(runArgs, "skipEvents") else 0   
    flags.Exec.OutputLevel = getattr(AthenaCommon.Constants, runArgs.logLevel)
    flags.Exec.FPE = -2
    flags.IOVDb.GlobalTag = runArgs.globalTag
        
    flags.GeoModel.Align.Dynamic = True
    flags.GeoModel.AtlasVersion = runArgs.atlasVersion
 
    if not flags.Input.isMC and runArgs.isCosmics:
        from AthenaConfiguration.Enums import BeamType
        
        flags.Beam.NumberOfCollisions = 0
        flags.Beam.Type = BeamType.Cosmics
        flags.Beam.Energy = 0.
        flags.Beam.BunchSpacing = 50
 
    if runArgs.isHeavyIon:
        flags.Beam.BunchSpacing = 50
        flags.Reco.EnableHI = True
        flags.HeavyIon.doGlobal = True
          
    else:
        flags.Beam.BunchSpacing = 25
                
    if not runArgs.isBFieldOff:
        flags.BField.solenoidOn = True
        flags.BField.barrelToroidOn = True
        flags.BField.endcapToroidOn = True
            
    else:
        flags.BField.solenoidOn = False
        flags.BField.barrelToroidOn = False
        flags.BField.endcapToroidOn = False
 
    # process pre-include/exec
    processPreInclude(runArgs, flags)
    processPreExec(runArgs, flags)
 
    # To respect --athenaopts
    flags.fillFromArgs()
 
    # Lock flags
    flags.lock()
 
    return flags
    
 

fromRunArgs()

IDAlign_Skeleton.fromRunArgs

(

runArgs

)

Definition at line 189 of file IDAlign_Skeleton.py.

def fromRunArgs(runArgs):
    flags = configureFlags(runArgs)
 
    from AthenaConfiguration.MainServicesConfig import MainServicesCfg
    cfg = MainServicesCfg(flags)
 
    from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
    cfg.merge(ByteStreamReadCfg(flags))
 
    
    with open(os.devnull, 'w') as f, contextlib.redirect_stdout(f):
        from InDetConfig.TrackRecoConfig import InDetTrackRecoCfg
        cfg.merge(InDetTrackRecoCfg(flags))
 
    
    if runArgs.accumulate and not runArgs.solve:
        os.makedirs(f"{flags.InDet.Align.baseDir}/Accumulate", exist_ok = True)
        os.chdir(f"{flags.InDet.Align.baseDir}/Accumulate")
        from InDetAlignConfig.AccumulateConfig import AccumulateCfg
        cfg.merge(AccumulateCfg(flags))
 
    
    elif runArgs.solve and not runArgs.accumulate:
        os.makedirs(f"{flags.InDet.Align.baseDir}/Solve", exist_ok = True)
        os.chdir(f"{flags.InDet.Align.baseDir}/Solve")
        from InDetAlignConfig.SolveConfig import SolveCfg
        cfg.merge(SolveCfg(flags))
               
    else:
        raise Exception("You can run either the acculumation step or the solve step, but not both or neither at the same time!")
            
    
    from InDetAlignConfig.IDAlignConditionConfig import UpdateTagsCfg
    cfg.merge(UpdateTagsCfg(flags))
 
    
    processPostInclude(runArgs, flags, cfg)
 
    
    processPostExec(runArgs, flags, cfg)
 
    
    if runArgs.dryRun:
        sc = cfg.printConfig(summariseProps = True)
       
    else:
        sc = cfg.run()
        
    
    if hasattr(runArgs, "outputTaredLogFile"):
        from glob import glob 
        import tarfile
        
        filesToTar = glob(f"{flags.InDet.Align.baseDir}/Solve/Old*") + glob(f"{flags.InDet.Align.baseDir}/Solve/Output*") + [f"{flags.InDet.Align.baseDir}/Solve/alignlogfile.txt"]
        
        with tarfile.open(f'{flags.InDet.Align.baseDir}/Solve/{runArgs.outputTaredLogFile}', "w:gz") as tar:
            for fileName in filesToTar:
                tar.add(fileName, arcname = fileName.split('/')[-1])
        
    
    if runArgs.eosT0Dir != "":
        from glob import glob
    
        for file_name in glob(f"{flags.InDet.Align.baseDir}/Accumulate/*" if runArgs.accumulate else f"{flags.InDet.Align.baseDir}/Solve/*"):
            os.system(f"mv -fv {file_name} {flags.InDet.Align.baseDir}")
        
    import sys
    sys.exit(sc.isFailure())

getT0SolveDB()

IDAlign_Skeleton.getT0SolveDB

(

runArgs

)

Definition at line 20 of file IDAlign_Skeleton.py.

def getT0SolveDB(runArgs):
    # Check which file to use to extract metadata
    if runArgs.solve and runArgs.iteration > 0:
        outputFile = runArgs.outputConditionFile
        iteration = runArgs.iteration - 1
    
    elif hasattr(runArgs, "outputTFile") and "Block" in runArgs.outputTFile:
        outputFile = runArgs.outputTFile
        iteration = runArgs.iteration - 1
 
    elif hasattr(runArgs, "outputMonitorFile") and "Block" in runArgs.outputMonitorFile:
        # For monitoring, the iteration DB file to use is the one from the current iteration
        outputFile = runArgs.outputMonitorFile
        iteration = runArgs.iteration
        
    else:
        return ""
 
    # Extract data taking period, stream, ect from output file name
    try:
        meta_data = re.search(r"^(data.*?_.*?)\.(\d+)\.(\w+).*?(c\d+.*?).*?(Block\d+)", outputFile)
        data_period, run, data_stream, AMI_tag, block = meta_data.groups()
    
    except Exception:
        raise Exception(f"Can not extract metadata from: {outputFile}")
        
    # Try to find local database file
    localDatabaseWildcard = f"{runArgs.eosT0Dir}/{data_period}/{data_stream}/{run}/{data_period}.{run}.{data_stream}.idalignsolve.ROOT_DB.Iter{iteration}*/*{block}*"
    
    try:
        from glob import glob
 
        # Get always latest DB files, in case a job restarted with a new AMI tag
        def get_AMI_Tag(file_name):
            m = re.search(r'c\d+', file_name)
            return m.group(0) if m else "c0000"
 
        localDataBases = sorted(glob(localDatabaseWildcard), key = get_AMI_Tag, reverse = True)
        latestLocalDataBase = localDataBases[0]
    
    except Exception:
        raise Exception(f"Could not find local database from wildcard: {localDatabaseWildcard}")
    
    return latestLocalDataBase
 

Variable Documentation

jobPropertiesDisallowed

IDAlign_Skeleton.jobPropertiesDisallowed

Definition at line 18 of file IDAlign_Skeleton.py.

msg

IDAlign_Skeleton.msg = logging.getLogger('IDAlign')

Definition at line 13 of file IDAlign_Skeleton.py.