def MdtCalibrationSvc(name="MdtCalibrationSvc", **kwargs): # call dependent tools. TODO: fix in C++ (move to ServiceHandle + declareProperty) from AthenaCommon.CfgGetter import getService getService("MdtCalibrationDbSvc") kwargs.setdefault("DoSlewingCorrection", mdtCalibFlags.correctMdtRtForTimeSlewing()) # Hack to use DoTemperatureCorrection for applyRtScaling; but applyRtScaling should not be used anyway, since MLRT can be used kwargs.setdefault("DoTemperatureCorrection", mdtCalibFlags.applyRtScaling()) kwargs.setdefault("DoWireSagCorrection", mdtCalibFlags.correctMdtRtWireSag()) if beamFlags.beamType() == 'collisions': kwargs.setdefault("DoTofCorrection", True) if globalflags.DataSource() == 'geant4': # for collisions cut away hits that are far outside of the MDT time window kwargs.setdefault("TimeWindowSetting", mdtCalibWindowNumber('Collision_G4')) elif globalflags.DataSource() == 'data': # for collisions cut away hits that are far outside of the MDT time window kwargs.setdefault("TimeWindowSetting", mdtCalibWindowNumber('Collision_G4')) else: # cosmics or single beam kwargs.setdefault("DoTofCorrection", False) return CfgMgr.MdtCalibrationSvc(name, **kwargs)
def MdtDriftCircleOnTrackCreator(name="MdtDriftCircleOnTrackCreator",**kwargs): # setup dependencies missing in C++. TODO: fix in C++ getService("MdtCalibrationSvc") getService("MdtCalibrationDbSvc") kwargs.setdefault("DoMagneticFieldCorrection", mdtCalibFlags.correctMdtRtForBField()) kwargs.setdefault("DoWireSag", muonRecFlags.useWireSagCorrections()) kwargs.setdefault("DoSlewingCorrection", mdtCalibFlags.correctMdtRtForTimeSlewing()) if beamFlags.beamType() == 'cosmics' or beamFlags.beamType() == 'singlebeam' : kwargs.setdefault("DoTofCorrection", False) kwargs.setdefault("DoFixedError", True) kwargs.setdefault("TimingMode", 1) kwargs.setdefault("UseParametrisedError", True) else: # collisions simulation/data settings kwargs.setdefault("DoTofCorrection", True) kwargs.setdefault("DoFixedError", False) kwargs.setdefault("DoErrorScaling", False) kwargs.setdefault("MuonTofTool", None) kwargs.setdefault("TimeWindowSetting", mdtCalibWindowNumber('Collision_data')) # MJW: should this be Collision_G4 ??? kwargs.setdefault("UseParametrisedError", False) if globalflags.DataSource() == 'data': # collisions real data or simulated first data kwargs.setdefault("CreateTubeHit", True) # BroadErrors kwargs.setdefault("UseLooseErrors", muonRecFlags.useLooseErrorTuning()) # LooseErrors on data if globalflags.DataSource() == 'data': kwargs.setdefault("IsMC", False) else: kwargs.setdefault("IsMC", True) return CfgMgr.Muon__MdtDriftCircleOnTrackCreator(name,**kwargs)
def MuonEDMHelperSvc(name='MuonEDMHelperSvc', **kwargs): # configure some tools that are used but are not declared as properties (they should be!) getService("MuonIdHelperSvc") getPublicTool("AtlasExtrapolator") from MuonRecHelperTools.MuonRecHelperToolsConf import Muon__MuonEDMHelperSvc return Muon__MuonEDMHelperSvc(name, **kwargs)
def getMuonSegmentToCalibSegment(): global topSequence, muonRecFlags try: return topSequence.MuonSegmentToCalibSegment except AttributeError: from MuonCalibPatRec.MuonCalibPatRecConf import MuonCalib__MuonSegmentToCalibSegment MuonSegmentToCalibSegment = MuonCalib__MuonSegmentToCalibSegment( "MuonSegmentToCalibSegment") # set consistent time-of-flight correction with MdtDriftCircleOnTrackCreator mdtCreator = getPublicTool("MdtDriftCircleOnTrackCreator") MuonSegmentToCalibSegment.DoTOF = getProperty(mdtCreator, "DoTofCorrection") # when doing segment fits with floating t0's MuonSegmentToCalibSegment.UpdateForT0Shift = type( MuonSegmentToCalibSegment.getDefaultProperty("UpdateForT0Shift"))( muonRecFlags.doSegmentT0Fit()) MuonSegmentToCalibSegment.UseCscSegments = False MuonSegmentToCalibSegment.SegmentLocations = ["MuonSegments"] MuonSegmentToCalibSegment.SegmentAuthors = [4, 8] MuonSegmentToCalibSegment.ReadSegments = True # rather than SegmentCombinations getService("MdtCalibrationSvc") # finally add it to topSequence topSequence += MuonSegmentToCalibSegment return topSequence.MuonSegmentToCalibSegment
def getMinBiasCache(name="MinBiasCache", **kwargs): from Digitization.DigitizationFlags import digitizationFlags from AthenaCommon.BeamFlags import jobproperties kwargs.setdefault('CollPerXing', (digitizationFlags.numberOfLowPtMinBias() + digitizationFlags.numberOfHighPtMinBias())) kwargs.setdefault('FractionOfCache1Collisions', (digitizationFlags.numberOfLowPtMinBias() / (digitizationFlags.numberOfLowPtMinBias() + digitizationFlags.numberOfHighPtMinBias()))) from Digitization import PileUpEventType kwargs.setdefault('PileUpEventType', PileUpEventType.MinimumBias ) # may need to have a separate type in the future if (digitizationFlags.doXingByXingPileUp() or digitizationFlags.SignalPatternForSteppingCache.statusOn): kwargs.setdefault('Cache1ReadDownscaleFactor', 1) kwargs.setdefault('Cache1EventSelector', getService('LowPtMinBiasEventSelector')) kwargs.setdefault('Cache2ReadDownscaleFactor', 1) kwargs.setdefault('Cache2EventSelector', getService('HighPtMinBiasEventSelector')) kwargs.setdefault( 'OccupationFraction', float(digitizationFlags.bunchSpacing.get_Value()) / float(jobproperties.Beam.bunchSpacing.get_Value())) kwargs.setdefault('RndmGenSvc', digitizationFlags.rndmSvc()) kwargs.setdefault('RndmStreamName', "PileUpCollXingStream") return CfgMgr.SplitBkgStreamsCache(name, **kwargs)
def getFatrasMaterialEffectsEngine(name="ISF_FatrasMaterialEffectsEngine", **kwargs): from G4AtlasApps.SimFlags import simFlags kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() ) kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName()) kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc')) kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName()) kwargs.setdefault("ProcessSamplingTool" , getPublicTool('ISF_FatrasProcessSamplingTool')) kwargs.setdefault("ParticleDecayHelper" , getPublicTool('ISF_FatrasParticleDecayHelper')) # energy loss kwargs.setdefault("EnergyLoss" , True) kwargs.setdefault("EnergyLossSampler" , getPublicTool('ISF_FatrasEnergyLossUpdator')) kwargs.setdefault("UseElectronSampler" , True) kwargs.setdefault("ElectronEnergyLossSampler" , getPublicTool('ISF_FatrasEnergyLossSamplerBetheHeitler')) kwargs.setdefault("CreateBremPhotons" , True) # multiple scattering kwargs.setdefault("MultipleScattering" , True) kwargs.setdefault("MultipleScatteringSampler" , getPublicTool('ISF_FatrasMultipleScatteringSamplerHighland')) # the properties given throuth the JobProperties interface kwargs.setdefault("MomentumCut" , FatrasTuningFlags.MomCutOffSec()) kwargs.setdefault("MinimumBremPhotonMomentum" , FatrasTuningFlags.MomCutOffSec()) # MCTruth Process Code kwargs.setdefault("BremProcessCode" , 3) # TODO: to be taken from central definition # the validation output kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode()) kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool')) kwargs.setdefault("OutputPrefix", '[McME] - ') kwargs.setdefault("OutputPostfix", ' - ') kwargs.setdefault("OutputLevel", ISF_FatrasFlags.OutputLevelGeneral()) from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__McMaterialEffectsEngine return iFatras__McMaterialEffectsEngine(name, **kwargs )
def MuidMaterialAllocator( name='MuidMaterialAllocator', **kwargs): kwargs.setdefault("AggregateMaterial",True) kwargs.setdefault("AllowReordering",False) kwargs.setdefault("Extrapolator", getPublicTool('AtlasExtrapolator') ) kwargs.setdefault("SpectrometerExtrapolator", getPublicTool('AtlasExtrapolator')) kwargs.setdefault("TrackingGeometrySvc", getService("AtlasTrackingGeometrySvc") ) return CfgMgr.Trk__MaterialAllocator(name,**kwargs)
def getNativeFastCaloSimSvc(name="ISF_NativeFastCaloSimSvc", **kwargs): from ISF_FastCaloSimParametrization.ISF_NativeFastCaloSimJobProperties import ISF_NativeFastCaloSimFlags kwargs.setdefault("BatchProcessMcTruth", False) kwargs.setdefault("SimulateUndefinedBarcodeParticles", False) kwargs.setdefault("Identifier", 'NativeFastCaloSim') kwargs.setdefault("CaloCellsOutputName", ISF_NativeFastCaloSimFlags.CaloCellsName()) kwargs.setdefault("PunchThroughTool", getPublicTool('ISF_PunchThroughTool')) kwargs.setdefault("DoPunchThroughSimulation", False) kwargs.setdefault("ParticleBroker", getService('ISF_ParticleBrokerSvc')) kwargs.setdefault("CaloCellMakerTools_setup", [ getPublicTool('ISF_EmptyCellBuilderTool'), ]) kwargs.setdefault( "CaloCellMakerTools_release", [ #getPublicTool('ISF_AddNoiseCellBuilderTool'), getPublicTool('ISF_CaloCellContainerFinalizerTool'), getPublicTool('ISF_FastHitConvertTool') ]) # let the ISF FCS flags know that FCS is being used ISF_NativeFastCaloSimFlags.NativeFastCaloSimIsActive.set_Value_and_Lock( True) # register the FastCaloSim random number streams from G4AtlasApps.SimFlags import SimFlags, simFlags simFlags.RandomSeedList.addSeed( ISF_NativeFastCaloSimFlags.RandomStreamName(), 98346412, 12461240) from ISF_FastCaloSimParametrization.ISF_FastCaloSimParametrizationConf import ISF__NativeFastCaloSimSvc return ISF__NativeFastCaloSimSvc(name, **kwargs)
def __init__(self): from AthenaCommon import Logging from AthenaCommon.CfgGetter import getService self.systemActions = [] self.log = Logging.logging.getLogger('G4UAStore') from AthenaCommon.AppMgr import ServiceMgr ##hack to allow for different named Configurations of the UserActionSvc basename = 'UserActionSvc' serviceName = '' for s in ServiceMgr.getAllChildren(): if basename in s.getName(): serviceName = s.getName() break if '' == serviceName: self.log.error('G4AtlasUAStore: Could not find ' + basename + ' instance in ServiceMgr!') raise AttributeError('G4AtlasUAStore: Could not find ' + basename + ' instance in ServiceMgr!') else: self.log.info('G4AtlasUAStore: Found a ' + basename + ' instance called ' + serviceName) self.theSvc = getService(serviceName) # map roles to attributes self.roleMap = { 'BeginOfRun': 'BeginOfRunActions', 'EndOfRun': 'EndOfRunActions', 'BeginOfEvent': 'BeginOfEventActions', 'EndOfEvent': 'EndOfEventActions', 'BeginOfTracking': 'PreTrackingActions', 'EndOfTracking': 'PostTrackingActions', 'Step': 'SteppingActions', 'Classification': 'StackingActionsClassification', 'PrepareNewEvent': 'StackingActionsPrepareNewEvent', 'NewStage': 'StackingActionsNewStage' }
def getCavernCache(name="CavernCache", **kwargs): from Digitization.DigitizationFlags import digitizationFlags from AthenaCommon.BeamFlags import jobproperties kwargs.setdefault('CollPerXing', digitizationFlags.numberOfCavern()) kwargs.setdefault('CollDistribution', "Fixed") from Digitization import PileUpEventType kwargs.setdefault('PileUpEventType', PileUpEventType.Cavern) if (digitizationFlags.doXingByXingPileUp() or digitizationFlags.SignalPatternForSteppingCache.statusOn): kwargs.setdefault('ReadDownscaleFactor', 1) # Cavern Background Cache Should Ignore Bunch Structure OccupationFraction = float( digitizationFlags.bunchSpacing.get_Value()) / float( jobproperties.Beam.bunchSpacing.get_Value()) if digitizationFlags.BeamIntensityPattern.statusOn: kwargs.setdefault('IgnoreBeamInt', digitizationFlags.cavernIgnoresBeamInt.get_Value()) if digitizationFlags.cavernIgnoresBeamInt.get_Value(): OccupationFraction = 1.0 kwargs.setdefault('OccupationFraction', OccupationFraction) kwargs.setdefault('EventSelector', getService('cavernEventSelector')) kwargs.setdefault('RndmGenSvc', digitizationFlags.rndmSvc()) kwargs.setdefault('RndmStreamName', "PileUpCollXingStream") #Use BkgStreamsStepCaches when using the StepArrayBM and BkgStreamsCache otherwise if digitizationFlags.SignalPatternForSteppingCache.statusOn: return CfgMgr.BkgStreamsStepCache(name, **kwargs) else: return CfgMgr.BkgStreamsCache(name, **kwargs)
def MuonTrackSummaryHelper(name="MuonTrackSummaryHelper",**kwargs): AtlasTrackingGeometrySvc = getService("AtlasTrackingGeometrySvc") kwargs.setdefault("TrackingGeometryName", AtlasTrackingGeometrySvc.TrackingGeometryName) kwargs.setdefault("DoHolesOnTrack", False) kwargs.setdefault("CalculateCloseHits", True) from MuonTrackSummaryHelperTool.MuonTrackSummaryHelperToolConf import Muon__MuonTrackSummaryHelperTool return Muon__MuonTrackSummaryHelperTool(name,**kwargs)
def getPunchThroughTool(name="ISF_PunchThroughTool", **kwargs): from G4AtlasApps.SimFlags import SimFlags,simFlags kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() ) kwargs.setdefault("RandomStreamName" , ISF_FastCaloSimFlags.RandomStreamName() ) kwargs.setdefault("FilenameLookupTable" , "CaloPunchThroughParametrisation.root" ) kwargs.setdefault("PunchThroughInitiators" , [ 211 ] ) kwargs.setdefault("PunchThroughParticles" , [ 2212, 211, 22, 11, 13 ] ) kwargs.setdefault("DoAntiParticles" , [ False, True, False, True, True ] ) kwargs.setdefault("CorrelatedParticle" , [ 211, 2212, 11, 22, 0 ] ) kwargs.setdefault("FullCorrelationEnergy" , [ 100000., 100000., 100000., 100000., 0. ] ) kwargs.setdefault("MinEnergy" , [ 938.3, 135.6, 50., 50., 105.7 ] ) kwargs.setdefault("MaxNumParticles" , [ -1, -1, -1, -1, -1 ] ) kwargs.setdefault("EnergyFactor" , [ 1., 1., 1., 1., 1. ] ) kwargs.setdefault("BarcodeSvc" , getService('ISF_LegacyBarcodeService') ) kwargs.setdefault("EnvelopeDefSvc" , getService('AtlasGeometry_EnvelopeDefSvc') ) kwargs.setdefault("BeamPipeRadius" , 500. ) from ISF_PunchThroughTools.ISF_PunchThroughToolsConf import ISF__PunchThroughTool return ISF__PunchThroughTool(name, **kwargs )
def getParametricSimServiceID(name="ISF_ParametricSimSvc", **kwargs): kwargs.setdefault("Identifier", "ParametricSim") kwargs.setdefault("OutputLevel", ISF_ParSimFlags.OutputLevelGeneral()) kwargs.setdefault("ParticleSmearers", [getPublicTool('ISF_TrackParticleSmearer')]) kwargs.setdefault("TrackingGeometrySvc", getService("AtlasTrackingGeometrySvc")) from ISF_ParSimServices.ISF_ParSimServicesConf import iParSim__ParametricSimSvc return iParSim__ParametricSimSvc(name, **kwargs)
def CaloMuonScoreTool(name='CaloMuonScoreTool', **kwargs): from TrackToCalo.TrackToCaloConf import Rec__ParticleCaloCellAssociationTool caloCellAssociationTool = Rec__ParticleCaloCellAssociationTool( ParticleCaloExtensionTool=getPublicTool( "MuonParticleCaloExtensionTool")) kwargs.setdefault("ParticleCaloCellAssociationTool", caloCellAssociationTool) kwargs.setdefault("CaloMuonScoreONNXRuntimeSvc", getService("CaloMuonScoreONNXRuntimeSvc")) return CfgMgr.CaloMuonScoreTool(name, **kwargs)
def getCaloEntryTrkExtrapolator(name="ISF_CaloEntryTrkExtrapolator", **kwargs): kwargs.setdefault('TrackingVolumeName', 'InDet::Containers::EntryVolume') kwargs.setdefault('TrackingGeometrySvc', getService('AtlasTrackingGeometrySvc')) atlasExtrapolator = getPublicTool('AtlasExtrapolator') atlasExtrapolator.ApplyMaterialEffects = False kwargs.setdefault('Extrapolator', atlasExtrapolator) from ISF_TrackingTools.ISF_TrackingToolsConf import ISF__TrkExtrapolator return ISF__TrkExtrapolator(name, **kwargs)
def _do_external(self): """ Place to handle the external services: GeoModel, CondDB, etc. """ AtlasG4Eng.G4Eng.log.info('SimSkeleton :: _do_external '+\ 'starting') #from LArH6Detectors import Det_Layouts from tbLArH6_calo import Det_Layouts from AthenaCommon.AppMgr import ServiceMgr from Geo2G4.Geo2G4Conf import Geo2G4Svc Geo2G4Svc = Geo2G4Svc() theApp.CreateSvc += ["Geo2G4Svc"] ServiceMgr += Geo2G4Svc # We do not use top transforms for the CTB geometry Geo2G4Svc.GetTopTransform = False #--- GeoModel stuff ---------------------------------------------------- from AtlasGeoModel import SetGeometryVersion from AtlasGeoModel import GeoModelInit from AthenaCommon.Configurable import Configurable if Configurable.allConfigurables.get('GeoModelSvc'): GeoModelSvc = Configurable.allConfigurables.get('GeoModelSvc') else: GeoModelSvc = theApp.service('GeoModelSvc') GeoModelSvc.AlignCallbacks = False if (DetFlags.Calo_on()): # Common for the Calo include( "CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py") include("CaloIdCnv/CaloIdCnv_joboptions.py") ## Explicitly create DetectorGeometrySvc - temporary fix from AthenaCommon.CfgGetter import getService from AthenaCommon.AppMgr import ServiceMgr ServiceMgr += getService('DetectorGeometrySvc') ServiceMgr += getService('PhysicsListSvc') AtlasG4Eng.G4Eng.log.info('SimSkeleton :: _do_external '+\ 'done')
def MdtPrepDataProviderTool(name="MdtPrepDataProviderTool", **kwargs): global source, include, getService # setup dependencies which are not yet in C++ import MuonCnvExample.MuonCablingConfig getService("MdtCalibrationSvc") include("AmdcAth/AmdcAth_jobOptions.py") # If we run trigger from BS, then the RDO to PRD tools need to automatically run BS to RDO tools kwargs.setdefault("useBStoRdoTool", DetFlags.readRDOBS.MDT_on() and recAlgs.doTrigger()) kwargs.setdefault("RawDataProviderTool", "MdtRawDataProviderTool") ### TODO: in C++ do not retrieve tool if useBStoRdoTool==False ## if not kwargs["useBStoRdoTool"]: ## kwargs["RawDataProviderTool"] = None # empty tool if source == 'data': kwargs.setdefault("UseTwin", True) from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataTool return Muon__MdtRdoToPrepDataTool(name, **kwargs)
def getFatrasG4HadIntProcessor(name="ISF_FatrasG4HadIntProcessor", **kwargs): from G4AtlasApps.SimFlags import simFlags kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() ) kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName()) kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc')) kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName()) kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool')) kwargs.setdefault('ValidationMode' , ISF_Flags.ValidationMode()) kwargs.setdefault("MomentumCut" , FatrasTuningFlags.MomCutOffSec()) from ISF_FatrasToolsG4.ISF_FatrasToolsG4Conf import iFatras__G4HadIntProcessor return iFatras__G4HadIntProcessor(name, **kwargs )
def BasicPixelDigitizationTool(name="PixelDigitizationTool", **kwargs): from AthenaCommon import CfgGetter kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) streamName = kwargs.setdefault("RndmEngine", "PixelDigitization") if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName): digitizationFlags.rndmSeedList.addSeed(streamName, 10513239, 492615104 ) from AthenaCommon.BeamFlags import jobproperties from AthenaCommon.Resilience import protectedInclude from AthenaCommon.Include import include from AthenaCommon.AppMgr import ServiceMgr from AthenaCommon.CfgGetter import getService protectedInclude( "PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py" ) include.block( "PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py" ) protectedInclude( "PixelConditionsServices/PixelDCSSvc_jobOptions.py" ) include.block( "PixelConditionsServices/PixelDCSSvc_jobOptions.py" ) protectedInclude("PixelConditionsServices/PixelCalibSvc_jobOptions.py") from IOVDbSvc.CondDB import conddb conddb.addFolderSplitMC("PIXEL","/PIXEL/ReadoutSpeed","/PIXEL/ReadoutSpeed") PixelCablingSvc = getService("PixelCablingSvc") ServiceMgr += PixelCablingSvc print PixelCablingSvc if not hasattr(ServiceMgr, "PixelSiPropertiesSvc"): from SiLorentzAngleSvc.LorentzAngleSvcSetup import lorentzAngleSvc from SiPropertiesSvc.SiPropertiesSvcConf import SiPropertiesSvc pixelSiPropertiesSvc = SiPropertiesSvc(name = "PixelSiPropertiesSvc",DetectorName="Pixel",SiConditionsServices = lorentzAngleSvc.pixelSiliconConditionsSvc) ServiceMgr += pixelSiPropertiesSvc kwargs.setdefault("InputObjectName", "PixelHits") procTools = [] chargeTools = [] #Tools in array for flexibility feSimTools = [] if GeometryFlags.isSLHC(): procTools += ['PixelRadDamDiodeCrossTalkGenerator'] chargeTools += ['RadDamSensorSimPlanarTool'] feSimTools += ['RadDamRD53SimTool'] else: procTools += ['PixelRadDamDiodeCrossTalkGenerator'] procTools += ['PixelRadDamChargeSmearer'] procTools += ['PixelRadDamNoisyCellGenerator'] procTools += ['PixelRadDamRandomDisabledCellGenerator'] chargeTools += ['RadDamSensorSimPlanarTool'] chargeTools += ['RadDamSensorSim3DTool'] feSimTools += ['RadDamFEI4SimTool'] feSimTools += ['RadDamFEI3SimTool'] kwargs.setdefault("PixelProcessorTools", procTools) kwargs.setdefault("ChargeTools", chargeTools) kwargs.setdefault("FrontEndSimTools", feSimTools) kwargs.setdefault("EnergyDepositionTool", "RadDamEnergyDepositionTool") if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", Pixel_FirstXing() ) kwargs.setdefault("LastXing", Pixel_LastXing() ) return CfgMgr.RadDam__PixelDigitizationTool(name, **kwargs)
def addAction(actionTool, roles, systemAction=False): """ Add an action tool to the list for a requested role. This should only be used in very special cases, by experts. Normally, you should use the getter for one of the specialized UASvc versions listed above to add an action. If systemAction=True, the action is prepended to the list. Otherwise, it is appended. """ from AthenaCommon.AppMgr import theApp, AthAppMgr, ServiceMgr roleMap={'Run': 'RunActionTools', 'Event': 'EventActionTools', 'Tracking': 'TrackingActionTools', 'Step': 'SteppingActionTools', 'Stack': 'StackingActionTools'} ##hack to allow for different named Configurations of the UserActionSvc basename='UserActionSvc' serviceName='' for s in ServiceMgr.getAllChildren(): if basename in s.getName(): serviceName = s.getName() break if ''==serviceName: Logging.logging.getLogger('G4UASvc').error('addAction: Could not find ' + basename + ' instance in ServiceMgr!') raise AttributeError('addAction: Could not find ' + basename + ' instance in ServiceMgr!') else: Logging.logging.getLogger('G4UASvc').info('addAction: Found a ' + basename + ' instance called ' + serviceName) from AthenaCommon.CfgGetter import getService theSvc=getService(serviceName) if theApp.state() > AthAppMgr.State.CONFIGURED: Logging.logging.getLogger('G4UASvc').fatal('Attempt to add a User Action when athena is ' + 'already initialized. Check your configuration') return for role in roles: roleAttr = roleMap[role] if not role in roleMap.keys(): Logging.logging.getLogger('G4UASvc').fatal('Unkown role '+role+' requested for action ') else: currentActionList = getattr(theSvc, roleAttr) if not actionTool in currentActionList: # Add to beginning of list if system, otherwise the end if systemAction: setattr(theSvc, roleAttr, [actionTool] + currentActionList) else: setattr(theSvc, roleAttr, currentActionList + [actionTool])
def getFatrasConversionCreator(name="ISF_FatrasConversionCreator", **kwargs): # Fatras Hadronic Interaction Processor # hadronic interaction creator from G4AtlasApps.SimFlags import simFlags kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() ) kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName()) kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc')) kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName()) kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool')) kwargs.setdefault("PhysicsProcessCode" , 14) # TODO: to be taken from central definition kwargs.setdefault('ValidationMode' , ISF_Flags.ValidationMode()) from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__PhotonConversionTool return iFatras__PhotonConversionTool(name, **kwargs )
def getFatrasParticleDecayHelper(name="ISF_FatrasParticleDecayHelper", **kwargs): from G4AtlasApps.SimFlags import simFlags if not simFlags.RandomSeedList.checkForExistingSeed( "FatrasG4" ): simFlags.RandomSeedList.addSeed( "FatrasG4" , 23491234, 23470291 ) kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() ) kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName()) kwargs.setdefault("G4RandomStreamName" , "FatrasG4") # TODO: read stream name "FatrasG4" from Fatras jobProperties kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc')) kwargs.setdefault("ParticleTruthSvc", simFlags.TruthStrategy.TruthServiceName()) kwargs.setdefault("PDGToG4ParticleConverter", getPublicTool('ISF_FatrasPdgG4Particle')) # the validation output kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode()) kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool')) #kwargs.setdefault("G4RunManagerHelper" , getPublicTool('ISF_G4RunManagerHelper')) from ISF_FatrasToolsG4.ISF_FatrasToolsG4Conf import iFatras__G4ParticleDecayHelper return iFatras__G4ParticleDecayHelper(name, **kwargs )
def getHighPtMinBiasCache(name="HighPtMinBiasCache", **kwargs): from Digitization.DigitizationFlags import digitizationFlags from AthenaCommon.BeamFlags import beamFlags kwargs.setdefault('CollPerXing', digitizationFlags.numberOfHighPtMinBias() ) from Digitization import PileUpEventType kwargs.setdefault('PileUpEventType', PileUpEventType.HighPtMinimumBias ) # may need to have a separate type in the future kwargs.setdefault('ReadDownscaleFactor', 1 ) kwargs.setdefault('EventSelector', getService('HighPtMinBiasEventSelector') ) kwargs.setdefault('OccupationFraction', float(digitizationFlags.bunchSpacing.get_Value())/float(beamFlags.bunchSpacing.get_Value()) ) kwargs.setdefault('RndmGenSvc', digitizationFlags.rndmSvc() ) kwargs.setdefault('RndmStreamName', "PileUpCollXingStream" ) #Use BkgStreamsStepCaches when using the StepArrayBM and BkgStreamsCache otherwise if digitizationFlags.SignalPatternForSteppingCache.statusOn: return CfgMgr.BkgStreamsStepCache(name, **kwargs) else: return CfgMgr.BkgStreamsCache(name, **kwargs)
def getFatrasParametricHadIntProcessor(name="ISF_FatrasParametricHadIntProcessor", **kwargs): from G4AtlasApps.SimFlags import simFlags # Fatras Hadronic Interaction Processor # hadronic interaction creator kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() ) kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName()) kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc')) kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName()) kwargs.setdefault("HadronicInteractionScaleFactor" , FatrasTuningFlags.HadronicInteractionProbabilityScalor()) kwargs.setdefault("MinimumHadronicInitialEnergy" , FatrasTuningFlags.MomCutOffSec()) kwargs.setdefault("MinimumHadronicOutEnergy" , FatrasTuningFlags.MomCutOffSec()) kwargs.setdefault("HadronicInteractionValidation" , False) kwargs.setdefault("PhysicsProcessCode" , 121) # TODO: to be taken from central definition kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool')) kwargs.setdefault('ValidationMode' , ISF_Flags.ValidationMode()) from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__HadIntProcessorParametric return iFatras__HadIntProcessorParametric(name, **kwargs )
def MuonCombinedTrackFitter( name="MuonCombinedTrackFitter", **kwargs ): kwargs.setdefault("ExtrapolationTool" , getPublicTool("AtlasExtrapolator") ) kwargs.setdefault("NavigatorTool" , getPublicTool("MuonNavigator") ) kwargs.setdefault("PropagatorTool" , getPublicTool("MuonCombinedPropagator") ) kwargs.setdefault("RotCreatorTool" , getPublicTool("MuonRotCreator") ) kwargs.setdefault("MeasurementUpdateTool" , getPublicTool("MuonMeasUpdator") ) kwargs.setdefault("TrackingGeometrySvc" , getService("AtlasTrackingGeometrySvc") ) kwargs.setdefault("ExtrapolatorMaterial" , True ) kwargs.setdefault("MuidTool" , getPublicTool("MuidMaterialEffectsOnTrackProvider") ) kwargs.setdefault("MuidToolParam" , None ) if jobproperties.Beam.beamType()=='collisions': kwargs.setdefault("MuidToolParam" , getPublicTool("MuidMaterialEffectsOnTrackProviderParam" ) ) kwargs.setdefault("MuidMat" , True ) kwargs.setdefault("StraightLine" , not jobproperties.BField.solenoidOn() and not jobproperties.BField.allToroidOn() ) kwargs.setdefault("MaxIterations" , 50 ) kwargs.setdefault("GetMaterialFromTrack" , jobproperties.BField.solenoidOn() and jobproperties.BField.allToroidOn() ) kwargs.setdefault("RecalculateDerivatives", False) kwargs.setdefault("UseCaloTG" , True) # return CfgMgr.Trk__GlobalChi2Fitter(name,**kwargs)
def getFatrasMaterialUpdator(name="ISF_FatrasMaterialUpdator", **kwargs): from G4AtlasApps.SimFlags import simFlags from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() ) kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName()) kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc')) kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName()) # hadronic interactions kwargs.setdefault("HadronicInteraction" , True) #kwargs.setdefault("HadronicInteractionProcessor", getPublicTool('ISF_FatrasParametricHadIntProcessor')) kwargs.setdefault("HadronicInteractionProcessor", getPublicTool('ISF_FatrasG4HadIntProcessor')) # enrgy loss kwargs.setdefault("EnergyLoss" , True) kwargs.setdefault("EnergyLossUpdator" , getPublicTool('ISF_FatrasEnergyLossUpdator')) # mutiple scattering kwargs.setdefault("MultipleScattering" , True) kwargs.setdefault("MultipleScatteringUpdator" , getPublicTool('ISF_FatrasMultipleScatteringUpdator')) # photon conversion kwargs.setdefault("PhotonConversionTool" , getPublicTool('ISF_FatrasConversionCreator')) # the validation output kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode()) kwargs.setdefault("BremPhotonValidation" , False) kwargs.setdefault("EnergyDepositValidation" , False) # the properties given throuth the JobProperties interface kwargs.setdefault("MomentumCut" , FatrasTuningFlags.MomCutOffSec()) kwargs.setdefault("MinimumBremPhotonMomentum" , FatrasTuningFlags.MomCutOffSec()) # kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool')) kwargs.setdefault("ProcessSamplingTool" , getPublicTool('ISF_FatrasProcessSamplingTool')) kwargs.setdefault("ParticleDecayHelper" , getPublicTool('ISF_FatrasParticleDecayHelper')) # MCTruth Process Code kwargs.setdefault("BremProcessCode" , 3) # TODO: to be taken from central definition kwargs.setdefault("TrackingGeometrySvc" , AtlasTrackingGeometrySvc) from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__McMaterialEffectsUpdator return iFatras__McMaterialEffectsUpdator(name, **kwargs )
# block include this file, many package will want to setup cabling include.block('InDetRecExample/InDetRecCabling.py') from InDetRecExample.InDetJobProperties import InDetFlags if not ('conddb' in dir()): IOVDbSvc = Service("IOVDbSvc") from IOVDbSvc.CondDB import conddb # # --- Pixel cabling # if DetFlags.detdescr.pixel_on() and not 'PixelCabling' in dir(): from AthenaCommon.CfgGetter import getService PixelCablingSvc = getService("PixelCablingSvc") ServiceMgr += PixelCablingSvc if (InDetFlags.doPrintConfigurables()): print PixelCablingSvc # # --- SCT cabling # if DetFlags.detdescr.SCT_on() and not 'SCT_CablingSvc' in dir(): SCTCablingDataSource = 'CORACOOL' SCTConfigurationFolderPath = '/SCT/DAQ/Config/' #if its COMP200, use old folders... if (conddb.dbdata == "COMP200"): SCTConfigurationFolderPath = '/SCT/DAQ/Configuration/' #...but now check if we want to override that decision with explicit flag (if there is one) try: if InDetFlags.ForceCoraCool():
import re if re.match("DC1|DC2|Rome|ATLAS-DC3-01|ATLAS-DC3-02", globalflags.DetDescrVersion()): topSequence.TrackRecordFilter.inputName = "MuonEntryRecord" if muonRecFlags.writeMuonExitLayer(): topSequence += TrackRecordFilter("TrackRecordFilterMuonExitLayer", inputName="MuonExitLayer", outputName="MuonExitLayerFilter") # only do PRD truth if PRD's are being made if rec.doTruth() and DetFlags.makeRIO.Muon_on(): from MuonTruthAlgs.MuonTruthAlgsConf import MuonPRD_MultiTruthMaker topSequence += MuonPRD_MultiTruthMaker() from AthenaCommon.CfgGetter import getService getService("AtlasTrackingGeometrySvc") from MuonTruthAlgs.MuonTruthAlgsConf import Muon__MuonTruthDecorationAlg topSequence += Muon__MuonTruthDecorationAlg("MuonTruthDecorationAlg") from AthenaCommon import CfgGetter topSequence.MuonTruthDecorationAlg.MCTruthClassifier = CfgGetter.getPublicTool( "MCTruthClassifier") try: from RecExConfig.InputFilePeeker import inputFileSummary truthStrategy = inputFileSummary['metadata']['/Simulation/Parameters'][ 'TruthStrategy'] if truthStrategy in ['MC15', 'MC18', 'MC18LLP']: topSequence.MuonTruthDecorationAlg.BarcodeOffset = 10000000 except: print "Failed to read /Simulation/Parameters/ metadata" pass
######################################################### # # SimulationJobOptions/postInitOptions.SCTCuts5.py # Pat Ward - adapted from postInitOptions.PixelCuts5.py by Zach Marshall # # For a special production to evaluate the effect of low # energy secondaries on SCT Clustering. # ######################################################### atlasG4log.info("G4 SCT Config: Setting SCT cut") from AthenaCommon.CfgGetter import getService sctRegionTool = getService( 'DetectorGeometrySvc').RegionCreators['SCTPhysicsRegionTool'] sctRegionTool.ElectronCut = 0.005 sctRegionTool.PositronCut = 0.005 sctRegionTool.GammaCut = 0.005
######################################################### # # SimulationJobOptions/postInitOptions.PixelCuts100.py # Zach Marshall # # For a special production to evaluate the effect of low # energy secondaries on Pixel Clustering. # ######################################################### atlasG4log.info("G4 PIX Config: Setting PIX cut") from AthenaCommon.CfgGetter import getService pixelRegionTool = getService( 'DetectorGeometrySvc').RegionCreators['PixelPhysicsRegionTool'] pixelRegionTool.ElectronCut = 0.1 pixelRegionTool.PositronCut = 0.1 pixelRegionTool.GammaCut = 0.1
# block include this file, many package will want to setup cabling include.block ('InDetRecExample/InDetRecCabling.py') from InDetRecExample.InDetJobProperties import InDetFlags if not ('conddb' in dir()): IOVDbSvc = Service("IOVDbSvc") from IOVDbSvc.CondDB import conddb # # --- Pixel cabling # if DetFlags.detdescr.pixel_on() and not 'PixelCabling' in dir(): from AthenaCommon.CfgGetter import getService PixelCablingSvc = getService("PixelCablingSvc") ServiceMgr += PixelCablingSvc if (InDetFlags.doPrintConfigurables()): print PixelCablingSvc # # --- SCT cabling # if DetFlags.detdescr.SCT_on() and not 'SCT_CablingSvc' in dir(): SCTCablingDataSource='CORACOOL' SCTConfigurationFolderPath='/SCT/DAQ/Config/' #if its COMP200, use old folders... if (conddb.dbdata == "COMP200"): SCTConfigurationFolderPath='/SCT/DAQ/Configuration/' #...but now check if we want to override that decision with explicit flag (if there is one) try: if InDetFlags.ForceCoraCool():