python.ITkActsHelpers Namespace Reference

Functions
bool	isPrimaryPass (flags)
bool	isFastPrimaryPass (flags)
bool	isValidationPass (flags)
bool	isProductionPass (flags)
bool	primaryPassUsesDevice (flags)
bool	secondaryPassUsesDevice (flags)
bool	primaryPassUsesActs (flags)
str	primaryPassExtension (flags)
str	separateTrackParticleContainerName (flags)
list	extractTrackingPasses (flags)
list[str]	getListOfGeneratedTrackParticles (flags)

Function Documentation

extractTrackingPasses()

list extractTrackingPasses

(

flags

)

Definition at line 58 of file ITkActsHelpers.py.

def extractTrackingPasses(flags) -> list:
    # Function for extracting the requested tracking passes that need to be scheduled
    trackingPasses = []
 
    # Check there is only one chain
    # for the time being we still technically allow for a list, but we should move to a single value eventually
    if len(flags.Tracking.recoChain) != 1:
        raise ValueError(f"Conflicting reco configuration: Tracking.recoChain should have only one element but we found {flags.Tracking.recoChain}")
    
    # Quick check about fast tracking configuration
    from TrkConfig.TrkConfigFlags import ITkPrimaryPassConfig
    if flags.Tracking.ITkPrimaryPassConfig is ITkPrimaryPassConfig.Acts:
        if not flags.Tracking.doITkFastTracking:
            raise ValueError(f"Main pass is set to Acts Fast Tracking but Tracking.doITkFastTracking is set to {flags.Tracking.doITkFastTracking}")
    else:
        if flags.Tracking.doITkFastTracking:
            raise ValueError(f"Main pass is NOT set to Fast Tracking but Tracking.doITkFastTracking is set to {flags.Tracking.doITkFastTracking}")
 
    # Check the ambiguity resolution strategy
    if flags.Acts.doAmbiguityResolution:
        from ActsConfig.ActsConfigFlags import AmbiguitySolverMode
        # If ambiguity resolution is requested, it means we want to schedule the ambiguity resolution algorithm
        # this means that we must have AmbiguitySolverMode.OUTSIDE_TF
        if flags.Acts.AmbiguitySolverMode is not AmbiguitySolverMode.OUTSIDE_TF:
            raise ValueError(f"Conflicting reco configuration: Acts.doAmbiguityResolution has been requested and this will schedule the ACTS ambiguity solver algorithm, yet the ambiguity mode (set to {flags.Acts.AmbiguitySolverMode}) is not compatible with this.")
 
 
    # Primary pass
    trackingPasses += [flags.cloneAndReplace(
        "Tracking.ActiveConfig",
        f"Tracking.{flags.Tracking.ITkPrimaryPassConfig.value}Pass")]
 
    # Conversion pass
    if flags.Acts.doITkConversion:
        # Check that we can schedule the conversion
        if not flags.Detector.EnableCalo:
            raise ValueError("Problem in the job configuration: required reconstruction of photon conversion tracks but Calorimeter Detector is not enabled")
        trackingPasses += [flags.cloneAndReplace(
            "Tracking.ActiveConfig",
            "Tracking.ITkActsConversionPass")]
 
    # Large Radius pass
    if flags.Acts.doLargeRadius and primaryPassUsesActs(flags):
        trackingPasses += [flags.cloneAndReplace(
            "Tracking.ActiveConfig",
            "Tracking.ITkActsLargeRadiusPass")]
 
        
    # Low pT pass
    if flags.Acts.doLowPt:
        trackingPasses += [flags.cloneAndReplace(
            "Tracking.ActiveConfig",
            "Tracking.ITkActsLowPtPass")]
                
    print("List of scheduled passes:")
    for trackingPass in trackingPasses:
        print(f'- {trackingPass.Tracking.ActiveConfig.extension}')
    
    # Check if we found a primary pass (and only one)
    nPrimaryPasses = 0
    for current_flags in trackingPasses:
        if isPrimaryPass(current_flags):
            nPrimaryPasses += 1
    if nPrimaryPasses != 1:
        raise ValueError(f"Problem in the job configuration: exactly one primary pass is required for a proper configuration, but we found {nPrimaryPasses} instead!")
    
    return trackingPasses
 

getListOfGeneratedTrackParticles()

list[str] getListOfGeneratedTrackParticles

(

flags

)

Definition at line 126 of file ITkActsHelpers.py.

def getListOfGeneratedTrackParticles(flags) -> list[str]:
    generateTrackCollections = ["InDetTrackParticles"]
 
    # loop on tracking passes
    scheduledTrackingPasses: list = extractTrackingPasses(flags)
    for currentFlags in scheduledTrackingPasses:
        # Add the seed tracks
        if currentFlags.Tracking.ActiveConfig.storeTrackSeeds:
            # pixel seeds
            generatePixelSegments = currentFlags.Detector.EnableITkPixel
            generateStripSegments = currentFlags.Detector.EnableITkStrip
            
            # For conversion pass we do not process pixels
            if currentFlags.Tracking.ActiveConfig.extension == "ActsConversion" or currentFlags.Tracking.ActiveConfig.isLargeD0:
                generatePixelSegments = False
                # For main pass disable strips if fast tracking configuration
            elif isFastPrimaryPass(currentFlags):
                generateStripSegments = False
 
            if generatePixelSegments:
                generateTrackCollections += [f'SiSPSeedSegments{currentFlags.Tracking.ActiveConfig.extension}PixelTrackParticles']
            if generateStripSegments:
                generateTrackCollections += [f'SiSPSeedSegments{currentFlags.Tracking.ActiveConfig.extension}StripTrackParticles']
            if generatePixelSegments and generateStripSegments:
                generateTrackCollections += [f'SiSPSeedSegments{currentFlags.Tracking.ActiveConfig.extension}TrackParticles']
            
            # Add CKF tracks
            if currentFlags.Tracking.ActiveConfig.storeSiSPSeededTracks:
                generateTrackCollections += [f'SiSPSeededTracks{currentFlags.Tracking.ActiveConfig.extension}TrackParticles']
            
            # Add tracks after ambi
            # this is necessary only if ambiguity resolution is run and we
            # store track particles in a separate container w.r.t InDetTrackParticles
            if currentFlags.Acts.doAmbiguityResolution and currentFlags.Tracking.ActiveConfig.storeSeparateContainer:
                generateTrackCollections += [separateTrackParticleContainerName(currentFlags)]
 
    print('Here is the list of generated track particle collections:')
    for collection in generateTrackCollections:
        print(f'- {collection}')
        
    return generateTrackCollections

isFastPrimaryPass()

bool isFastPrimaryPass

(

flags

)

Definition at line 13 of file ITkActsHelpers.py.

def isFastPrimaryPass(flags) -> bool:
    if flags.hasCategory("Tracking.ActiveConfig") and flags.Tracking.ActiveConfig.extension in ["ActsValidateF100", "ActsValidateF150"] and flags.Tracking.doITkFastTracking:
        return True
    return flags.Tracking.doITkFastTracking and isPrimaryPass(flags)
 

isPrimaryPass()

bool isPrimaryPass

(

flags

)

Definition at line 3 of file ITkActsHelpers.py.

def isPrimaryPass(flags) -> bool:
    if not flags.hasCategory("Tracking.ActiveConfig"):
        return False
    # Support for non ACTS passes, that do not respect the convention
    # This comes from Athena legacy passes
    if flags.Tracking.ActiveConfig.extension in ["", "HeavyIon"]:
        return True
    # For ACTS the convention is respected: ITk{extension} + Pass
    return f"ITk{flags.Tracking.ActiveConfig.extension}" == flags.Tracking.ITkPrimaryPassConfig.value
 

isProductionPass()

bool isProductionPass

(

flags

)

Definition at line 21 of file ITkActsHelpers.py.

def isProductionPass(flags) -> bool:
    return not isValidationPass(flags)
 

isValidationPass()

bool isValidationPass

(

flags

)

Definition at line 18 of file ITkActsHelpers.py.

def isValidationPass(flags) -> bool:
    return "Validate" in flags.Tracking.ActiveConfig.extension
 

primaryPassExtension()

str primaryPassExtension

(

flags

)

Definition at line 42 of file ITkActsHelpers.py.

def primaryPassExtension(flags) -> str:
    # we rely on the fact that flags.Tracking.ITkPrimaryPassConfig.value is
    # equal to ITk{extension}
    return flags.Tracking.ITkPrimaryPassConfig.value.replace("ITk", "")
 

primaryPassUsesActs()

bool primaryPassUsesActs

(

flags

)

Definition at line 36 of file ITkActsHelpers.py.

def primaryPassUsesActs(flags) -> bool:
    from TrkConfig.TrkConfigFlags import ITkPrimaryPassConfig
    return flags.Tracking.ITkPrimaryPassConfig in [ITkPrimaryPassConfig.Acts, \
                                                   ITkPrimaryPassConfig.ActsLegacy, \
                                                   ITkPrimaryPassConfig.ActsHeavyIon]
 

primaryPassUsesDevice()

bool primaryPassUsesDevice

(

flags

)

Definition at line 24 of file ITkActsHelpers.py.

def primaryPassUsesDevice(flags) -> bool:
    from ActsConfig.ActsConfigFlags import DeviceTritonMode
    return (flags.Acts.Device.tritonMode is DeviceTritonMode.Client or
            flags.Acts.Device.doClusterization or
            flags.Acts.Device.doSpacePointFormation or
            flags.Acts.Device.doSeeding or
            flags.Acts.Device.doTrackReconstruction)
 

secondaryPassUsesDevice()

bool secondaryPassUsesDevice

(

flags

)

Definition at line 32 of file ITkActsHelpers.py.

def secondaryPassUsesDevice(flags) -> bool:
    return (flags.Tracking.ActiveConfig.isLargeD0 and
            flags.Acts.Device.doLargeRadiusPass)
 

separateTrackParticleContainerName()

str separateTrackParticleContainerName

(

flags

)

Definition at line 47 of file ITkActsHelpers.py.

def separateTrackParticleContainerName(flags) -> str:
    # Name of the persistified track particle container for tracking passes
    # that store their tracks in a separate container (storeSeparateContainer).
    # This follows the InDet{extension}TrackParticles convention, unless the
    # pass requests a different name via the storedTrackParticlesExtension flag
    # (e.g. the ActsLargeRadius pass writes to InDetLargeD0TrackParticles so that
    # downstream LRT clients can rely on the Run-3 container name)
    extension = flags.Tracking.ActiveConfig.storedTrackParticlesExtension or \
        flags.Tracking.ActiveConfig.extension
    return f"InDet{extension}TrackParticles"