TrigInDetConfig.py

Go to the documentation of this file.

#
#  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
#
 
from AthenaConfiguration.AccumulatorCache import AccumulatorCache
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaCommon.Logging import logging
 
def InDetExtraDataObjectsFromDataPrep(flags, dataObjects) :
  if flags.Detector.GeometryITk:
    if flags.Detector.EnableITkPixel:
      dataObjects.append( ('InDet::SiDetectorElementStatus' , 'StoreGateSvc+ITkPixelDetectorElementStatus' ))
    if flags.Detector.EnableITkStrip:
      dataObjects.append( ('InDet::SiDetectorElementStatus' , 'StoreGateSvc+ITkStripDetectorElementStatus' ))
 
 
def InDetIDCCacheCreatorCfg(flags):
  #Create IdentifiableCaches
  acc = ComponentAccumulator()
  InDet__CacheCreator=CompFactory.getComp("InDet::CacheCreator")
  InDetCacheCreatorTrig = InDet__CacheCreator(name = "InDetCacheCreatorTrig", 
                                              TRT_DriftCircleKey = flags.Trigger.InDetTracking.TRT_DriftCircleCacheKey,
                                              Pixel_ClusterKey   = flags.Trigger.InDetTracking.PixelClusterCacheKey,
                                              SCT_ClusterKey     = flags.Trigger.InDetTracking.SCTClusterCacheKey,
                                              SpacePointCachePix = flags.Trigger.InDetTracking.SpacePointCachePix,
                                              SpacePointCacheSCT = flags.Trigger.InDetTracking.SpacePointCacheSCT,
                                              SCTRDOCacheKey     = flags.Trigger.InDetTracking.SCTRDOCacheKey,
                                              SCTBSErrCacheKey   = flags.Trigger.InDetTracking.SCTBSErrCacheKey,
                                              SCTFlaggedCondCacheKey = flags.Trigger.InDetTracking.SCTFlaggedCondCacheKey,
                                              PixRDOCacheKey     = flags.Trigger.InDetTracking.PixRDOCacheKey,
                                              PixBSErrCacheKey   = flags.Trigger.InDetTracking.PixBSErrCacheKey,
                                              TRTRDOCacheKey     = flags.Trigger.InDetTracking.TRTRDOCacheKey)
  
  if not flags.Detector.GeometryTRT:
    InDetCacheCreatorTrig.disableTRT = True
 
  acc.addEventAlgo( InDetCacheCreatorTrig )
  return acc
 
def ActsIDCCacheCreatorCfg(flags):
  #Create IdentifiableCaches
  acc = ComponentAccumulator()
 
  creator = CompFactory.ActsTrk.Cache.CreatorAlg(name="ActsCacheCreatorTrig", 
                                                   PixelClustersCacheKey="ActsPixelClusterCache_Back",
                                                   StripClustersCacheKey="ActsStripClusterCache_Back",
                                                   PixelSpacePointCacheKey="ActsPixelSpacePointCache_Back",
                                                   StripSpacePointCacheKey="ActsStripSpacePointCache_Back",
                                                   StripOverlapSpacePointCacheKey="ActsStripOverlapSpacePointCache_Back")
  
  acc.addEventAlgo(creator)
 
  return acc
 
 
 

@AccumulatorCache
def trigInDetSPFormationCfg(inflags, roisKey: str, signatureName: str, in_view: bool | str = True) -> ComponentAccumulator:
  log = logging.getLogger('trigInDetSPFormationCfg')
  from TrigInDetConfig.utils import getFlagsForActiveConfig
  flags = getFlagsForActiveConfig(inflags, signatureName, log)
 
  if in_view:
    if isinstance(in_view, bool):
      in_view = 'VDVInDetFTF'
  else:
    in_view = None
 
  from TrigInDetConfig.InnerTrackingTrigSequence import InnerTrackingTrigSequence
  seq = InnerTrackingTrigSequence.create(flags, 
                                         flags.Tracking.ActiveConfig.input_name, 
                                         rois = roisKey,
                                         inView = in_view)
 
  return seq.sequence('spacePointFormation')
 
 
 

@AccumulatorCache
def trigInDetFastTrackingCfg( inflags, roisKey="EMRoIs", signatureName='', patternMode='FTF', in_view=True ):
 
  log = logging.getLogger("trigInDetFastTrackingCfg")
  from TrigInDetConfig.utils import getFlagsForActiveConfig
  flags = getFlagsForActiveConfig(inflags, signatureName, log)
 
  """ Generates fast tracking config, it is a primary config function """
 
  from TrigInDetConfig.InnerTrackingTrigSequence import InnerTrackingTrigSequence
 
  seq = InnerTrackingTrigSequence.create(flags, 
                                         flags.Tracking.ActiveConfig.input_name, 
                                         rois   = roisKey,
                                         inView = "VDVInDetFTF" if in_view else None)
  if patternMode=='FTF':
    acc = seq.sequence("FastTrackFinder")
  elif patternMode=="fastTracking":
    acc = seq.sequence("offlinePattern")
    
  return acc
 
 
 
 
 
@AccumulatorCache
def trigInDetLRTCfg(flags, LRTInputCollection, roisKey, in_view, extra_view_inputs=tuple()):
  from TrigInDetConfig.InnerTrackingTrigSequence import InnerTrackingTrigSequence
  viewname = "VDVInDetLRT" if in_view else None
  seq = InnerTrackingTrigSequence.create(flags,
                                         flags.Tracking.ActiveConfig.input_name,
                                         rois   = roisKey,
                                         inView = viewname)
  acc = ComponentAccumulator()
  if in_view:
    acc.addEventAlgo( CompFactory.AthViews.ViewDataVerifier(
      name = "LRTInputVDV_"+viewname + "_" + flags.Tracking.ActiveConfig.input_name,
      DataObjects = { ( 'TrigRoiDescriptorCollection' ,  f'StoreGateSvc+{roisKey}' ),
                      ( 'TrackCollection' ,               'StoreGateSvc+HLT_IDTrkTrack_FS_FTF' ),
                    } | set(extra_view_inputs) ) )
    
    #need to make sure the cache containers are available
    acc.merge(seq.viewDataVerifier(viewname))
    acc.merge(seq.dataPreparation())
    acc.merge(seq.spacePointFormation())
    
  acc.merge(seq.fastTrackFinder(inputTracksName = LRTInputCollection))
  
  return acc
 
 
 
 
 

 
@AccumulatorCache
def trigInDetPrecisionTrackingCfg( inflags, rois, signatureName, in_view=True ):
 
  """ Generates precision tracking config, it is a primary config function """
 
  acc = ComponentAccumulator()
  log = logging.getLogger("trigInDetPrecisionTrackingCfg")
  from TrigInDetConfig.utils import getFlagsForActiveConfig
  flags = getFlagsForActiveConfig(inflags, signatureName, log)
 
  if in_view:
 
    verifier = CompFactory.AthViews.ViewDataVerifier( name = 'VDVInDetPrecision'+flags.Tracking.ActiveConfig.input_name,
                                                      DataObjects= {( 'xAOD::EventInfo', 'StoreGateSvc+EventInfo'),
                                                                    ( 'SG::AuxElement' , 'StoreGateSvc+EventInfo.averageInteractionsPerCrossing'),
                                                                    ( 'TrigRoiDescriptorCollection' ,  f'StoreGateSvc+{rois}' ),
                                                                    ( 'TagInfo', 'DetectorStore+ProcessingTags' ), 
                                                                    ( ('ActsTrk::TrackContainer' if "Acts" in flags.Tracking.ActiveConfig.trkTracks_FTF else 'TrackCollection'), flags.Tracking.ActiveConfig.trkTracks_FTF )} )
 
    acc.addEventAlgo(verifier)
 
  from TrigInDetConfig.InnerTrackingTrigSequence import InnerTrackingTrigSequence
 
  seq = InnerTrackingTrigSequence.create(flags, 
                                         flags.Tracking.ActiveConfig.input_name, 
                                         rois = flags.Tracking.ActiveConfig.roi, 
                                         inView = verifier.getName() if in_view else '')
  
  acc.merge(seq.sequenceAfterPattern(rois = rois))
 
  return acc
 
 
 
 
 
def trigInDetVertexingCfg(flags, inputTracks, outputVtx):
  
  acc = ComponentAccumulator()
 
  acc.addEventAlgo( CompFactory.AthViews.ViewDataVerifier(
    name = "VtxVDV_" + flags.Tracking.ActiveConfig.input_name,
    DataObjects = {
      ('ActsTrk::GeometryContext' , 'StoreGateSvc+ActsAlignment' ) 
    } 
  ))
                
  from InDetConfig.InDetPriVxFinderConfig import InDetTrigPriVxFinderCfg
  acc.merge(InDetTrigPriVxFinderCfg(flags, inputTracks = inputTracks, outputVtx =outputVtx))
 
  return acc
 
 
 
 
if __name__ == "__main__":
    from AthenaConfiguration.AllConfigFlags import initConfigFlags
    from AthenaConfiguration.TestDefaults import defaultTestFiles, defaultGeometryTags
    ComponentAccumulator.debugMode = "trackCA trackPublicTool trackEventAlgo trackCondAlgo trackPrivateTool"
    flags = initConfigFlags()
    flags.Input.Files = defaultTestFiles.RAW_RUN2
    flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN2
    flags.lock()
    # this configuration is not runable, the test checks if there is no mistake in python scripts above
    # output can be used by experts to check actual configuration (e.g. here we configure to run on RAW and it should be reflected in settings)
    from AthenaConfiguration.MainServicesConfig import MainServicesCfg
    acc = MainServicesCfg( flags )
    roisKey = "ElectronRoIs"
    
    flags = flags.cloneAndReplace("Tracking.ActiveConfig", "Trigger.InDetTracking.electron")
    acc.merge( trigInDetFastTrackingCfg( flags, roisKey=roisKey, signatureName="electron" ) )
    acc.merge( trigInDetPrecisionTrackingCfg( flags, rois=roisKey, signatureName="electron", in_view=True) )
    acc.merge( trigInDetVertexingCfg( flags, inputTracks=flags.Tracking.ActiveConfig.tracks_FTF, outputVtx="testVtx") )
 
 
    acc.printConfig(withDetails=True, summariseProps=True)
    acc.store( open("test.pkl", "wb") )