def MuonTrackCleaner(name, extraFlags=None, **kwargs): kwargs.setdefault("Chi2Cut", muonStandaloneFlags.Chi2NDofCut()) kwargs.setdefault("MaxAvePullSumPerChamber", 6) kwargs.setdefault("Fitter", getPrivateTool('MCTBFitterMaterialFromTrack')) kwargs.setdefault("SLFitter", getPrivateTool('MCTBSLFitterMaterialFromTrack')) kwargs.setdefault("MdtRotCreator", getPrivateTool('MdtDriftCircleOnTrackCreator')) # kwargs.setdefault("CompRotCreator", getPrivateTool('TriggerChamberClusterOnTrackCreator')) Not in DB return CfgMgr.Muon__MuonTrackCleaner(name, **kwargs)
def MuonSegmentFittingTool(name='MuonSegmentFittingTool', extraFlags=None, **kwargs): prop = getPublicTool('AtlasRungeKuttaPropagator') kwargs.setdefault("SLPropagator", getPrivateToolClone('SLPropagator', prop)) # Think I need to do it this way because AtlasRungeKuttaPropagator isn't known to ConfigurableFactory. # If I directly call getPrivateTool('AtlasRungeKuttaPropagator') then it fails with: # ConfigurationError: Private Tool <Trk::RungeKuttaPropagator/ToolSvc.AtlasRungeKuttaPropagator at 0x7f5811db3158> not found kwargs.setdefault("SLFitter", getPrivateTool('MCTBSLFitter')) kwargs.setdefault("CurvedFitter", getPrivateTool('MCTBFitter')) kwargs.setdefault("TrackCleaner", getPrivateTool('MuonTrackCleaner')) return CfgMgr.Muon__MuonSegmentFittingTool(name, **kwargs)
def MuonCaloTagTool(name='MuonCaloTagTool', **kwargs): from CaloTrkMuIdTools.CaloTrkMuIdToolsConf import CaloMuonTag as ConfiguredCaloMuonTag CaloMuonTagLoose = ConfiguredCaloMuonTag(name="CaloMuonTagLoose") CaloMuonTagLoose.TagMode = "Loose" CaloMuonTagTight = ConfiguredCaloMuonTag(name="CaloMuonTag") kwargs.setdefault("CaloMuonTagLoose", CaloMuonTagLoose) kwargs.setdefault("CaloMuonTagTight", CaloMuonTagTight) kwargs.setdefault("CaloMuonLikelihoodTool", getPrivateTool("CaloMuonLikelihoodTool")) kwargs.setdefault("CaloMuonScoreTool", getPrivateTool("CaloMuonScoreTool")) kwargs.setdefault("TrackDepositInCaloTool", getPublicTool("TrackDepositInCaloTool")) kwargs.setdefault("TrackSelectorTool", getPublicTool("CaloTrkMuIdAlgTrackSelectorTool")) kwargs.setdefault("doCaloLR", True) return CfgMgr.MuonCombined__MuonCaloTagTool(name, **kwargs)
def QratCscClusterFitter(name="QratCscClusterFitter", extraFlags=None, **kwargs): qratcor_css_eta = [ 0.000000, 0.000000, 0.000000, 0.000000, 0.0699381, 0.178291, 0.271303, 0.345611, 0.400738, 0.452451, 0.493772, 0.526792, 0.553845, 0.580111, 0.603337, 0.624749, 0.646065, 0.663924, 0.681897, 0.701345, 0.716067, 0.730324, 0.743168, 0.760598, 0.773341, 0.786406, 0.798358, 0.811339, 0.820949, 0.832676, 0.843917, 0.85412, 0.863914, 0.873229, 0.88251, 0.892856, 0.903296, 0.910067, 0.917892, 0.928028, 0.93461, 0.943679, 0.951617, 0.958326, 0.964428, 0.97341, 0.978204, 0.987075, 0.994789, 1.000000 ] qratcor_csl_eta = [ 0.000000, 0.000000, 0.000000, 0.000000, 0.0290177, 0.0834867, 0.188683, 0.269967, 0.334887, 0.393036, 0.440317, 0.481884, 0.51725, 0.545107, 0.56959, 0.592327, 0.614087, 0.635344, 0.655252, 0.672766, 0.690929, 0.707293, 0.722742, 0.738323, 0.753562, 0.76749, 0.780983, 0.79354, 0.806521, 0.818085, 0.829987, 0.841443, 0.853723, 0.863393, 0.87431, 0.883139, 0.892962, 0.902803, 0.911276, 0.921417, 0.929387, 0.938106, 0.947072, 0.954406, 0.961692, 0.97055, 0.978517, 0.985133, 0.992257, 1.000000 ] kwargs.setdefault("qratcor_csl_eta", qratcor_csl_eta) kwargs.setdefault("qratcor_css_eta", qratcor_css_eta) kwargs.setdefault("CscAlignmentTool", getPrivateTool("CscAlignmentTool")) return CfgMgr.QratCscClusterFitter(name, **kwargs)
def CscClusterOnTrackCreator(name="CscClusterOnTrackCreator", **kwargs): kwargs.setdefault("CscStripFitter", getPrivateTool("CalibCscStripFitter")) kwargs.setdefault("CscClusterFitter", getPrivateTool("QratCscClusterFitter")) kwargs.setdefault("CscClusterUtilTool", getPrivateTool("CscClusterUtilTool")) if False: # enable CscClusterOnTrack error scaling : from InDetRecExample.TrackingCommon import getRIO_OnTrackErrorScalingCondAlg, createAndAddCondAlg createAndAddCondAlg(getMuonRIO_OnTrackErrorScalingCondAlg, 'RIO_OnTrackErrorScalingCondAlg') kwargs.setdefault("CSCErrorScalingKey", "/MUON/TrkErrorScalingCSC") if globalflags.DataSource( ) == 'data': # collisions real data or simulated first data # scale CSC and hit errors kwargs.setdefault("ErrorScalerBeta", 0.070) return CfgMgr.Muon__CscClusterOnTrackCreator(name, **kwargs)
def DCMathSegmentMaker(name='DCMathSegmentMaker', extraFlags=None, **kwargs): beamType = getattr(extraFlags, "beamType", beamFlags.beamType()) doSegmentT0Fit = getattr(extraFlags, "doSegmentT0Fit", muonRecFlags.doSegmentT0Fit()) updateSegmentSecondCoordinate = getattr( extraFlags, "updateSegmentSecondCoordinate", muonStandaloneFlags.updateSegmentSecondCoordinate()) enableCurvedSegmentFinding = getattr( extraFlags, "enableCurvedSegmentFinding", muonStandaloneFlags.enableCurvedSegmentFinding()) kwargs.setdefault("RefitSegment", True) kwargs.setdefault("AssumePointingPhi", beamType != 'cosmics') kwargs.setdefault("OutputFittedT0", True) kwargs.setdefault("DCFitProvider", "MdtSegmentT0Fitter") #kwargs.setdefault("CurvedErrorScaling", False) kwargs.setdefault("UsePreciseError", True) kwargs.setdefault("SinAngleCut", 0.4) #MDT conditions information not available online if (athenaCommonFlags.isOnline): kwargs.setdefault("MdtCondKey", "") # MuonCompetingClustersCreator apparently just takes default kwargs.setdefault("MuonClusterCreator", getPrivateTool("MuonClusterOnTrackCreator")) if (beamType == 'singlebeam' or beamType == 'cosmics'): kwargs.setdefault("SinAngleCut", 0.9) kwargs.setdefault("AddUnassociatedPhiHits", True) kwargs.setdefault("RecoverBadRpcCabling", True) kwargs.setdefault("CurvedErrorScaling", False) elif globalflags.DataSource( ) == 'data': # collisions real data or simulation first data kwargs.setdefault("AddUnassociatedPhiHits", True) kwargs.setdefault("RecoverBadRpcCabling", True) if doSegmentT0Fit: kwargs.setdefault( "MdtCreatorT0", getPrivateTool("MdtDriftCircleOnTrackCreatorAdjustableT0")) kwargs.setdefault("MdtSegmentFinder", getPrivateTool("MdtMathT0FitSegmentFinder")) else: kwargs.setdefault("MdtSegmentFinder", getPrivateTool("MdtMathSegmentFinder")) kwargs.setdefault("SegmentFitter", getPrivateTool("MuonSegmentFittingTool")) kwargs.setdefault("SegmentSelector", getPrivateTool("MuonSegmentSelectionTool")) if updateSegmentSecondCoordinate: kwargs.setdefault("UpdatePhiUsingPhiHits", True) if enableCurvedSegmentFinding: kwargs.setdefault("CurvedErrorScaling", False) kwargs.setdefault("PreciseErrorScale", 1) kwargs.setdefault("UsePreciseError", True) return CfgMgr.Muon__DCMathSegmentMaker(name, **kwargs)
from AthenaCommon.CfgGetter import getPrivateTool ckvptool = getPrivateTool("CrabKissingVertexPositioner") # all lengths are in mm ckvptool.BunchShape = "GAUSS" # GAUSS or FLAT ckvptool.BunchLength = 81. ckvptool.Epsilon = 2.5e-3 # normalized emittance ckvptool.BetaStar = 150. # ckvptool.AlfaParallel = 3.3e-3 # kissing angle ckvptool.AlfaX = 10.3e-3 #rad, crabbing angle ckvptool.ThetaX = 0. #rad, half crossing angle from AthenaCommon.AlgSequence import AlgSequence job = AlgSequence() job.BeamEffectsAlg.GenEventManipulators["GenEventVertexPositioner"].VertexShifters=[ckvptool]
############################################################# # # postOptions.ScoringVolume.py : calls ScoringVolumeKiller # while running a G4 simulation of the ATLAS detector. # The ScoringVolumeKiller will kill all particles leaving # the scoring volumes surrounding the muon stations. # # Dennis Wright (SLAC) # 25 May 2010 ############################################################# from AthenaCommon.CfgGetter import getPrivateTool, getService getService('DetectorGeometrySvc').RegionCreators += [ getPrivateTool('MuonPhysicsRegionTool') ] #FIXME need to add this to the list of RegionCreators, but #currently initializing the DetectorGeometrySvc too early causes #problems with the GeoModelSvc configuration.
csc_evtSelectionTriggers = [ "L1_MU10", "L1_MU15", "EF_mu20_muCombTag_NoEF", "EF_mu15", "EF_mu15_mu10_EFFS", "EF_2mu10", "EF_2mu10_loose" ] ## retrieve TDT (this should be done already?) if(DQMonFlags.useTrigger() and hasattr(ToolSvc, DQMonFlags.nameTrigDecTool())): from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool ToolSvc += Trig__TrigDecisionTool( "TrigDecisionTool" ) ToolSvc.TrigDecisionTool.OutputLevel=ERROR ToolSvc.TrigDecisionTool.Navigation.OutputLevel = ERROR from CscRawDataMonitoring.CscRawDataMonitoringConf import CscClusterValAlg cscClusterESDValAlg = CscClusterValAlg( name = 'cscClusterESDValAlg', CSCClusterPath = 'Muon/MuonRawDataMonitoring/CSC/Clusters', CSCClusterKey = 'CSC_Clusters', CSCPrepRawDataKey = 'CSC_Measurements', CSCQmaxCutADC = 0, CSCCalibTool = getPrivateTool("CscCalibTool"), CSCStripFitter = getPrivateTool("CalibCscStripFitter"), #CSCTrigDecisionTool = ToolSvc.TrigDecisionTool, CSCDoEventSelection = False, CSCEventSelTriggers = csc_evtSelectionTriggers ) #ToolSvc += cscClusterESDValAlg cscesdRawMonMan.AthenaMonTools += [cscClusterESDValAlg] topSequence += cscesdRawMonMan #print cscesdRawMonMan ############################################################################################################ #--------------------------------------------------------------- # CSC Segment Monitoring
def getPileUpEventLoopMgr(name="PileUpEventLoopMgr", **kwargs): from Digitization.DigitizationFlags import digitizationFlags #configure random generator digitizationFlags.rndmSeedList.addSeed("PileUpCollXingStream", 123, 345) # SubDet By SubDet (default) or Xing By Xing Pile-up? kwargs.setdefault('XingByXing', digitizationFlags.doXingByXingPileUp()) # Bunch Structure if digitizationFlags.BeamIntensityPattern.statusOn: if digitizationFlags.SignalPatternForSteppingCache.statusOn: # Simulate Bunch Structure with events sliding backwards on a conveyor belt kwargs.setdefault('BeamInt', getService("StepArrayBM")) elif digitizationFlags.FixedT0BunchCrossing.statusOn: # Simulate Bunch Structure using a fixed point for the central bunch crossing kwargs.setdefault('BeamInt', getService("FixedArrayBM")) else: # Simulate Bunch Structure and allow the central bunch crossing to vary kwargs.setdefault('BeamInt', getService("ArrayBM")) #define inputs kwargs.setdefault('OrigSelector', "EventSelector") BackgroundCaches = [] if 'SplitCacheForMinbias' in digitizationFlags.experimentalDigi( ) and digitizationFlags.doLowPtMinBias( ) and digitizationFlags.doHighPtMinBias(): BackgroundCaches += [getPrivateTool("MinBiasCache", checkType=True)] else: if digitizationFlags.doLowPtMinBias(): BackgroundCaches += [ getPrivateTool("LowPtMinBiasCache", checkType=True) ] if digitizationFlags.doHighPtMinBias(): BackgroundCaches += [ getPrivateTool("HighPtMinBiasCache", checkType=True) ] if digitizationFlags.doCavern(): BackgroundCaches += [getPrivateTool("CavernCache", checkType=True)] if digitizationFlags.doBeamGas(): BackgroundCaches += [getPrivateTool("BeamGasCache", checkType=True)] if digitizationFlags.doBeamHalo(): BackgroundCaches += [getPrivateTool("BeamHaloCache", checkType=True)] kwargs.setdefault('bkgCaches', BackgroundCaches) #define output stream kwargs.setdefault('OutStreamType', "AthenaOutputStream") #xing frequency in ns kwargs.setdefault('XingFrequency', digitizationFlags.bunchSpacing()) #define time range to be studied. t0 at t' ,0, xing' ,0 kwargs.setdefault('firstXing', digitizationFlags.initialBunchCrossing()) kwargs.setdefault('lastXing', digitizationFlags.finalBunchCrossing()) from AthenaCommon.AppMgr import ServiceMgr if digitizationFlags.RunAndLumiOverrideList.statusOn: if not (digitizationFlags.RunAndLumiOverrideList.is_locked()): raise RuntimeError( 'You cannot configure the PileUpEventLoopMgr with an unlocked JobProperty.' ) kwargs.setdefault( 'MaxMinBiasCollPerXing', digitizationFlags.RunAndLumiOverrideList.getMaxNevtsPerXing()) lumiProfileSvc = getService("LumiProfileSvc") kwargs.setdefault('BeamLuminosity', lumiProfileSvc) ServiceMgr += lumiProfileSvc else: kwargs.setdefault('MaxMinBiasCollPerXing', digitizationFlags.numberOfCollisions()) noProfileSvc = getService("NoProfileSvc") kwargs.setdefault('BeamLuminosity', noProfileSvc) ServiceMgr += noProfileSvc return CfgMgr.PileUpEventLoopMgr(name, **kwargs)
# This job option should be added via the postInclude # command line argument. I.e. before theApp.initialize() # is called. # ######################################################### from AthenaCommon.AlgSequence import AlgSequence, AthSequencer topSequence = AlgSequence() from AthenaCommon.DetFlags import DetFlags if DetFlags.pileup.any_on(): index = 0 for alg in topSequence: index += 1 #count position if 'PileUpToolsAlg' in alg.name(): from AthenaCommon.CfgGetter import getPrivateTool alg.PileUpTools += [getPrivateTool("MergeHijingParsTool")] break if 'MergeMcEventCollection' == alg.name(): from MCTruthSimAlgs.MCTruthSimAlgsConf import MergeHijingPars mergeHijingPars = MergeHijingPars() topSequence.insert(index, mergeHijingPars) break else: try: from TruthIO.TruthIOConf import PrintHijingPars except: from TruthExamples.TruthExamplesConf import PrintHijingPars topSequence += PrintHijingPars() ## configure Athena for POOL persistency streamAlgs = ['StreamHITS', 'StreamRDO', 'StreamESD', 'StreamAOD']
def CscClusterUtilTool(name="CscClusterUtilTool", extraFlags=None, **kwargs): kwargs.setdefault("strip_fitter", getPrivateTool("CalibCscStripFitter")) kwargs.setdefault("precision_fitter", getPrivateTool("QratCscClusterFitter")) return CfgMgr.CscClusterUtilTool(name, **kwargs)
def __init__(self, forceUseDB=False, forceUseGeoModel=False): if forceUseDB and forceUseGeoModel: from AthenaCommon import Logging msg = Logging.logging.getLogger("SCTLorentzAngleToolSetup") msg.error( "Setting is wrong: both forceUseDB and forceUseGeoModel cannot be True at the same time" ) return # Set up SCT_DCSConditiosnTool if necessary if not forceUseGeoModel: from SCT_ConditionsTools.SCT_DCSConditionsToolSetup import SCT_DCSConditionsToolSetup sct_DCSConditionsToolSetup = SCT_DCSConditionsToolSetup() # For HLT and online monitoring from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.isOnline(): sct_DCSConditionsToolSetup.setReadAllDBFolders(False) from AthenaCommon.GlobalFlags import globalflags if globalflags.DataSource() == "data": sct_DCSConditionsToolSetup.setDbInstance("SCT") dcs_folder = "/SCT/HLT/DCS" sct_DCSConditionsToolSetup.setStateFolder(dcs_folder + "/CHANSTAT") sct_DCSConditionsToolSetup.setHVFolder(dcs_folder + "/HV") sct_DCSConditionsToolSetup.setTempFolder(dcs_folder + "/MODTEMP") sct_DCSConditionsToolSetup.setup() # Set up SCT_SiliconConditionsTool from SCT_ConditionsTools.SCT_SiliconConditionsToolSetup import SCT_SiliconConditionsToolSetup sct_SiliconConditionsToolSetup = SCT_SiliconConditionsToolSetup() if forceUseGeoModel: sct_SiliconConditionsToolSetup.setUseDB(False) sct_SiliconConditionsToolSetup.setForceUseGeoModel(True) else: sct_SiliconConditionsToolSetup.setDcsTool( sct_DCSConditionsToolSetup.getTool()) sct_SiliconConditionsToolSetup.setup() sctSiliconConditionsTool = sct_SiliconConditionsToolSetup.getTool() self.sctSiliconConditionsTool = sctSiliconConditionsTool self.SCT_SiliconConditionsTool = sctSiliconConditionsTool # Set up SCTSiLorentzAngleCondAlg from AthenaCommon.AlgSequence import AthSequencer condSeq = AthSequencer("AthCondSeq") if not hasattr(condSeq, "SCTSiLorentzAngleCondAlg"): from SiLorentzAngleTool.SiLorentzAngleToolConf import SCTSiLorentzAngleCondAlg from AthenaCommon.AthenaCommonFlags import athenaCommonFlags condSeq += SCTSiLorentzAngleCondAlg( name="SCTSiLorentzAngleCondAlg", SiConditionsTool=sctSiliconConditionsTool, UseMagFieldCache=True, UseMagFieldDcs=(not athenaCommonFlags.isOnline()), UseGeoModel=forceUseGeoModel) sctSiLorentzAngleCondAlg = condSeq.SCTSiLorentzAngleCondAlg if forceUseDB: sctSiLorentzAngleCondAlg.useSctDefaults = False # Set up SCTLorentzAngleTool from AthenaCommon.CfgGetter import getPrivateTool sctLorentzAngleTool = getPrivateTool("SCTLorentzAngleTool") # Pass the silicon conditions tool to the Lorentz angle tool # Also make sure UseMagFieldTool is True as AtlasGeoModel sets this to False # if loaded first. sctLorentzAngleTool.UseMagFieldCache = True self.SCTLorentzAngleTool = sctLorentzAngleTool
getPrivateToolClone('SLPropagator', prop)) # Think I need to do it this way because AtlasRungeKuttaPropagator isn't known to ConfigurableFactory. # If I directly call getPrivateTool('AtlasRungeKuttaPropagator') then it fails with: # ConfigurationError: Private Tool <Trk::RungeKuttaPropagator/ToolSvc.AtlasRungeKuttaPropagator at 0x7f5811db3158> not found kwargs.setdefault("SLFitter", getPrivateTool('MCTBSLFitter')) kwargs.setdefault("CurvedFitter", getPrivateTool('MCTBFitter')) kwargs.setdefault("TrackCleaner", getPrivateTool('MuonTrackCleaner')) return CfgMgr.Muon__MuonSegmentFittingTool(name, **kwargs) if DetFlags.detdescr.Muon_on() and rec.doMuon(): # until all clients explicitly get their tools and services, load some explicitly getPublicTool("ResidualPullCalculator") getPublicTool("MuonHoughPatternTool") getPublicTool("MuonCombinePatternTool") getPublicTool("MuonPhiHitSelector") getPublicTool("MuonEDMPrinterTool") getPublicTool("MuonSegmentMomentum") getPublicTool("MuonClusterOnTrackCreator") if MuonGeometryFlags.hasCSC(): getPrivateTool("CscClusterOnTrackCreator") getPrivateTool("CscBroadClusterOnTrackCreator") getPublicTool("MdtDriftCircleOnTrackCreator") getPublicTool("MdtTubeHitOnTrackCreator") #getService("SomeService") else: # not (DetFlags.Muon_on() and rec.doMuon()) logMuon.warning( "Muon reconstruction tools only loaded on-demand because Muons")
def CombinedMuonTrackBuilder( name='CombinedMuonTrackBuilder', **kwargs ): from AthenaCommon.AppMgr import ToolSvc kwargs.setdefault("CaloEnergyParam" , getPublicTool("MuidCaloEnergyToolParam") ) kwargs.setdefault("CaloTSOS" , getPublicTool("MuidCaloTrackStateOnSurface") ) kwargs.setdefault("MaterialAllocator" , getPublicTool("MuidMaterialAllocator") ) kwargs.setdefault("MdtRotCreator" , getPublicTool("MdtDriftCircleOnTrackCreator") ) kwargs.setdefault("CleanCombined" , True ) kwargs.setdefault("CleanStandalone" , True ) kwargs.setdefault("BadFitChi2" , 2.5 ) kwargs.setdefault("LargeMomentumError" , 0.5 ) kwargs.setdefault("LineMomentum" , muonStandaloneFlags.straightLineFitMomentum() ) kwargs.setdefault("LowMomentum" , 10.*GeV ) kwargs.setdefault("MinEnergy" , 0.3*GeV ) kwargs.setdefault("PerigeeAtSpectrometerEntrance" , False ) kwargs.setdefault("ReallocateMaterial" , False ) kwargs.setdefault("Vertex2DSigmaRPhi" , 100.*mm ) kwargs.setdefault("Vertex3DSigmaRPhi" , 6.*mm ) kwargs.setdefault("Vertex3DSigmaZ" , 60.*mm) kwargs.setdefault("UseCaloTG" , True ) # kwargs.setdefault("CaloMaterialProvider" , getPublicTool("MuonMaterialProviderTool")) kwargs.setdefault("TrackQuery" , getPrivateTool("MuonTrackQuery") ) if TriggerFlags.MuonSlice.doTrigMuonConfig: kwargs.setdefault("MuonHoleRecovery" , "" ) trigTrackSummary = getPublicToolClone("TrigMuonTrackSummary", "MuonTrackSummaryTool") if DetFlags.detdescr.ID_on(): from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackSummaryHelperTool trigTrackSummary.InDetSummaryHelperTool = InDetTrigTrackSummaryHelperTool trigTrackSummary.doHolesInDet = True kwargs.setdefault("TrackSummaryTool" , trigTrackSummary ) kwargs.setdefault("Propagator" , ToolSvc.AtlasRungeKuttaPropagator) kwargs.setdefault("SLPropagator" , ToolSvc.AtlasRungeKuttaPropagator) #The trigger uses the iPatFitter in different sequences that do and do not include ID tracking #so using the same track summary tool as is used here to get it correct trackSummary = kwargs["TrackSummaryTool"] suffix = "MS" if "Trig" in trackSummary.name(): suffix = "CB" kwargs.setdefault("Fitter" , getPublicToolClone("TrigiPatFitter_"+suffix, "iPatFitter", TrackSummaryTool=trackSummary) ) kwargs.setdefault("SLFitter" , getPublicToolClone("TrigiPatSLFitter_"+suffix, "iPatSLFitter", TrackSummaryTool=trackSummary) ) kwargs.setdefault("MuonErrorOptimizer", "") kwargs.setdefault("CscRotCreator" , "" ) kwargs.setdefault("Cleaner" , getPrivateToolClone("TrigMuidTrackCleaner_"+suffix, "MuidTrackCleaner", Fitter=kwargs["Fitter"]) ) else: import MuonCombinedRecExample.CombinedMuonTrackSummary kwargs.setdefault("MuonHoleRecovery" , getPublicTool("MuidSegmentRegionRecoveryTool") ) kwargs.setdefault("TrackSummaryTool" , ToolSvc.CombinedMuonTrackSummary ) kwargs.setdefault("Propagator" , getPublicTool("MuonCombinedPropagator") ) kwargs.setdefault("SLPropagator" , getPublicTool("MuonCombinedPropagator") ) kwargs.setdefault("Fitter" , getPublicTool("iPatFitter") ) kwargs.setdefault("SLFitter" , getPublicTool("iPatSLFitter") ) kwargs.setdefault("CscRotCreator" , (getPublicTool("CscClusterOnTrackCreator") if MuonGeometryFlags.hasCSC() else "") ) kwargs.setdefault("Cleaner" , getPrivateTool("MuidTrackCleaner") ) if beamFlags.beamType() == 'cosmics': kwargs.setdefault("MdtRotCreator" , "" ) kwargs.setdefault("LowMomentum" , 1.5*GeV ) kwargs.setdefault("ReallocateMaterial", False ) kwargs.setdefault("Vertex2DSigmaRPhi" , 100.*mm ) kwargs.setdefault("Vertex3DSigmaRPhi" , 100.*mm ) kwargs.setdefault("Vertex3DSigmaZ" , 1.*meter ) # configure tools for data reprocessing if muonRecFlags.enableErrorTuning(): # use alignment effects on track for all algorithms useAlignErrs = True if conddb.dbdata == 'COMP200' or conddb.dbmc == 'COMP200' or 'HLT' in globalflags.ConditionsTag() or conddb.isOnline or TriggerFlags.MuonSlice.doTrigMuonConfig: useAlignErrs = False kwargs.setdefault("MuonErrorOptimizer", getPublicToolClone("MuidErrorOptimisationTool", "MuonErrorOptimisationTool", PrepareForFit = False, RecreateStartingParameters = False, RefitTool = getPublicToolClone("MuidRefitTool", "MuonRefitTool", AlignmentErrors = useAlignErrs, Fitter = getPublicTool("iPatFitter")) )) if muonRecFlags.doSegmentT0Fit(): kwargs.setdefault("MdtRotCreator" , "" ) getPublicTool("MuonCaloParticleCreator") return CfgMgr.Rec__CombinedMuonTrackBuilder(name,**kwargs)
#-------------------------------------------------------------- # Load CondAlg, Tool and TestAlg #-------------------------------------------------------------- from AthenaCommon.AlgSequence import AthSequencer condSeq = AthSequencer("AthCondSeq") condAlgName = "SCT_CablingCondAlgFromCoraCool" if not hasattr(condSeq, condAlgName): from AthenaCommon.CfgGetter import getAlgorithm SCT_CablingCondAlgFromCoraCool = getAlgorithm(condAlgName) condSeq += SCT_CablingCondAlgFromCoraCool from AthenaCommon.CfgGetter import getPrivateTool SCT_CablingTool = getPrivateTool("SCT_CablingTool") SCT_CablingTool.DataSource = "COOLVECTOR" SCT_CablingTool.OutputLevel = INFO from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() from SCT_Cabling.SCT_CablingConf import SCT_TestCablingAlg topSequence += SCT_TestCablingAlg( SCT_CablingTool=SCT_CablingTool, OutputLevel=INFO, POSIXtime=ServiceMgr.EventSelector.InitialTimeStamp) if numThreads >= 2: from SCT_ConditionsAlgorithms.SCTCondAlgCardinality import sctCondAlgCardinality
DetFlags.Print() include("Digitization/Digitization.py") #-------------------------------------------------------------- #test the IPileUpTool call back mechanism #-------------------------------------------------------------- #this only works in XingByXing mode if digitizationFlags.doXingByXingPileUp(): job = AlgSequence() puAlg = job.StandardPileUpToolsAlg #puAlg = job.StandardInTimeOnlyTruthPileUpToolsAlg puAlg.OutputLevel = DEBUG from AthenaCommon.CfgGetter import getPrivateTool puAlg.PileUpTools += [ getPrivateTool("TestPileUpTool", tryDefaultConfigurable=True) ] puAlg.PileUpTools["TestPileUpTool"].OutputLevel = DEBUG #xing times in ns puAlg.PileUpTools["TestPileUpTool"].FirstXing = -300 puAlg.PileUpTools["TestPileUpTool"].LastXing = +300 #-------------------------------------------------------------- # Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL ) #-------------------------------------------------------------- from AthenaCommon.AppMgr import ServiceMgr ServiceMgr.MessageSvc.OutputLevel = INFO ServiceMgr.MessageSvc.setVerbose += ["PileUpStream"] pupElm = ServiceMgr.PileUpEventLoopMgr pupElm.OutputLevel = VERBOSE
def CalibCscStripFitter(name="CalibCscStripFitter", extraFlags=None, **kwargs): kwargs.setdefault("cscCalibTool", getPrivateTool("CscCalibTool")) return CfgMgr.CalibCscStripFitter(name, **kwargs)