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