def JetGroomAlgCfg(ConfigFlags, buildjetsname, groomjetsname):
groomcfg = ComponentAccumulator()
# Create a sequence that holds a set of algorithms
# -- mainly for understanding how chunks of the job
# relate to each other
sequencename = "JetGroomSeq"
groomcfg.addSequence(CompFactory.AthSequencer(sequencename))
# Create the JetGroomer, provide it with a JetTrimmer
jtrim = CompFactory.JetTrimming("trimSmallR2Frac5", RClus=0.2, PtFrac=0.05)
jtrim.UngroomedJets = buildjetsname
jtrim.ParentPseudoJets = "PseudoJetMerged_" + buildjetsname
# Create the JetRecAlg, configure it to use the builder
# using constructor syntax instead
# (equivalent to setting properties with "=")
jra = CompFactory.JetRecAlg(
"JRA_trim",
Provider=jtrim, # Single ToolHandle
Modifiers=[], # ToolHandleArray
OutputContainer=groomjetsname)
# Add the alg to the ComponentAccumulator in the named sequence
groomcfg.addEventAlgo(jra, sequencename)
return groomcfg
def TgcRDODecodeCfg(flags, forTrigger=False):
acc = ComponentAccumulator()
# We need the TGC cabling to be setup
from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
acc.merge(TGCCablingConfigCfg(flags))
# Make sure muon geometry is configured
from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
acc.merge(MuonGeoModelCfg(flags))
# Get the RDO -> PRD tool
Muon__TgcRdoToPrepDataToolMT = CompFactory.Muon.TgcRdoToPrepDataToolMT
TgcRdoToTgcPrepDataTool = Muon__TgcRdoToPrepDataToolMT(
name="TgcRdoToTgcPrepDataTool")
# Get the RDO -> PRD alorithm
TgcRdoToTgcPrepData = CompFactory.TgcRdoToTgcPrepData
TgcRdoToTgcPrepData = TgcRdoToTgcPrepData(
name="TgcRdoToTgcPrepData",
DecodingTool=TgcRdoToTgcPrepDataTool,
PrintPrepData=False)
# add RegSelTool
from RegionSelector.RegSelToolConfig import regSelTool_TGC_Cfg
TgcRdoToTgcPrepData.RegSel_TGC = acc.popToolsAndMerge(
regSelTool_TGC_Cfg(flags))
if forTrigger:
# Set the algorithm to RoI mode
TgcRdoToTgcPrepData.DoSeededDecoding = True
from L1Decoder.L1DecoderConfig import mapThresholdToL1RoICollection
TgcRdoToTgcPrepData.RoIs = mapThresholdToL1RoICollection("MU")
acc.addEventAlgo(TgcRdoToTgcPrepData)
return acc
def SCTTruthOverlayCfg(flags, name="SCTSDOOverlay", **kwargs):
"""Return a ComponentAccumulator for the SCT SDO overlay algorithm"""
acc = ComponentAccumulator()
# We do not need background SCT SDOs
kwargs.setdefault("BkgInputKey", "")
kwargs.setdefault("SignalInputKey",
flags.Overlay.SigPrefix + "SCT_SDO_Map")
kwargs.setdefault("OutputKey", "SCT_SDO_Map")
# Do SCT truth overlay
InDetSDOOverlay = CompFactory.InDetSDOOverlay
alg = InDetSDOOverlay(name, **kwargs)
acc.addEventAlgo(alg)
# Setup output
if flags.Output.doWriteRDO:
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(
OutputStreamCfg(flags,
"RDO",
ItemList=["InDetSimDataCollection#SCT_SDO_Map"]))
if flags.Output.doWriteRDO_SGNL:
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(
OutputStreamCfg(flags,
"RDO_SGNL",
ItemList=[
"InDetSimDataCollection#" +
flags.Overlay.SigPrefix + "SCT_SDO_Map"
]))
return acc
def BCM_ZeroSuppressionCfg(flags, **kwargs):
acc = ComponentAccumulator()
kwargs.setdefault("BcmContainerName", "BCM_RDOs")
algo = CompFactory.BCM_ZeroSuppression("InDetBCM_ZeroSuppression",
**kwargs)
acc.addEventAlgo(algo, primary=True)
return acc
def egammaForwardBuilderCfg(flags, name='egammaForwardElectron', **kwargs):
mlog = logging.getLogger(name)
mlog.info('Starting configuration')
acc = ComponentAccumulator()
if "forwardelectronIsEMselectors" not in kwargs:
LooseFwdElectronSelector = AsgForwardElectronIsEMSelectorCfg(flags, "LooseForwardElectronSelector", egammaPID.ForwardElectronIDLoose)
MediumFwdElectronSelector = AsgForwardElectronIsEMSelectorCfg(flags, "MediumForwardElectronSelector", egammaPID.ForwardElectronIDMedium)
TightFwdElectronSelector = AsgForwardElectronIsEMSelectorCfg(flags, "TightForwardElectronSelector", egammaPID.ForwardElectronIDTight)
kwargs.setdefault("forwardelectronIsEMselectors", [LooseFwdElectronSelector.popPrivateTools(),
MediumFwdElectronSelector.popPrivateTools(),
TightFwdElectronSelector.popPrivateTools()])
kwargs.setdefault("forwardelectronIsEMselectorResultNames", ["Loose", "Medium", "Tight"])
acc.merge(LooseFwdElectronSelector)
acc.merge(MediumFwdElectronSelector)
acc.merge(TightFwdElectronSelector)
if "ObjectQualityTool" not in kwargs:
egOQ = egammaOQFlagsBuilderCfg(flags)
kwargs["ObjectQualityTool"] = egOQ.popPrivateTools()
acc.merge(egOQ)
kwargs.setdefault("ElectronOutputName", flags.Egamma.Keys.Output.ForwardElectrons)
kwargs.setdefault("TopoClusterName", flags.Egamma.Keys.Input.ForwardTopoClusters)
kwargs.setdefault("ClusterContainerName", flags.Egamma.Keys.Output.ForwardClusters)
kwargs.setdefault("FourMomBuilderTool", EMFourMomBuilder())
fwdAlg = egammaForwardBuilder(name, **kwargs)
acc.addEventAlgo(fwdAlg)
return acc
def testCfg(configFlags):
result = ComponentAccumulator()
from IOVDbSvc.IOVDbSvcConfig import addFolders
result.merge(
addFolders(configFlags,
'/LAR/CellCorrOfl/deadOTX',
detDb='LAR_OFL',
className='CondAttrListCollection'))
from CaloRec.ToolConstantsCondAlgConfig import ToolConstantsCondAlgCfg
result.merge(
ToolConstantsCondAlgCfg(configFlags,
'deadOTXCorrCtes',
COOLFolder='/LAR/CellCorrOfl/deadOTX'))
from EventSelectorAthenaPool.CondProxyProviderConfig import CondProxyProviderCfg
from CaloClusterCorrection.poolfiles import poolfiles
result.merge(
CondProxyProviderCfg(configFlags,
poolFiles=[poolfiles['caloswcorr_pool_v22']]))
result.merge(
ToolConstantsCondAlgCfg(
configFlags,
'CaloSwClusterCorrections.rfac-v5',
DetStoreKey='CaloSwClusterCorrections.rfac-v5'))
CaloClusterCorrDumper = CompFactory.CaloClusterCorrDumper # CaloRec
alg = CaloClusterCorrDumper(
'dumper1',
Constants=['deadOTXCorrCtes', 'CaloSwClusterCorrections.rfac-v5'])
result.addEventAlgo(alg)
return result
def EventInfoOverlayAlgCfg(flags, name="EventInfoOverlay", **kwargs):
"""Return a ComponentAccumulator for EventInfoOverlay algorithm"""
acc = ComponentAccumulator()
# Add beam spot conditions
from BeamSpotConditions.BeamSpotConditionsConfig import BeamSpotCondAlgCfg
acc.merge(BeamSpotCondAlgCfg(flags))
kwargs.setdefault("BkgInputKey", flags.Overlay.BkgPrefix + "EventInfo")
kwargs.setdefault("SignalInputKey", flags.Overlay.SigPrefix + "EventInfo")
kwargs.setdefault("OutputKey", "EventInfo")
kwargs.setdefault("DataOverlay", flags.Overlay.DataOverlay)
# Do the xAOD::EventInfo overlay
xAODMaker__EventInfoOverlay = CompFactory.xAODMaker.EventInfoOverlay
alg = xAODMaker__EventInfoOverlay(name, **kwargs)
acc.addEventAlgo(alg)
# Re-map signal address
from SGComps.AddressRemappingConfig import AddressRemappingCfg
acc.merge(AddressRemappingCfg([
"xAOD::EventInfo#EventInfo->" + flags.Overlay.SigPrefix + "EventInfo",
"xAOD::EventAuxInfo#EventInfoAux.->" + flags.Overlay.SigPrefix + "EventInfoAux.",
]))
return acc
def CopyMcEventCollectionAlgCfg(flags, name="CopyMcEventCollection", **kwargs):
"""Return a ComponentAccumulator for the CopyMcEventCollection algorithm"""
acc = ComponentAccumulator()
kwargs.setdefault("RemoveBkgHardScatterTruth", True)
if flags.Overlay.DataOverlay:
# Disable background for data overlay
kwargs.setdefault("BkgInputKey", "")
else:
kwargs.setdefault("BkgInputKey",
flags.Overlay.BkgPrefix + "TruthEvent")
kwargs.setdefault("SignalInputKey", flags.Overlay.SigPrefix + "TruthEvent")
kwargs.setdefault("OutputKey", "TruthEvent")
# Merge and copy McEventCollection
CopyMcEventCollection = CompFactory.CopyMcEventCollection
alg = CopyMcEventCollection(name, **kwargs)
acc.addEventAlgo(alg)
# Re-map signal address
from SGComps.AddressRemappingConfig import AddressRemappingCfg
acc.merge(
AddressRemappingCfg([
"McEventCollection#TruthEvent->" + flags.Overlay.SigPrefix +
"TruthEvent"
]))
return acc
def CopyCaloCalibrationHitContainerAlgCfg(
flags,
collectionName,
name="CopyCaloCalibrationHitContainer",
**kwargs):
"""Return a ComponentAccumulator for the CaloCalibrationHitContainer copying"""
acc = ComponentAccumulator()
kwargs.setdefault("collectionName", collectionName)
kwargs.setdefault("SignalInputKey",
flags.Overlay.SigPrefix + collectionName)
kwargs.setdefault("OutputKey", collectionName)
# Copy CaloCalibrationHitContainer
CopyCaloCalibrationHitContainer = CompFactory.CopyCaloCalibrationHitContainer
alg = CopyCaloCalibrationHitContainer(name + collectionName, **kwargs)
acc.addEventAlgo(alg)
# Re-map signal address
from SGComps.AddressRemappingConfig import AddressRemappingCfg
acc.merge(
AddressRemappingCfg([
"CaloCalibrationHitContainer#" + collectionName + "->" +
flags.Overlay.SigPrefix + collectionName
]))
return acc
def CopyTimingsAlgCfg(flags, name="CopyTimings", **kwargs):
"""Return a ComponentAccumulator for the CopyTimings algorithm"""
acc = ComponentAccumulator()
# Disable background copying
kwargs.setdefault("BkgInputKey", "")
kwargs.setdefault("SignalInputKey",
flags.Overlay.SigPrefix + "EVNTtoHITS_timings")
kwargs.setdefault("OutputKey", "EVNTtoHITS_timings")
# Copy RecoTimingObj
CopyTimings = CompFactory.CopyTimings
alg = CopyTimings(name, **kwargs)
acc.addEventAlgo(alg)
# Re-map signal address
from SGComps.AddressRemappingConfig import AddressRemappingCfg
acc.merge(
AddressRemappingCfg([
"RecoTimingObj#EVNTtoHITS_timings->" + flags.Overlay.SigPrefix +
"EVNTtoHITS_timings"
]))
return acc
def CopyTrackRecordCollectionAlgCfg(flags,
collectionName,
name="CopyTrackRecordCollection",
**kwargs):
"""Return a ComponentAccumulator for the TrackRecordCollection copying"""
acc = ComponentAccumulator()
kwargs.setdefault("collectionName", collectionName)
kwargs.setdefault("SignalInputKey",
flags.Overlay.SigPrefix + collectionName)
kwargs.setdefault("OutputKey", collectionName)
# Copy TrackRecordCollection
CopyTrackRecordCollection = CompFactory.CopyTrackRecordCollection
alg = CopyTrackRecordCollection(name + collectionName, **kwargs)
acc.addEventAlgo(alg)
# Re-map signal address
from SGComps.AddressRemappingConfig import AddressRemappingCfg
acc.merge(
AddressRemappingCfg([
"TrackRecordCollection#" + collectionName + "->" +
flags.Overlay.SigPrefix + collectionName
]))
return acc
def RoIBResultToxAODCfg(flags, seqName=''):
if flags.Trigger.enableL1Phase1 and not flags.Trigger.enableL1CaloLegacy:
# No Run-2 L1 RoIs -> nothing to covert to xAOD -> don't add RoIBResultToxAOD
return ComponentAccumulator()
acc = ComponentAccumulator(sequenceName=seqName)
alg = CompFactory.RoIBResultToxAOD('RoIBResultToxAOD')
alg.DoMuon = not flags.Trigger.enableL1Phase1
alg.DoCalo = flags.Trigger.enableL1CaloLegacy
acc.addEventAlgo(alg, sequenceName=seqName)
if flags.Input.Format == 'BS':
from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
typeNames = [
'xAOD::JetElementContainer/JetElements',
'xAOD::JetElementAuxContainer/JetElementsAux.',
'xAOD::CPMTowerContainer/CPMTowers',
'xAOD::CPMTowerAuxContainer/CPMTowersAux.'
]
acc.merge(ByteStreamReadCfg(flags, typeNames))
# Create output list to return for use by the caller
outputList = []
if alg.DoMuon:
outputList += [("xAOD::MuonRoIContainer", alg.xAODKeyMuon)]
if alg.DoCalo:
outputList += [("xAOD::EmTauRoIContainer", alg.xAODKeyEmTau),
("xAOD::EnergySumRoI", alg.xAODKeyEsum),
("xAOD::JetEtRoI", alg.xAODKeyJetEt),
("xAOD::JetRoIContainer", alg.xAODKeyJet)]
return acc, outputList
def egammaTruthAssociationCfg(flags, name='egammaTruthAssociation', **kwargs):
mlog = logging.getLogger(name)
mlog.info('Start configuration')
acc = ComponentAccumulator()
if "MCTruthClassifier" not in kwargs:
mctruth = MCTruthClassifierCaloTruthMatchCfg(flags)
kwargs["MCTruthClassifier"] = mctruth.popPrivateTools()
acc.merge(mctruth)
kwargs.setdefault("ClusterContainerName",
flags.Egamma.Keys.Output.CaloClusters)
kwargs.setdefault("ElectronContainerName",
flags.Egamma.Keys.Output.Electrons)
kwargs.setdefault("PhotonContainerName", flags.Egamma.Keys.Output.Photons)
kwargs.setdefault("FwdElectronContainerName",
flags.Egamma.Keys.Output.ForwardElectrons)
kwargs.setdefault("TruthEventContainerName",
flags.Egamma.Keys.Input.TruthEvents)
kwargs.setdefault("TruthParticleContainerName",
flags.Egamma.Keys.Input.TruthParticles)
kwargs.setdefault("EgammaTruthContainerName",
flags.Egamma.Keys.Output.TruthParticles)
kwargs.setdefault("MatchForwardElectrons", flags.Egamma.doForwardSeeded)
kwargs.setdefault("SimBarcodeOffset", flags.Sim.SimBarcodeOffset)
egtruthAlg = egammaTruthAssociationAlg(name, **kwargs)
acc.addEventAlgo(egtruthAlg)
return acc
def JetCopyAlgCfg(ConfigFlags, buildjetsname, copyjetsname):
copycfg = ComponentAccumulator()
# Create a sequence that holds a set of algorithms
# -- mainly for understanding how chunks of the job
# relate to each other
sequencename = "JetCopySeq"
copycfg.addSequence(CompFactory.AthSequencer(sequencename))
# Create the JetCopier, set some standard options
jcopy = CompFactory.JetCopier("copier")
jcopy.InputJets = buildjetsname
# Add a simple jet modifier to the JetRecAlg
jclsmoms = CompFactory.JetClusterMomentsTool("clsmoms",
JetContainer=copyjetsname)
# Create the JetRecAlg, configure it to use the copier
# using constructor syntax instead
# (equivalent to setting properties with "=")
jra = CompFactory.JetRecAlg(
"JRA_copy",
Provider=jcopy, # Single ToolHandle
Modifiers=[jclsmoms], # ToolHandleArray
OutputContainer=copyjetsname)
# Add the alg to the ComponentAccumulator in the named sequence
copycfg.addEventAlgo(jra, sequencename)
return copycfg
def BTagHighLevelAugmenterAlgCfg(ConfigFlags, JetCollection, BTagCollection, Associator, doFlipTagger=False, sequenceName=None, **options):
"""Adds a SecVtxTool instance and registers it.
input: name: The algorithm's name.
BTaggingCollectionName The name of the btagging collections.
options: Python dictionary of options to be passed to the algorithm.
output: The tool."""
options = {}
options['JetCollectionName'] = JetCollection.replace('Track', 'PV0Track') + 'Jets'
options['BTaggingCollectionName'] = BTagCollection
options['JetLinkName'] = options['BTaggingCollectionName'] + '.jetLink'
options['BTagTrackToJetAssociatorName'] = Associator
options['name'] = (BTagCollection + '_Augment').lower()
if doFlipTagger: options['FlipTagConfig'] = 'FLIP_SIGN'
# -- create the augmentation algorithm
if sequenceName:
acc = ComponentAccumulator(sequenceName)
acc.addEventAlgo(Analysis__BTagHighLevelAugmenterAlg(**options), sequenceName)
else:
acc = ComponentAccumulator()
acc.addEventAlgo(Analysis__BTagHighLevelAugmenterAlg(**options))
return acc
def JetGroomCfg(groomdef, configFlags, jetnameprefix="",jetnamesuffix=""):
jetsfullname = jetnameprefix+groomdef.basename+jetnamesuffix+"Jets"
jetlog.info("Setting up to find {0}".format(jetsfullname))
sequencename = jetsfullname
components = ComponentAccumulator()
from AthenaCommon.AlgSequence import AthSequencer
components.addSequence( AthSequencer(sequencename) )
# Check if the ungroomed jets exist in the input file.
# If not, we need to configure their reconstruction.
filecontents = configFlags.Input.Collections
if groomdef.ungroomedname not in filecontents:
from . import JetRecCfg
components.merge(JetRecCfg(groomdef.ungroomeddef, configFlags,
jetnameoverride=groomdef.ungroomedname))
else:
# FIXME: Need to schedule rebuilding of pseudojets
pass
# FIXME: Add calls to JetModConfig.getFinalModifierListAndPrereqs
components.addEventAlgo(getJetGroomAlg(jetsfullname,groomdef,groomdef.modifiers))
return components
def EMGSFCaloExtensionBuilderCfg(flags,
name='EMGSFCaloExtensionBuilder',
**kwargs):
mlog = logging.getLogger(name)
mlog.info('Starting configuration')
acc = ComponentAccumulator()
if "PerigeeCaloExtensionTool" not in kwargs:
perigeeCaloExtrapAcc = ParticleCaloExtensionToolCfg(
flags,
name="PerigeeCaloExtensionTool",
ParticleType="electron",
StartFromPerigee=True)
kwargs[
"PerigeeCaloExtensionTool"] = perigeeCaloExtrapAcc.popPrivateTools(
)
acc.merge(perigeeCaloExtrapAcc)
if "LastCaloExtensionTool" not in kwargs:
lastCaloExtrapAcc = ParticleCaloExtensionToolCfg(
flags, name="LastCaloExtensionTool", ParticleType="electron")
kwargs["LastCaloExtensionTool"] = lastCaloExtrapAcc.popPrivateTools()
acc.merge(lastCaloExtrapAcc)
kwargs.setdefault("GFFTrkPartContainerName",
flags.Egamma.Keys.Output.GSFTrackParticles)
emgscaloextfAlg = EMGSFCaloExtensionBuilder(name, **kwargs)
acc.addEventAlgo(emgscaloextfAlg)
return acc
def RpcOverlayAlgCfg(flags, name="RpcOverlay", **kwargs):
"""Return a ComponentAccumulator for RPCOverlay algorithm"""
acc = ComponentAccumulator()
kwargs.setdefault("BkgInputKey", flags.Overlay.BkgPrefix + "RPC_DIGITS")
kwargs.setdefault("SignalInputKey", flags.Overlay.SigPrefix + "RPC_DIGITS")
kwargs.setdefault("OutputKey", "RPC_DIGITS")
# Do RPC overlay
RpcOverlay = CompFactory.RpcOverlay
alg = RpcOverlay(name, **kwargs)
acc.addEventAlgo(alg)
# Setup output
if flags.Output.doWriteRDO:
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(
OutputStreamCfg(flags, "RDO", ItemList=["RpcPadContainer#RPCPAD"]))
if flags.Output.doWriteRDO_SGNL:
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(
OutputStreamCfg(flags,
"RDO_SGNL",
ItemList=[
"RpcPadContainer#" + flags.Overlay.SigPrefix +
"RPCPAD"
]))
return acc
def TileRawChannelToL2Cfg(flags, **kwargs):
"""Return component accumulator with configured Tile raw channels to L2 algorithm
Arguments:
flags -- Athena configuration flags (ConfigFlags)
"""
kwargs.setdefault('name', 'TileRawChannelToL2')
if flags.Digitization.PileUpPremixing:
kwargs.setdefault('TileL2Container',
flags.Overlay.BkgPrefix + 'TileL2Cnt')
else:
kwargs.setdefault('TileL2Container', 'TileL2Cnt')
acc = ComponentAccumulator()
if 'TileL2Builder' not in kwargs:
l2Builder = acc.popToolsAndMerge(TileL2BuilderCfg(flags))
kwargs['TileL2Builder'] = l2Builder
TileRawChannelToL2 = CompFactory.TileRawChannelToL2
acc.addEventAlgo(TileRawChannelToL2(**kwargs), primary=True)
return acc
def egammaRecBuilderCfg(flags, name='egammaRecBuilder', **kwargs):
mlog = logging.getLogger(name)
mlog.debug('Start configuration')
acc = ComponentAccumulator()
if "TrackMatchBuilderTool" not in kwargs:
emtrkmatch = EMTrackMatchBuilderCfg(flags)
kwargs["TrackMatchBuilderTool"] = emtrkmatch.popPrivateTools()
acc.merge(emtrkmatch)
if "ConversionBuilderTool" not in kwargs:
emcnv = EMConversionBuilderCfg(flags)
kwargs["ConversionBuilderTool"] = emcnv.popPrivateTools()
acc.merge(emcnv)
kwargs.setdefault("egammaRecContainer",
flags.Egamma.Keys.Internal.EgammaRecs)
kwargs.setdefault("InputTopoClusterContainerName",
flags.Egamma.Keys.Internal.EgammaTopoClusters)
egrecAlg = egammaRecBuilder(name, **kwargs)
acc.addEventAlgo(egrecAlg)
return acc
def SCTClusterizationCfg(flags, **kwargs):
acc = ComponentAccumulator()
# Need to get SCT_ConditionsSummaryTool for e.g. SCT_ClusteringTool
from InDetConfig.InDetRecToolConfig import InDetSCT_ConditionsSummaryToolCfg
InDetSCT_ConditionsSummaryToolWithoutFlagged = acc.popToolsAndMerge(
InDetSCT_ConditionsSummaryToolCfg(flags, withFlaggedCondTool=False))
#### Clustering tool ######
accbuf = ClusterMakerToolCfg(flags)
InDetClusterMakerTool = accbuf.getPrimary()
acc.merge(accbuf)
InDetSCT_ClusteringTool = CompFactory.InDet.SCT_ClusteringTool(
name="InDetSCT_ClusteringTool",
globalPosAlg=InDetClusterMakerTool,
conditionsTool=InDetSCT_ConditionsSummaryToolWithoutFlagged)
if flags.InDet.selectSCTIntimeHits:
if flags.InDet.InDet25nsec:
InDetSCT_ClusteringTool.timeBins = "01X"
else:
InDetSCT_ClusteringTool.timeBins = "X1X"
acc.addEventAlgo(
CompFactory.InDet.SCT_Clusterization(
name="InDetSCT_Clusterization",
clusteringTool=InDetSCT_ClusteringTool,
DataObjectName='SCT_RDOs', ##InDetKeys.SCT_RDOs(),
ClustersName='SCT_Clusters', ##InDetKeys.SCT_Clusters(),
conditionsTool=InDetSCT_ConditionsSummaryToolWithoutFlagged))
return acc
def TileMuonFitterCfg(flags, **kwargs):
acc = ComponentAccumulator()
kwargs.setdefault('DoHoughTransform', True)
kwargs.setdefault('EThreshold', 250.0)
kwargs.setdefault('BeamType', flags.Beam.Type)
kwargs.setdefault('CaloCellContainer', 'AllCalo')
if kwargs['DoHoughTransform']:
kwargs.setdefault('name', 'TileMuonFitter')
kwargs.setdefault('ComTimeKey', 'ComTimeTileMuon')
kwargs.setdefault('TileCosmicMuonKey', 'TileCosmicMuonHT')
else:
kwargs.setdefault('name', 'TileMuonFitterMF')
kwargs.setdefault('ComTimeKey', 'ComTimeTileMuonMF')
kwargs.setdefault('TileCosmicMuonKey', 'TileCosmicMuonMF')
from TileGeoModel.TileGMConfig import TileGMCfg
acc.merge(TileGMCfg(flags))
from LArGeoAlgsNV.LArGMConfig import LArGMCfg
acc.merge(LArGMCfg(flags))
TileMuonFitter = CompFactory.TileMuonFitter
acc.addEventAlgo(TileMuonFitter(**kwargs), primary=True)
return acc
def egammaSelectedTrackCopyCfg(flags,
name='egammaSelectedTrackCopy',
**kwargs):
mlog = logging.getLogger(name)
mlog.info('Starting configuration')
acc = ComponentAccumulator()
if "egammaCaloClusterSelector" not in kwargs:
egammaCaloClusterGSFSelector = egammaCaloClusterSelector(
name='caloClusterGSFSelector',
EMEtCut=2250.,
EMEtSplittingFraction=0.7,
EMFCut=0.5)
kwargs["egammaCaloClusterSelector"] = egammaCaloClusterGSFSelector
if "ExtrapolationTool" not in kwargs:
extraptool = EMExtrapolationToolsCfg(flags)
kwargs["ExtrapolationTool"] = extraptool.popPrivateTools()
acc.merge(extraptool)
kwargs.setdefault("ClusterContainerName",
flags.Egamma.Keys.Internal.EgammaTopoClusters)
kwargs.setdefault("TrackParticleContainerName",
flags.Egamma.Keys.Input.TrackParticles)
egseltrkcpAlg = egammaSelectedTrackCopy(name, **kwargs)
acc.addEventAlgo(egseltrkcpAlg)
return acc
def MdtOverlayAlgCfg(flags, name="MdtOverlay", **kwargs):
"""Return a ComponentAccumulator for MDTOverlay algorithm"""
acc = ComponentAccumulator()
kwargs.setdefault("BkgInputKey", flags.Overlay.BkgPrefix + "MDT_DIGITS")
kwargs.setdefault("SignalInputKey", flags.Overlay.SigPrefix + "MDT_DIGITS")
kwargs.setdefault("OutputKey", "MDT_DIGITS")
kwargs.setdefault("IntegrationWindow", 20) # in ns
# Do MDT overlay
MdtOverlay = CompFactory.MdtOverlay
alg = MdtOverlay(name, **kwargs)
acc.addEventAlgo(alg)
# Setup output
if flags.Output.doWriteRDO:
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[
"MdtCsmContainer#MDTCSM"
]))
if flags.Output.doWriteRDO_SGNL:
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(OutputStreamCfg(flags, "RDO_SGNL", ItemList=[
"MdtCsmContainer#" + flags.Overlay.SigPrefix + "MDTCSM"
]))
return acc
def MuonPrdCacheCfg():
# Use MuonGeometryFlags to identify which configuration is being used
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
acc = ComponentAccumulator()
MuonPRDCacheCreator = CompFactory.MuonPRDCacheCreator
cacheCreator = MuonPRDCacheCreator(
CscStripCacheKey=(MuonPrdCacheNames.CscStripCache
if MuonGeometryFlags.hasCSC() else ""),
MdtCacheKey=MuonPrdCacheNames.MdtCache,
CscCacheKey=(MuonPrdCacheNames.CscCache
if MuonGeometryFlags.hasCSC() else ""),
RpcCacheKey=MuonPrdCacheNames.RpcCache,
TgcCacheKey=MuonPrdCacheNames.TgcCache,
sTgcCacheKey=(MuonPrdCacheNames.sTgcCache
if MuonGeometryFlags.hasSTGC() else ""),
MmCacheKey=(MuonPrdCacheNames.MmCache
if MuonGeometryFlags.hasMM() else ""),
TgcCoinCacheKey=MuonPrdCacheNames.TgcCoinCache,
RpcCoinCacheKey=MuonPrdCacheNames.RpcCoinCache,
)
acc.addEventAlgo(cacheCreator, primary=True)
return acc
def MdtTruthOverlayCfg(flags, name="MdtTruthOverlay", **kwargs):
"""Return a ComponentAccumulator for the MDT SDO overlay algorithm"""
acc = ComponentAccumulator()
# We do not need background MDT SDOs
if flags.Overlay.DataOverlay:
kwargs.setdefault("BkgInputKey", "")
else:
kwargs.setdefault("BkgInputKey",
flags.Overlay.BkgPrefix + "MDT_SDO")
kwargs.setdefault("SignalInputKey",
flags.Overlay.SigPrefix + "MDT_SDO")
kwargs.setdefault("OutputKey", "MDT_SDO")
# Do MDT truth overlay
MuonSimDataOverlay = CompFactory.MuonSimDataOverlay
alg = MuonSimDataOverlay(name, **kwargs)
acc.addEventAlgo(alg)
# Setup output
if flags.Output.doWriteRDO:
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(OutputStreamCfg(flags, "RDO", ItemList=[
"MuonSimDataCollection#MDT_SDO"
]))
if flags.Output.doWriteRDO_SGNL:
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(OutputStreamCfg(flags, "RDO_SGNL", ItemList=[
"MuonSimDataCollection#" + flags.Overlay.SigPrefix + "MDT_SDO"
]))
return acc
def LArNoisyROSummaryCfg(configFlags):
result = ComponentAccumulator()
result.merge(LArKnownBadFebCfg(configFlags))
result.merge(LArKnownMNBFebCfg(configFlags))
# now configure the algorithm
try:
LArNoisyROAlg, LArNoisyROTool = CompFactory.getComps(
"LArNoisyROAlg", "LArNoisyROTool")
except Exception:
import traceback
print(traceback.format_exc())
return result
theLArNoisyROTool = LArNoisyROTool(
CellQualityCut=larNoisyROFlags.CellQualityCut(),
BadChanPerFEB=larNoisyROFlags.BadChanPerFEB(),
BadFEBCut=larNoisyROFlags.BadFEBCut(),
MNBLooseCut=larNoisyROFlags.MNBLooseCut(),
MNBTightCut=larNoisyROFlags.MNBTightCut(),
MNBTight_PsVetoCut=larNoisyROFlags.MNBTight_PsVetoCut())
result.setPrivateTools(theLArNoisyROTool)
theLArNoisyROAlg = LArNoisyROAlg()
theLArNoisyROAlg.Tool = result.popPrivateTools()
result.addEventAlgo(theLArNoisyROAlg)
return result
def CollectionMergerCfg(ConfigFlags, bare_collection_name,
mergeable_collection_suffix, merger_input_property,
region):
"""Generates and returns a collection name that is also registered to
the ISF CollectionMerger algorithm.
:param bare_collection_name: name of the collection if no merging
is taking place.
:param mergeable_collection_suffix: suffix to the collection in
case merging is taking place.
:param merger_input_property: name of the Input* property in the
CollectionMerger algorithm to add the mergeable collection to."""
result = ComponentAccumulator()
if ConfigFlags.Sim.ISFRun and ConfigFlags.Sim.ISF.HITSMergingRequired.get(
region, True):
mergeable_collection = '{bare}{suffix}'.format(
bare=bare_collection_name, suffix=mergeable_collection_suffix)
from ISF_Algorithms.CollectionMergerConfig import ISFCollectionMergerCfg
algo = ISFCollectionMergerCfg(ConfigFlags)
result.addEventAlgo(algo)
input_attribute_name = 'Input{merger_input_property}'.format(
merger_input_property=merger_input_property)
merger_input_collections = getattr(
algo, input_attribute_name) #empty list always?
merger_input_collections.append(mergeable_collection)
else:
mergeable_collection = bare_collection_name
print(result)
print("#################################")
return result, mergeable_collection
def SCTOverlayAlgCfg(flags, name="SCTOverlay", **kwargs):
"""Return a ComponentAccumulator for SCTOverlay algorithm"""
acc = ComponentAccumulator()
kwargs.setdefault("BkgInputKey", flags.Overlay.BkgPrefix + "SCT_RDOs")
kwargs.setdefault("SignalInputKey", flags.Overlay.SigPrefix + "SCT_RDOs")
kwargs.setdefault("OutputKey", "SCT_RDOs")
# Do SCT overlay
SCTOverlay = CompFactory.SCTOverlay
alg = SCTOverlay(name, **kwargs)
acc.addEventAlgo(alg)
# Setup output
if flags.Output.doWriteRDO:
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(
OutputStreamCfg(flags,
"RDO",
ItemList=["SCT_RDO_Container#SCT_RDOs"]))
if flags.Output.doWriteRDO_SGNL:
from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
acc.merge(
OutputStreamCfg(flags,
"RDO_SGNL",
ItemList=[
"SCT_RDO_Container#" +
flags.Overlay.SigPrefix + "SCT_RDOs"
]))
return acc
def TileRawChannelCorrectionAlgCfg(flags, **kwargs):
"""Return component accumulator with configured Tile raw channel correction algorithm
Arguments:
flags -- Athena configuration flags (ConfigFlags)
Keyword arguments:
InputRawChannelContainer -- input Tile raw channel container. Defaults to TileRawChannelCnt.
OutputRawChannelContainer -- output Tile raw channel container. Defaults to TileRawChannelCntCorrected.
"""
acc = ComponentAccumulator()
kwargs.setdefault('InputRawChannelContainer', 'TileRawChannelCnt')
kwargs.setdefault('OutputRawChannelContainer',
'TileRawChannelCntCorrected')
if 'NoiseFilterTools' not in kwargs:
kwargs['NoiseFilterTools'] = acc.popToolsAndMerge(
TileRawChannelCorrectionToolsCfg(flags))
TileRawChannelCorrectionAlg = CompFactory.TileRawChannelCorrectionAlg
acc.addEventAlgo(TileRawChannelCorrectionAlg(**kwargs), primary=True)
return acc
