def SCT_LorentzAngleCfg(flags, name="SCT_SiLorentzAngleCondAlg", forceUseDB=False, forceUseGeoModel=False, **kwargs): """Return configured ComponentAccumulator and tool for SCT_LorentzAngle SiLorentzAngleTool may be provided in kwargs """ if forceUseDB and forceUseGeoModel: msg = Logging.logging.getLogger("SCT_LorentzAngleCfg") msg.error( "Setting is wrong: both forceUseDB and forceUseGeoModel cannot be True at the same time" ) # construct with field services acc = MagneticFieldSvcCfg(flags) tool = kwargs.get("SiLorentzAngleTool", SCT_LorentzAngleToolCfg(flags)) if not forceUseGeoModel: DCSkwargs = {} # For HLT if flags.Common.isOnline and not flags.Input.isMC: dcs_folder = "/SCT/HLT/DCS" DCSkwargs["dbInstance"] = "SCT" DCSkwargs["hvFolder"] = dcs_folder + "/HV" DCSkwargs["tempFolder"] = dcs_folder + "/MODTEMP" DCSkwargs["stateFolder"] = dcs_folder + "/CHANSTAT" DCSAcc = SCT_DCSConditionsCfg(flags, **DCSkwargs) SCAcc = SCT_SiliconConditionsCfg( flags, DCSConditionsTool=DCSAcc.popPrivateTools()) acc.merge(DCSAcc) acc.merge(SCAcc) # set up SCTSiLorentzAngleCondAlg kwargs.setdefault("UseMagFieldCache", tool.UseMagFieldCache) kwargs.setdefault("UseMagFieldDcs", not flags.Common.isOnline) kwargs.setdefault("UseGeoModel", forceUseGeoModel) kwargs.setdefault("useSctDefaults", False) acc.addCondAlgo(SCTSiLorentzAngleCondAlg(name, **kwargs)) acc.setPrivateTools(tool) return acc
def ActsExtrapolationToolCfg(configFlags, name="ActsExtrapolationTool"): result = ComponentAccumulator() acc = MagneticFieldSvcCfg(configFlags) result.merge(acc) acc, actsTrackingGeometryTool = ActsTrackingGeometryToolCfg(configFlags) result.merge(acc) Acts_ActsExtrapolationTool = CompFactory.ActsExtrapolationTool actsExtrapolationTool = Acts_ActsExtrapolationTool(name) result.addPublicTool(actsExtrapolationTool, primary=True) return result
def testCfg (configFlags): result = ComponentAccumulator() from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg result.merge (MuonGeoModelCfg(configFlags)) from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg result.merge (MagneticFieldSvcCfg(configFlags, UseDCS = False)) Muon__MdtRdoToPrepDataTool = CompFactory.Muon.MdtRdoToPrepDataTool result.addPublicTool (Muon__MdtRdoToPrepDataTool ('Muon__MdtRdoToPrepDataTool', OutputLevel = 1)) result.addEventAlgo (TestAlg ('TestAlg')) return result
def DQTDetSynchMonAlgConfig(flags): from AthenaMonitoring import AthMonitorCfgHelper from AthenaConfiguration.ComponentFactory import CompFactory helper = AthMonitorCfgHelper(flags, 'DQTDetSynchMonAlgCfg') _DQTDetSynchMonAlgConfigCore(helper, CompFactory.DQTDetSynchMonAlg, flags.Common.isOnline, False) acc = helper.result() # RPC currently crashes, switch off acc.getEventAlgo('DQTDetSynchMonAlg').doRPC = False from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg acc.merge(MagneticFieldSvcCfg(flags)) from TileConditions.TileCablingSvcConfig import TileCablingSvcCfg acc.merge(TileCablingSvcCfg(flags)) return acc
def testCfg(configFlags): result = ComponentAccumulator() from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg result.merge(MuonGeoModelCfg(configFlags)) from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg result.merge(MagneticFieldSvcCfg(configFlags, UseDCS=False)) MuonStationIntersectSvc = CompFactory.MuonStationIntersectSvc result.addService( MuonStationIntersectSvc('MuonStationIntersectSvc', OutputLevel=1)) result.addEventAlgo(TestAlg('TestAlg')) return result
def testCfg(configFlags): result = ComponentAccumulator() from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg result.merge(MuonGeoModelCfg(configFlags)) from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg result.merge(MagneticFieldSvcCfg(configFlags, UseDCS=False)) TrigL2MuonSA__MdtDataPreparator = CompFactory.TrigL2MuonSA.MdtDataPreparator result.addPublicTool( TrigL2MuonSA__MdtDataPreparator('TrigL2MuonSA::MdtDataPreparator', OutputLevel=1)) # noqa: ATL900 result.addEventAlgo(TestAlg('TestAlg')) return result
def MdtBytestreamDecodeCfg(flags, forTrigger=False): acc = ComponentAccumulator() # We need the MDT cabling to be setup from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg acc.merge(MDTCablingConfigCfg(flags)) # need the MagFieldSvc since MdtRdoToMdtPrepData.MdtRdoToMdtPrepDataTool.MdtCalibrationTool wants to retrieve it from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg acc.merge(MagneticFieldSvcCfg(flags)) # Make sure muon geometry is configured from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg acc.merge(MuonGeoModelCfg(flags)) # Setup the MDT ROD decoder MdtROD_Decoder = CompFactory.MdtROD_Decoder MDTRodDecoder = MdtROD_Decoder(name="MdtROD_Decoder") # RAW data provider tool needs ROB data provider service (should be another Config function?) ROBDataProviderSvc = CompFactory.ROBDataProviderSvc robDPSvc = ROBDataProviderSvc() acc.addService(robDPSvc) # Setup the RAW data provider tool keyName = flags.Overlay.BkgPrefix + "MDTCSM" if flags.Detector.OverlayMDT else "MDTCSM" Muon__MDT_RawDataProviderToolMT = CompFactory.Muon.MDT_RawDataProviderToolMT MuonMdtRawDataProviderTool = Muon__MDT_RawDataProviderToolMT( name="MDT_RawDataProviderToolMT", Decoder=MDTRodDecoder, RdoLocation=keyName) if forTrigger: MuonMdtRawDataProviderTool.CsmContainerCacheKey = MuonCacheNames.MdtCsmCache acc.addPublicTool( MuonMdtRawDataProviderTool ) # This should be removed, but now defined as PublicTool at MuFastSteering # Setup the RAW data provider algorithm Muon__MdtRawDataProvider = CompFactory.Muon.MdtRawDataProvider MdtRawDataProvider = Muon__MdtRawDataProvider( name="MdtRawDataProvider", ProviderTool=MuonMdtRawDataProviderTool) acc.addEventAlgo(MdtRawDataProvider, primary=True) return acc
def TrackingGeoCfg(inputFlags): result = ComponentAccumulator() from AtlasGeoModel.InDetGMConfig import InDetGeometryCfg result.merge(InDetGeometryCfg(inputFlags)) # Something builds muon stations -- extrapolator? from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg result.merge(MuonGeoModelCfg(inputFlags)) from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg result.merge(TrackingGeometrySvcCfg(inputFlags)) from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg result.merge(MagneticFieldSvcCfg(inputFlags)) return result
def MuonSTEP_PropagatorCfg(flags, name='MuonSTEP_Propagator', **kwargs): # Really there should be a central configuration for the STEP propagator. FIXME # In the old ConfigDb this was named MuonStraightLinePropagator (!) Trk__STEP_Propagator = CompFactory.Trk.STEP_Propagator from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg result = ComponentAccumulator() acc = MagneticFieldSvcCfg(flags) result.merge(acc) kwargs.setdefault("Tolerance", 0.00001) kwargs.setdefault("MaterialEffects", True) kwargs.setdefault("IncludeBgradients", True) propagator = Trk__STEP_Propagator(name=name, **kwargs) result.setPrivateTools(propagator) return result
def MdtCalibrationToolCfg(flags, **kwargs): result = MdtCalibrationDbToolCfg(flags, **kwargs) mdt_calibibration_db_tool = result.getPrimary() kwargs.setdefault("CalibrationDbTool", mdt_calibibration_db_tool) kwargs.setdefault("DoSlewingCorrection", flags.Muon.Calib.correctMdtRtForTimeSlewing) kwargs.setdefault("DoTemperatureCorrection", flags.Muon.Calib.applyRtScaling) kwargs.setdefault("DoWireSagCorrection", flags.Muon.Calib.correctMdtRtWireSag) kwargs.setdefault( "DoTofCorrection", flags.Beam.Type == 'collisions') # No TOF correction if not collisions acc = MagneticFieldSvcCfg(flags) result.merge(acc) MdtCalibrationTool = CompFactory.MdtCalibrationTool mdt_calibration_tool = MdtCalibrationTool(**kwargs) result.setPrivateTools(mdt_calibration_tool) return result
def TRT_DigitizationBasicToolCfg(flags, name="TRT_DigitizationBasicTool", **kwargs): """Return ComponentAccumulator with common TRT digitization tool config""" acc = TRT_GeometryCfg(flags) acc.merge(MagneticFieldSvcCfg(flags)) PartPropSvc = CompFactory.PartPropSvc acc.addService(PartPropSvc(InputFile="PDGTABLE.MeV")) if flags.Detector.Overlay and not flags.Input.isMC: acc.merge( addFolders(flags, "/TRT/Cond/DigVers", "TRT_OFL", tag="TRTCondDigVers-Collisions-01", db="OFLP200")) # default arguments kwargs.setdefault("PAI_Tool_Ar", TRT_PAI_Process_ArToolCfg(flags)) kwargs.setdefault("PAI_Tool_Kr", TRT_PAI_Process_KrToolCfg(flags)) kwargs.setdefault("PAI_Tool_Xe", TRT_PAI_Process_XeToolCfg(flags)) kwargs.setdefault("Override_TrtRangeCutProperty", flags.Digitization.TRTRangeCut) kwargs.setdefault("RandomSeedOffset", flags.Digitization.RandomSeedOffset) if not flags.Digitization.DoInnerDetectorNoise: kwargs.setdefault("Override_noiseInSimhits", 0) kwargs.setdefault("Override_noiseInUnhitStraws", 0) if flags.Beam.Type == "cosmics": kwargs.setdefault("PrintDigSettings", True) kwargs.setdefault("Override_cosmicFlag", 0) kwargs.setdefault("Override_doCosmicTimingPit", 1) kwargs.setdefault("Override_jitterTimeOffset", 0.) kwargs.setdefault("Override_timeCorrection", 0) if flags.Digitization.DoXingByXingPileUp: kwargs.setdefault("FirstXing", TRT_FirstXing()) kwargs.setdefault("LastXing", TRT_LastXing()) TRTDigitizationTool = CompFactory.TRTDigitizationTool tool = TRTDigitizationTool(name, **kwargs) acc.setPrivateTools(tool) return acc
def PrepareStandAloneBTagCfg(inputFlags): result = ComponentAccumulator() from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg result.merge(PoolReadCfg(inputFlags)) from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg acc = TrackingGeometrySvcCfg(inputFlags) result.merge(acc) from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg result.merge(MuonGeoModelCfg(inputFlags)) GeometryDBSvc = CompFactory.GeometryDBSvc result.addService(GeometryDBSvc("InDetGeometryDBSvc")) from PixelGeoModel.PixelGeoModelConfig import PixelGeometryCfg result.merge(PixelGeometryCfg(inputFlags)) # get standard config for magnetic field - map and cache from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg result.merge(MagneticFieldSvcCfg(inputFlags)) from IOVDbSvc.IOVDbSvcConfig import addFolders, addFoldersSplitOnline #load folders needed for Run2 ID alignment result.merge( addFoldersSplitOnline(inputFlags, "INDET", "/Indet/Onl/Align", "/Indet/Align", className="AlignableTransformContainer")) result.merge(addFolders(inputFlags, ['/TRT/Align'], 'TRT_OFL')) #load folders needed for IBL result.merge(addFolders(inputFlags, ['/Indet/IBLDist'], 'INDET_OFL')) return result
def PFCfg(inputFlags, **kwargs): #This is monolithic for now. #Once a first complete example runs, this will be split into small modular chunks. #Some such items may be best placed elsewehere (e.g. put magnetic field setup in magnetic field git folder etc) result = ComponentAccumulator() StoreGateSvc = CompFactory.StoreGateSvc result.addService(StoreGateSvc("DetectorStore")) #Alias calibrated topoclusters, if they exist already, such that overwrite won't fial from SGComps.AddressRemappingConfig import InputRenameCfg result.merge( InputRenameCfg("xAOD::CaloClusterContainer", "CaloCalTopoClusters", "")) #Setup up general geometry from AtlasGeoModel.InDetGMConfig import InDetGeometryCfg result.merge(InDetGeometryCfg(inputFlags)) #Setup TRT conditions TRTAlignCondAlg = CompFactory.TRTAlignCondAlg result.addCondAlgo( TRTAlignCondAlg(name="TRTAlignCondAlg", UseDynamicFolders=inputFlags.GeoModel.Align.Dynamic)) #Setup Pixel conditions PixelAlignCondAlg = CompFactory.PixelAlignCondAlg result.addCondAlgo( PixelAlignCondAlg( name="PixelAlignCondAlg", UseDynamicAlignFolders=inputFlags.GeoModel.Align.Dynamic)) PixelDetectorElementCondAlg = CompFactory.PixelDetectorElementCondAlg result.addCondAlgo( PixelDetectorElementCondAlg(name="PixelDetectorElementCondAlg")) #Setup SCT conditions SCT_AlignCondAlg = CompFactory.SCT_AlignCondAlg result.addCondAlgo( SCT_AlignCondAlg( name="SCT_AlignCondAlg", UseDynamicAlignFolders=inputFlags.GeoModel.Align.Dynamic)) SCT_DetectorElementCondAlg = CompFactory.SCT_DetectorElementCondAlg result.addCondAlgo( SCT_DetectorElementCondAlg(name="SCT_DetectorElementCondAlg")) GeometryDBSvc = CompFactory.GeometryDBSvc result.addService(GeometryDBSvc("InDetGeometryDBSvc")) #from AthenaCommon import CfgGetter #result.getService("GeoModelSvc").DetectorTools += [ CfgGetter.getPrivateTool("PixelDetectorTool", checkType=True) ] #result.getService("GeoModelSvc").DetectorTools += [ CfgGetter.getPrivateTool("SCT_DetectorTool", checkType=True) ] #Setup TRT geometry TRT_DetectorTool = CompFactory.TRT_DetectorTool trtDetectorTool = TRT_DetectorTool() #These two lines fix ATLASRECTS-5053. I expect eventually we can remove them, once the underlying issue is fixed. trtDetectorTool.DoXenonArgonMixture = False trtDetectorTool.DoKryptonMixture = False result.getService("GeoModelSvc").DetectorTools += [trtDetectorTool] #Setup up material for inner detector InDetServMatTool = CompFactory.InDetServMatTool result.getService("GeoModelSvc").DetectorTools += [InDetServMatTool()] #Setup up tracking geometry from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg acc = TrackingGeometrySvcCfg(inputFlags) result.merge(acc) #load folders needed for Run2 ID alignment from IOVDbSvc.IOVDbSvcConfig import addFolders result.merge(addFolders(inputFlags, ['/TRT/Align'], 'TRT_OFL')) #Setup up muon geometry from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg result.merge(MuonGeoModelCfg(inputFlags)) #setup magnetic field service from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg result.merge(MagneticFieldSvcCfg(inputFlags)) #hard-code MC conditions tag needed for my ESD file - must be a better way? how to auto-configure? iovDbSvc = result.getService("IOVDbSvc") iovDbSvc.GlobalTag = "OFLCOND-MC16-SDR-20" #Configure topocluster algorithmsm, and associated conditions from CaloRec.CaloTopoClusterConfig import CaloTopoClusterCfg result.merge(CaloTopoClusterCfg(inputFlags, doLCCalib=True)) from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg result.merge(caloTopoCoolFolderCfg(inputFlags)) from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg result.merge(CaloNoiseCondAlgCfg(inputFlags, "totalNoise")) result.merge(CaloNoiseCondAlgCfg(inputFlags, "electronicNoise")) #Cache the track extrapolations from TrackToCalo.CaloExtensionBuilderAlgCfg import getCaloExtenstionBuilderAlgorithm result.addEventAlgo(getCaloExtenstionBuilderAlgorithm(inputFlags)) #Configure the pflow algorithms PFLeptonSelector = CompFactory.PFLeptonSelector result.addEventAlgo(PFLeptonSelector("PFLeptonSelector")) from eflowRec.PFCfg import getPFTrackSelectorAlgorithm result.addEventAlgo( getPFTrackSelectorAlgorithm(inputFlags, "PFTrackSelector")) result.addEventAlgo(getOfflinePFAlgorithm(inputFlags)) from eflowRec.PFCfg import getChargedPFOCreatorAlgorithm, getNeutralPFOCreatorAlgorithm result.addEventAlgo(getChargedPFOCreatorAlgorithm(inputFlags, "")) result.addEventAlgo(getNeutralPFOCreatorAlgorithm(inputFlags, "")) return result
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration from AthenaCommon import Logging from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator from AthenaConfiguration.ComponentFactory import CompFactory if __name__=="__main__": # Setting needed for the ComponentAccumulator to do its thing from AthenaCommon.Configurable import Configurable Configurable.configurableRun3Behavior=True # Set message levels from AthenaCommon import Constants msgLvl = "WARNING" from AthenaCommon.Logging import log log.setLevel(msgLvl) # Config flags steer the job at various levels from AthenaConfiguration.AllConfigFlags import ConfigFlags ConfigFlags.Input.isMC = True ConfigFlags.Input.Files = ["/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/ASG/mc16_13TeV.410501.PowhegPythia8EvtGen_A14_ttbar_hdamp258p75_nonallhad.merge.AOD.e5458_s3126_r9364_r9315/AOD.11182705._000001.pool.root.1"] # Flags relating to multithreaded execution nthreads=0 ConfigFlags.Concurrency.NumThreads =nthreads if nthreads>0: ConfigFlags.Concurrency.NumThreads = 1 ConfigFlags.Concurrency.NumConcurrentEvents = 1 ConfigFlags.MET.UseTracks = True ConfigFlags.MET.DoPFlow = True if ConfigFlags.Beam.Type == 'cosmics' or ConfigFlags.Beam.Type == 'singlebeam':# used to have " or not rec.doInDet()" on the end
def AtlasExtrapolatorCfg(flags, name='AtlasExtrapolator'): result = ComponentAccumulator() acc = MagneticFieldSvcCfg(flags) result.merge(acc) # get the correct TrackingGeometry setup from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg acc = TrackingGeometrySvcCfg(flags) geom_svc = acc.getPrimary() result.merge(acc) # PROPAGATOR DEFAULTS -------------------------------------------------------------------------------------- AtlasPropagators = [] RkPropagator = CompFactory.Trk.RungeKuttaPropagator AtlasRungeKuttaPropagator = RkPropagator(name='AtlasRungeKuttaPropagator') result.addPublicTool(AtlasRungeKuttaPropagator) #TODO remove one day AtlasPropagators += [AtlasRungeKuttaPropagator] STEP_Propagator = CompFactory.Trk.STEP_Propagator AtlasSTEP_Propagator = STEP_Propagator(name='AtlasSTEP_Propagator') result.addPublicTool(AtlasSTEP_Propagator) #TODO remove one day AtlasPropagators += [AtlasSTEP_Propagator] # UPDATOR DEFAULTS ----------------------------------------------------------------------------------------- AtlasUpdators = [] MaterialEffectsUpdator = CompFactory.Trk.MaterialEffectsUpdator AtlasMaterialEffectsUpdator = MaterialEffectsUpdator( name='AtlasMaterialEffectsUpdator') result.addPublicTool(AtlasMaterialEffectsUpdator) #TODO remove one day AtlasUpdators += [AtlasMaterialEffectsUpdator] AtlasMaterialEffectsUpdatorLandau = MaterialEffectsUpdator( name='AtlasMaterialEffectsUpdatorLandau') AtlasMaterialEffectsUpdatorLandau.LandauMode = True result.addPublicTool( AtlasMaterialEffectsUpdatorLandau) #TODO remove one day AtlasUpdators += [AtlasMaterialEffectsUpdatorLandau] # the UNIQUE NAVIGATOR ( === UNIQUE GEOMETRY) -------------------------------------------------------------- Trk__Navigator = CompFactory.Trk.Navigator AtlasNavigator = Trk__Navigator(name='AtlasNavigator') AtlasNavigator.TrackingGeometrySvc = geom_svc result.addPublicTool(AtlasNavigator) #TODO remove one day # CONFIGURE PROPAGATORS/UPDATORS ACCORDING TO GEOMETRY SIGNATURE AtlasSubPropagators = [] AtlasSubUpdators = [] # -------------------- set it depending on the geometry ---------------------------------------------------- # default for Global is (Rk,Mat) AtlasSubPropagators += [AtlasRungeKuttaPropagator.name] AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name] # default for ID is (Rk,Mat) AtlasSubPropagators += [AtlasRungeKuttaPropagator.name] AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name] # default for BeamPipe is (STEP,Mat) AtlasSubPropagators += [AtlasSTEP_Propagator.name] AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name] # default for Calo is (STEP,Mat) AtlasSubPropagators += [AtlasSTEP_Propagator.name] AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name] # default for MS is (STEP,Mat) AtlasSubPropagators += [AtlasSTEP_Propagator.name] AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name] # default for Cavern is (Rk,Mat) AtlasSubPropagators += [AtlasRungeKuttaPropagator.name] AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name] # ---------------------------------------------------------------------------------------------------------- # call the base class constructor Extrapolator = Trk__Extrapolator(name,\ Navigator = AtlasNavigator,\ MaterialEffectsUpdators = AtlasUpdators,\ Propagators = AtlasPropagators,\ SubPropagators = AtlasSubPropagators,\ SubMEUpdators = AtlasSubUpdators ) result.setPrivateTools(Extrapolator) return result
def MooTrackBuilderCfg(flags, name="MooTrackBuilderTemplate", **kwargs): Muon__MooTrackBuilder = CompFactory.Muon.MooTrackBuilder Trk__STEP_Propagator = CompFactory.Trk.STEP_Propagator from MuonConfig.MuonRIO_OnTrackCreatorConfig import MdtDriftCircleOnTrackCreatorCfg, TriggerChamberClusterOnTrackCreatorCfg from MuonConfig.MuonRecToolsConfig import MuonTrackToSegmentToolCfg from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg # Based on this: https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MooreTools.py#L221 # ignoring all the name_prefix stuff for the moment, since I'm not sure it's necessary any more. result = MooTrackFitterCfg(flags) moo_track_fitter = result.getPrimary() result.addPublicTool(moo_track_fitter) kwargs.setdefault("Fitter", moo_track_fitter) # Now setup SL fitter (MooSLTrackFitter as defined here: # https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecExampleConfigDb.py#L203) acc = MCTBFitterCfg(flags, name='MCTBSLFitter', StraightLine=True) mctbslfitter = acc.getPrimary() result.addPublicTool(mctbslfitter) result.merge(acc) # Just take the default configuration, as per https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecExampleConfigDb.py#L56 # FIXME - this should be updated once there is a proper CA implementation for the STEP_Propagator prop = Trk__STEP_Propagator(name='MuonStraightLinePropagator') result.addPublicTool(prop) # TODO - check why Fitter and FitterPreFit are identical acc = MooTrackFitterCfg(flags, name="MooSLTrackFitter", Fitter=mctbslfitter, FitterPreFit=mctbslfitter, Propagator=prop, ReducedChi2Cut=10.0, SLFit=True) moo_sl_track_fitter = acc.getPrimary() result.addPublicTool(moo_sl_track_fitter) result.merge(acc) kwargs.setdefault("SLFitter", moo_sl_track_fitter) kwargs.setdefault( "RecalibrateMDTHitsOnTrack", ((not flags.Muon.doSegmentT0Fit) and flags.Beam.Type == 'collisions')) acc = MuonSeededSegmentFinderCfg(flags) muon_seeded_segment_finder = acc.getPrimary() result.addPublicTool(muon_seeded_segment_finder) result.merge(acc) kwargs.setdefault("SeededSegmentFinder", muon_seeded_segment_finder) acc = MdtDriftCircleOnTrackCreatorCfg(flags) mdt_dcot_creator = acc.getPrimary() kwargs.setdefault("MdtRotCreator", mdt_dcot_creator) result.merge(acc) acc = TriggerChamberClusterOnTrackCreatorCfg(flags) muon_comp_cluster_creator = acc.getPrimary() kwargs.setdefault("CompetingClustersCreator", muon_comp_cluster_creator) result.merge(acc) acc = MuonSTEP_PropagatorCfg(flags) muon_prop = acc.getPrimary() kwargs.setdefault("Propagator", muon_prop) result.merge(acc) acc = MuonChamberHoleRecoveryToolCfg(flags) hole_recovery_tool = acc.getPrimary() result.addPublicTool(hole_recovery_tool) result.merge(acc) kwargs.setdefault("HitRecoveryTool", hole_recovery_tool) kwargs.setdefault("ChamberHoleRecoveryTool", hole_recovery_tool) # FIXME? Remove duplicate from cxx? acc = MagneticFieldSvcCfg(flags) result.merge(acc) acc = MuonTrackToSegmentToolCfg(flags) track_to_segment_tool = acc.getPrimary() kwargs.setdefault("TrackToSegmentTool", track_to_segment_tool) result.merge(acc) kwargs.setdefault("Printer", MuonEDMPrinterTool(flags)) # FIXME - remove ErrorOptimisationTool from cxx? # declareProperty("ErrorOptimisationTool","" ); acc = MuPatCandidateToolCfg(flags) cand_tool = acc.getPrimary() result.merge(acc) kwargs.setdefault("CandidateTool", cand_tool) acc = MooCandidateMatchingToolCfg(flags) track_segment_matching_tool = acc.getPrimary() result.merge(acc) kwargs.setdefault("CandidateMatchingTool", track_segment_matching_tool) from MuonConfig.MuonRecToolsConfig import MuonTrackSummaryToolCfg acc = MuonTrackSummaryToolCfg(flags) track_summary = acc.getPrimary() result.merge(acc) kwargs.setdefault("TrackSummaryTool", track_summary) builder = Muon__MooTrackBuilder(name, **kwargs) result.setPrivateTools(builder) return result
def TrackSummaryToolWorkaround(flags): from AthenaConfiguration.ComponentFactory import CompFactory from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator result = ComponentAccumulator() ############################## WORKAROUND (START) ########################## ############################## TO RUN TRACKSUMMARYTOOL ##################### # Taken from InnerDetector/InDetDigitization/PixelDigitization/python/PixelDigitizationConfigNew.py from PixelConditionsAlgorithms.PixelConditionsConfig import PixelConfigCondAlgCfg result.merge( PixelConfigCondAlgCfg(flags, UseCalibConditions=True, UseDeadmapConditions=True, UseDCSStateConditions=False, UseDCSStatusConditions=False, UseDCSHVConditions=True, UseDCSTemperatureConditions=True, UseTDAQConditions=False)) from PixelConditionsTools.PixelConditionsSummaryConfig import PixelConditionsSummaryCfg InDetPixelConditionsSummaryTool = result.popToolsAndMerge( PixelConditionsSummaryCfg(flags)) # Taken from Tracking/TrkConfig/python/AtlasExtrapolatorConfig.py # AtlasExtrapolatorConfig can give only private extrapolator. We need public extrapolator. from TrkConfig.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg trackGeomCfg = TrackingGeometrySvcCfg(flags) geom_svc = trackGeomCfg.getPrimary() geom_svc.GeometryBuilder.Compactify = False ######## To avoid crash ######## result.merge(trackGeomCfg) from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg result.merge(MagneticFieldSvcCfg(flags)) AtlasNavigator = CompFactory.Trk.Navigator(name='AtlasNavigator') AtlasNavigator.TrackingGeometrySvc = geom_svc result.addPublicTool(AtlasNavigator) # Taken from InnerDetector/InDetExample/InDetRecExample/share/InDetRecLoadTools.py InDetPropagator = CompFactory.Trk.RungeKuttaPropagator( name='InDetPropagator') InDetPropagator.AccuracyParameter = 0.0001 InDetPropagator.MaxStraightLineStep = .004 result.addPublicTool(InDetPropagator) InDetMaterialUpdator = CompFactory.Trk.MaterialEffectsUpdator( name="InDetMaterialEffectsUpdator") result.addPublicTool(InDetMaterialUpdator) InDetSubPropagators = [] InDetSubUpdators = [] # -------------------- set it depending on the geometry ---------------------------------------------------- # default for ID is (Rk,Mat) InDetSubPropagators += [InDetPropagator.name] InDetSubUpdators += [InDetMaterialUpdator.name] # default for Calo is (Rk,MatLandau) InDetSubPropagators += [InDetPropagator.name] InDetSubUpdators += [InDetMaterialUpdator.name] # default for MS is (STEP,Mat) #InDetSubPropagators += [ InDetStepPropagator.name ] InDetSubUpdators += [InDetMaterialUpdator.name] #from TrkExTools.TrkExToolsConf import Trk__Extrapolator InDetExtrapolator = CompFactory.Trk.Extrapolator( name='InDetExtrapolator', Propagators=[InDetPropagator], MaterialEffectsUpdators=[InDetMaterialUpdator], Navigator=AtlasNavigator, SubPropagators=InDetSubPropagators, SubMEUpdators=InDetSubUpdators) result.addPublicTool(InDetExtrapolator) InDetTestPixelLayerTool = CompFactory.InDet.InDetTestPixelLayerTool( name="InDetTestPixelLayerTool", PixelSummaryTool=InDetPixelConditionsSummaryTool, CheckActiveAreas=True, CheckDeadRegions=True, CheckDisabledFEs=True) result.addPublicTool(InDetTestPixelLayerTool) InDetBoundaryCheckTool = CompFactory.InDet.InDetBoundaryCheckTool( name="InDetBoundaryCheckTool", UsePixel=flags.Detector.GeometryPixel, UseSCT=flags.Detector.GeometrySCT, PixelLayerTool=InDetTestPixelLayerTool) result.addPublicTool(InDetBoundaryCheckTool) InDetHoleSearchTool = CompFactory.InDet.InDetTrackHoleSearchTool( name="InDetHoleSearchTool", Extrapolator=InDetExtrapolator, CountDeadModulesAfterLastHit=True, BoundaryCheckTool=InDetBoundaryCheckTool) result.addPublicTool(InDetHoleSearchTool) InDetPrdAssociationTool = CompFactory.InDet.InDetPRD_AssociationToolGangedPixels( name="InDetPrdAssociationTool", PixelClusterAmbiguitiesMapName="PixelClusterAmbiguitiesMap", SetupCorrect=True, addTRToutliers=True) result.addPublicTool(InDetPrdAssociationTool) InDetTrackSummaryHelperTool = CompFactory.InDet.InDetTrackSummaryHelperTool( name="InDetSummaryHelper", AssoTool=InDetPrdAssociationTool, PixelToTPIDTool=None, TestBLayerTool=None, RunningTIDE_Ambi=True, DoSharedHits=False, HoleSearch=InDetHoleSearchTool, usePixel=flags.Detector.GeometryPixel, useSCT=flags.Detector.GeometrySCT, useTRT=flags.Detector.GeometryTRT) InDetTrackSummaryTool = CompFactory.Trk.TrackSummaryTool( name="InDetTrackSummaryTool", InDetSummaryHelperTool=InDetTrackSummaryHelperTool, doSharedHits=False, doHolesInDet=True, TRT_ElectronPidTool=None, TRT_ToT_dEdxTool=None, PixelToTPIDTool=None) result.setPrivateTools(InDetTrackSummaryTool) ############################## WORKAROUND (END) ############################ # To run job only with ID if hasattr(flags, "Detector") and hasattr( flags.Detector, "GeometryMuon") and hasattr( flags.Detector, "GeometryID"): TrkEventCnvSuperTool = CompFactory.Trk.EventCnvSuperTool( name="EventCnvSuperTool", DoMuons=flags.Detector.GeometryMuon, DoID=flags.Detector.GeometryID) result.addPublicTool(TrkEventCnvSuperTool) return result
def PixelLorentzAngleCfg(flags, name="PixelSiLorentzAngleCondAlg", **kwargs): """Return configured ComponentAccumulator and tool for PixelLorentzAngle SiLorentzAngleTool may be provided in kwargs """ acc = MagneticFieldSvcCfg(flags) tool = kwargs.get("SiLorentzAngleTool", PixelLorentzAngleTool(flags)) acc.merge(PixelDCSCondHVAlgCfg(flags)) acc.merge(PixelDCSCondTempAlgCfg(flags)) acc.merge(PixelDCSCondStateAlgCfg(flags)) acc.merge(PixelDCSCondStatusAlgCfg(flags)) SiPropAcc = PixelSiPropertiesCfg(flags) kwargs.setdefault("SiPropertiesTool", SiPropAcc.popPrivateTools()) acc.merge(SiPropAcc) kwargs.setdefault("UseMagFieldCache", tool.UseMagFieldCache) kwargs.setdefault("UseMagFieldDcs", not flags.Common.isOnline) acc.addCondAlgo(PixelSiLorentzAngleCondAlg(name, **kwargs)) acc.setPrivateTools(tool) return acc
def SCTHitEffMonAlgConfig(inputFlags): '''Function to configures some algorithms in the monitoring system.''' ### STEP 1 ### # Define one top-level monitoring algorithm. The new configuration # framework uses a component accumulator. from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator result = ComponentAccumulator() # The following class will make a sequence, configure algorithms, and link # them to GenericMonitoringTools from AthenaMonitoring import AthMonitorCfgHelper helper = AthMonitorCfgHelper(inputFlags, 'SCTHitEffMonCfg') ### STEP 2 ### # Adding an algorithm to the helper. Here, we will use the example # algorithm in the AthenaMonitoring package. Just pass the type to the # helper. Then, the helper will instantiate an instance and set up the # base class configuration following the inputFlags. The returned object # is the algorithm. from AthenaConfiguration.ComponentFactory import CompFactory myMonAlg = helper.addAlgorithm(CompFactory.SCTHitEffMonAlg, 'SCTHitEffMonAlg') # # If for some really obscure reason you need to instantiate an algorithm # # yourself, the AddAlgorithm method will still configure the base # # properties and add the algorithm to the monitoring sequence. # helper.AddAlgorithm(myExistingAlg) ### STEP 3 ### # Edit properties of a algorithm myMonAlg.TriggerChain = '' from LumiBlockComps.BunchCrossingCondAlgConfig import BunchCrossingCondAlgCfg result.merge(BunchCrossingCondAlgCfg(inputFlags)) from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg result.merge(MagneticFieldSvcCfg(inputFlags)) ### STEP 4 ### # Add some tools. N.B. Do not use your own trigger decion tool. Use the # standard one that is included with AthMonitorAlgorithm. # set up geometry / conditions from AtlasGeoModel.InDetGMConfig import InDetGeometryCfg result.merge(InDetGeometryCfg(inputFlags)) # Add a generic monitoring tool (a "group" in old language). The returned # object here is the standard GenericMonitoringTool. from ROOT import SCT_Monitoring as sctMon myMonGroup = [ helper.addGroup(myMonAlg, "SCTHitEffMonitorEC", "SCT/SCTEC/"), helper.addGroup(myMonAlg, "SCTHitEffMonitorB", "SCT/SCTB/"), helper.addGroup(myMonAlg, "SCTHitEffMonitorEA", "SCT/SCTEA/"), helper.addGroup(myMonAlg, "SCTHitEffMonitor", "SCT/GENERAL/") ] ### STEP 5 ### # Configure histograms # Conversion of ROOT.vector of ROOT.TString to list of str subDetName = [] for i in range(len(sctMon.subDetName)): subDetName.append(sctMon.subDetName[i].Data()) mapName = ["m_eff_", "eff_", "p_eff_"] ineffmapName = ["ineffm_", "ineff_", "ineffp_"] sumEff = ["summaryeffm", "summaryeff", "summaryeffp"] sumEffTitle = [ "Summary Module Efficiency in Endcap C", "Summary Module Efficiency in Barrel", "Summary Module Efficiency in Endcap A" ] limit = [sctMon.N_DISKS * 2, sctMon.N_BARRELS * 2, sctMon.N_DISKS * 2] # GENERAL myMonGroup[sctMon.GENERAL_INDEX].defineHistogram( varname="isub, eff;" + "SctTotalEff", type="TProfile", title="SCT Total Efficiency", path="eff", xbins=sctMon.N_REGIONS, xmin=0., xmax=sctMon.N_REGIONS, xlabels=subDetName) myMonGroup[sctMon.GENERAL_INDEX].defineHistogram( varname="isub, eff;" + "SctTotalEffBCID", type="TProfile", title="SCT Total Efficiency for First BCID", path="eff", xbins=sctMon.N_REGIONS, xmin=0., xmax=sctMon.N_REGIONS, xlabels=subDetName, cutmask="isFirstBCID") myMonGroup[sctMon.GENERAL_INDEX].defineHistogram( varname="sideHash, eff;" + "effHashCode", type="TProfile", title="Efficiency vs module Hash code" + ";Module Hash Code;Efficiency", path="eff", xbins=sctMon.n_mod[sctMon.GENERAL_INDEX] * 2, xmin=-0.5, xmax=sctMon.n_mod[sctMon.GENERAL_INDEX] * 2 - 0.5) myMonGroup[sctMon.GENERAL_INDEX].defineHistogram( varname="LumiBlock, eff;" + "effLumiBlock", type="TProfile", title="Efficiency vs Luminosity block" + ";;Efficiency", path="eff", xbins=sctMon.NBINS_LBs, xmin=0.5, xmax=sctMon.NBINS_LBs + 0.5) ### This histogram should be filled by post processing ### # myMonGroup[sctMon.GENERAL_INDEX].defineHistogram(varname= "eff;" + "SctEffDistribution", # type= "TH1F", # title= "SCT Efficiency Distribution"+";Efficiency;Links", # path="eff", # xbins= 500, # xmin=0., # xmax=1.) # SCTEC, SCTB, SCTEA for isub in range(sctMon.N_REGIONS): profileLabels = range(limit[isub]) for k in range(limit[isub]): profileLabels[k] = dedicatedTitle(k, isub) # Efficiency myMonGroup[isub].defineHistogram( varname="layerPlusHalfSide, eff;" + sumEff[isub], type="TProfile", title=sumEffTitle[isub] + ";;Efficiency", path="eff", xbins=2 * sctMon.n_layers[isub], xmin=0., xmax=sctMon.n_layers[isub], xlabels=profileLabels) # Efficiency for first BCIDs myMonGroup[isub].defineHistogram( varname="layerPlusHalfSide, eff;" + sumEff[isub] + "BCID", type="TProfile", title=sumEffTitle[isub] + " for First BC" + ";;Efficiency", path="eff", xbins=2 * sctMon.n_layers[isub], xmin=0., xmax=sctMon.n_layers[isub], xlabels=profileLabels, cutmask="isFirstBCID") # Efficiency as a function of LB myMonGroup[isub].defineHistogram( varname="LumiBlock, eff;" + "effLumiBlock", #different names for fill type="TProfile", title="Efficiency vs Luminosity block in " + sctMon.subDetName[isub] + ";Luminosity block" + ";Efficiency", path="eff", xbins=sctMon.NBINS_LBs, xmin=0.5, xmax=sctMon.NBINS_LBs + 0.5) # Disks for SCTEC and SCTEA and layers for SCTB for layer_disk in range(sctMon.n_layers[isub]): for side in range(2): etaPhiSuffix = "_" + str(layer_disk) + "_" + str(side) effName = mapName[isub] + str(layer_disk) + "_" + str(side) ineffName = ineffmapName[isub] + str(layer_disk) + "_" + str( side) # Efficiency myMonGroup[isub].defineHistogram( varname="ieta" + etaPhiSuffix + ",iphi" + etaPhiSuffix + ",eff;" + effName, type="TProfile2D", title="Hit efficiency of" + sctMon.layerName[isub].Data() + str(layer_disk) + " / side " + str(side) + " in " + subDetName[isub] + ";Index in the direction of #eta;Index in the direction of #phi", path="eff", xbins=sctMon.n_etabins[isub], xmin=sctMon.f_etabin[isub] - .5, xmax=sctMon.l_etabin[isub] + .5, ybins=sctMon.n_phibins[isub], ymin=sctMon.f_phibin[isub] - .5, ymax=sctMon.l_phibin[isub] + .5) # Efficiency for first BCIDs myMonGroup[isub].defineHistogram( varname="ieta" + etaPhiSuffix + ",iphi" + etaPhiSuffix + ",eff;" + effName + "_bcid", type="TProfile2D", title="Hit efficiency of" + sctMon.layerName[isub].Data() + str(layer_disk) + " / side " + str(side) + " in " + subDetName[isub] + " for first BCID" + ";Index in the direction of #eta;Index in the direction of #phi", path="eff", xbins=sctMon.n_etabins[isub], xmin=sctMon.f_etabin[isub] - .5, xmax=sctMon.l_etabin[isub] + .5, ybins=sctMon.n_phibins[isub], ymin=sctMon.f_phibin[isub] - .5, ymax=sctMon.l_phibin[isub] + .5, cutmask="isFirstBCID") # Inefficiency myMonGroup[isub].defineHistogram( varname="ieta" + etaPhiSuffix + ",iphi" + etaPhiSuffix + ",ineff;" + ineffName, type="TProfile2D", title="Hit inefficiency of" + sctMon.layerName[isub].Data() + str(layer_disk) + " / side " + str(side) + " in " + subDetName[isub] + ";Index in the direction of #eta;Index in the direction of #phi", path="eff", xbins=sctMon.n_etabins[isub], xmin=sctMon.f_etabin[isub] - .5, xmax=sctMon.l_etabin[isub] + .5, ybins=sctMon.n_phibins[isub], ymin=sctMon.f_phibin[isub] - .5, ymax=sctMon.l_phibin[isub] + .5) # Merge with result object and return result.merge(helper.result()) return result