def commonSCT_DigitizationConfig(name, **kwargs): from Digitization.DigitizationFlags import digitizationFlags # If noise is turned off: if not digitizationFlags.doInDetNoise.get_Value(): kwargs.setdefault("OnlyHitElements", True) kwargs.setdefault("InputObjectName", "SCT_Hits") kwargs.setdefault("EnableHits", True) kwargs.setdefault("BarrelOnly", False) # Use of random disabled cells #kwargs.setdefault("RandomDisabledCells", True) # Set FixedTime for cosmics for use in SurfaceChargesGenerator from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == "cosmics": kwargs.setdefault("CosmicsRun", True) kwargs.setdefault("FixedTime", 10) # write out SCT1_RawData #kwargs.setdefault("WriteSCT1_RawData", False) if digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", SCT_FirstXing()) kwargs.setdefault("LastXing", SCT_LastXing()) from AthenaCommon import CfgMgr return CfgMgr.SCT_DigitizationTool(name, **kwargs)
def commonSCT_FastDigitizationConfig(name, **kwargs): # Setup the DCS folders and Svc used in the sctSiliconConditionsSvc from IOVDbSvc.CondDB import conddb if not conddb.folderRequested('/SCT/DCS/CHANSTAT'): conddb.addFolder("DCS_OFL", "/SCT/DCS/CHANSTAT") if not conddb.folderRequested('/SCT/DCS/MODTEMP'): conddb.addFolder("DCS_OFL", "/SCT/DCS/MODTEMP") if not conddb.folderRequested('/SCT/DCS/HV'): conddb.addFolder("DCS_OFL", "/SCT/DCS/HV") from AthenaCommon.AppMgr import ServiceMgr if not hasattr(ServiceMgr, "InDetSCT_DCSConditionsSvc"): from SCT_ConditionsServices.SCT_ConditionsServicesConf import SCT_DCSConditionsSvc InDetSCT_DCSConditionsSvc = SCT_DCSConditionsSvc( name="InDetSCT_DCSConditionsSvc") ServiceMgr += InDetSCT_DCSConditionsSvc kwargs.setdefault("ClusterMaker", "FastClusterMakerTool") # Import Digitization job properties from Digitization.DigitizationFlags import digitizationFlags # set the random service, stream name streamName = kwargs.setdefault("RndmEngine", "FastSCT_Digitization") kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) # set rndm seeds if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName): digitizationFlags.rndmSeedList.addSeed(streamName, 49261510, 105132394) if digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", FastSCT_FirstXing()) kwargs.setdefault("LastXing", FastSCT_LastXing()) from AthenaCommon import CfgMgr return CfgMgr.SCT_FastDigitizationTool(name, **kwargs)
def BCM_DigitizationTool(name="BCM_DigitizationTool", **kwargs): from Digitization.DigitizationFlags import digitizationFlags kwargs.setdefault("HitCollName", "BCMHits") if not digitizationFlags.doInDetNoise.get_Value(): kwargs.setdefault("ModNoise", [0., 0., 0., 0., 0., 0., 0., 0.]) else: kwargs.setdefault( "ModNoise", [90.82, 90.82, 90.82, 90.82, 90.82, 90.82, 90.82, 90.82]) kwargs.setdefault("ModSignal", [450.0, 450.0, 450.0, 450.0, 450.0, 450.0, 450.0, 450.0]) kwargs.setdefault("NinoThr", [330.0, 330.0, 330.0, 330.0, 330.0, 330.0, 330.0, 330.0]) kwargs.setdefault("EffDistanceParam", 4.0) kwargs.setdefault("EffSharpnessParam", 0.11) kwargs.setdefault("TimeDelay", 9.0) kwargs.setdefault("MIPDeposit", 0.33) # BCM with diamond #kwargs.setdefault("MIPDeposit", 0.25) # BCM with graphite kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) digitizationFlags.rndmSeedList.addSeed("BCM_Digitization", 49261510, 105132394) if digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", BCM_FirstXing()) kwargs.setdefault("LastXing", BCM_LastXing()) from AthenaCommon import CfgMgr return CfgMgr.BCM_DigitizationTool(name, **kwargs)
def commonPixelFastDigitizationConfig(name,**kwargs): kwargs.setdefault("ClusterMaker", "FastClusterMakerTool") # Import Digitization job properties from Digitization.DigitizationFlags import digitizationFlags # set the random service, stream name streamName = kwargs.setdefault("RndmEngine", "FastPixelDigitization") kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc() ) # set rndm seeds if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName): digitizationFlags.rndmSeedList.addSeed(streamName, 10513239, 492615104 ) if digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", FastPixel_FirstXing()) kwargs.setdefault("LastXing", FastPixel_LastXing() ) # SiLorentzAngleTool for PixelFastDigitizationTool from AthenaCommon.AppMgr import ToolSvc if not hasattr(ToolSvc, "PixelLorentzAngleTool"): from SiLorentzAngleTool.PixelLorentzAngleToolSetup import PixelLorentzAngleToolSetup pixelLorentzAngleToolSetup = PixelLorentzAngleToolSetup() kwargs.setdefault("LorentzAngleTool", ToolSvc.PixelLorentzAngleTool) from AthenaCommon import CfgMgr return CfgMgr.PixelFastDigitizationTool(name,**kwargs)
def getStandardPileUpToolsAlg(name="StandardPileUpToolsAlg", **kwargs): kwargs.setdefault('PileUpTools', getStandardPileUpToolsList() ) from Digitization.DigitizationFlags import digitizationFlags if digitizationFlags.doXingByXingPileUp(): return CfgMgr.PileUpToolsAlg(name, **kwargs) else: return CfgMgr.DigitizationAlg(name, **kwargs)
def commonSCT_DigitizationConfig(name, **kwargs): from Digitization.DigitizationFlags import digitizationFlags # If noise is turned off: if not digitizationFlags.doInDetNoise.get_Value(): kwargs.setdefault("OnlyHitElements", True) kwargs.setdefault("InputObjectName", "SCT_Hits") kwargs.setdefault("EnableHits", True) kwargs.setdefault("BarrelOnly", False) # Use of random disabled cells #kwargs.setdefault("RandomDisabledCells", True) # Set FixedTime for cosmics for use in SurfaceChargesGenerator from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == "cosmics": kwargs.setdefault("CosmicsRun", True) kwargs.setdefault("FixedTime", 10) # write out SCT1_RawData #kwargs.setdefault("WriteSCT1_RawData", False) kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) streamName = "SCT_Digitization" # FIXME ideally random stream name would be configurable if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName): digitizationFlags.rndmSeedList.addSeed(streamName, 49261510, 105132394) if digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", SCT_FirstXing()) kwargs.setdefault("LastXing", SCT_LastXing()) from AthenaCommon import CfgMgr return CfgMgr.SCT_DigitizationTool(name, **kwargs)
def TileHitVecToCntTool(name="TileHitVecToCntTool", **kwargs): ## FIXME includes to be replaced by confGetter configuration. from AthenaCommon.Resilience import protectedInclude protectedInclude( "CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py") protectedInclude("TileConditions/TileConditions_jobOptions.py") kwargs.setdefault("TileHitVectors", ["TileHitVec", "MBTSHits"]) kwargs.setdefault("TileInfoName", "TileInfo") kwargs.setdefault("TileHitContainer", "TileHitCnt") kwargs.setdefault("TileHitContainer_DigiHSTruth", "TileHitCnt_DigiHSTruth") kwargs.setdefault("DoHSTruthReconstruction", digitizationFlags.doDigiTruth()) from AthenaCommon.DetFlags import DetFlags kwargs.setdefault("PileUp", DetFlags.pileup.Tile_on()) from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == 'cosmics': kwargs.setdefault("TriggerTimeTool", "CosmicTriggerTimeTool") kwargs.setdefault("HitTimeFlag", 2) kwargs.setdefault("UseTriggerTime", True) if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", Tile_FirstXing()) kwargs.setdefault("LastXing", Tile_LastXing()) return CfgMgr.TileHitVecToCntTool(name, **kwargs)
def MergeMicromegasSimHitCollTool(name="MergeMicromegasSimHitCollTool", **kwargs): kwargs.setdefault("SimHitContainerNames", ["MicromegasSensitiveDetector"]) if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", -250) kwargs.setdefault("LastXing", 200) return CfgMgr.MergeGenericMuonSimHitCollTool(name, **kwargs)
def getLUCID_PileUpTool(name="LUCID_PileUpTool",**kwargs): kwargs.setdefault('pmtSmearing', [0.317, 0.000, 0.292, 0.316, 0.208, 0.178, 0.204, 0.281, 0.233, 0.261, 0.223, 0.250, 0.254, 0.239, 0.202, 0.224, 1, 1, 1, 1, 0.268, 0.277, 0.297, 0.310, 0.203, 0.347, 0.269, 0.241, 0.234, 0.234, 0.277, 0.297, 0.225, 0.297, 0.238, 0.000, 1, 1, 1, 1] ) kwargs.setdefault('pmtScaling', [1.010, 0.000, 0.991, 0.948, 1.152, 1.221, 1.160, 0.988, 1.092, 1.063, 1.143, 1.091, 1.109, 1.117, 1.185, 1.142, 1, 1, 1, 1, 1.023, 1.127, 1.043, 0.986, 1.148, 0.899, 0.898, 1.098, 1.115, 1.109, 1.127, 1.043, 1.085, 1.043, 1.063, 0.000, 1, 1, 1, 1] ) kwargs.setdefault('gasScaling', [1.176, 0.000, 1.217, 1.101, 1.143, 1.105, 1.103, 1.144, 1.075, 1.069, 1.100, 1.208, 1.212, 1.125, 1.026, 1.037, 1, 1, 1, 1, 1.064, 0.956, 0.975, 0.938, 1.205, 1.095, 1.137, 1.222, 1.262, 1.160, 0.923, 0.969, 1.132, 0.969, 1.174, 0.000, 1, 1, 1, 1] ) kwargs.setdefault('npeThreshold', [ 17, 15, 16, 16, 18, 16, 16, 18, 17, 16, 16, 17, 19, 16, 16, 17, 15, 15, 15, 15, 17, 16, 16, 17, 17, 15, 16, 16, 17, 16, 15, 17, 17, 15, 16, 15, 15, 15, 15, 15] ) from Digitization.DigitizationFlags import digitizationFlags kwargs.setdefault('RndmSvc', digitizationFlags.rndmSvc.get_Value() ) LucidRndmStream = "LUCIDRndEng" digitizationFlags.rndmSeedList.addSeed(LucidRndmStream, 3591, 2309736) # Configure bunch-crossing envelope if digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", LUCID_FirstXing() ) kwargs.setdefault("LastXing", LUCID_LastXing() ) from AthenaCommon import CfgMgr return CfgMgr.LUCID_PileUpTool(name,**kwargs)
def BasicTRTFastDigitizationTool(name, **kwargs): from IOVDbSvc.CondDB import conddb if not conddb.folderRequested('/TRT/Calib/errors'): conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Calib/errors", "/TRT/Calib/errors") if not conddb.folderRequested("/TRT/Calib/PID_vector"): conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Calib/PID_vector", "/TRT/Calib/PID_vector") if not conddb.folderRequested("/TRT/Calib/ToT/ToTVectors"): conddb.addFolder("TRT_OFL", "/TRT/Calib/ToT/ToTVectors") if not conddb.folderRequested("/TRT/Calib/ToT/ToTValue"): conddb.addFolder("TRT_OFL", "/TRT/Calib/ToT/ToTValue") #choose random number service from Digitization.DigitizationFlags import digitizationFlags kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) streamName = kwargs.setdefault("RandomStreamName", "FastTRTDigitization") # set rndm seeds if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName): digitizationFlags.rndmSeedList.addSeed(streamName, 45123, 94345) from Digitization.DigitizationFlags import digitizationFlags if digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", FastTRT_FirstXing()) kwargs.setdefault("LastXing", FastTRT_LastXing()) from AthenaCommon import CfgMgr return CfgMgr.TRTFastDigitizationTool(name, **kwargs)
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 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 getNewMergeMcEventCollTool_Signal(name="NewMergeMcEventCollTool_Signal", **kwargs): if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", 0) kwargs.setdefault("LastXing", 0) from Digitization import PileUpEventType kwargs.setdefault("PileUpType", PileUpEventType.Signal) return getNewMergeMcEventCollTool_Base(name, **kwargs)
def MergeCalibHitsTool(name="MergeCalibHitsTool", **kwargs): if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", CalibHit_FirstXing()) kwargs.setdefault("LastXing", CalibHit_LastXing()) if 'OldTileCalibHitContainers' in digitizationFlags.experimentalDigi(): kwargs.setdefault("OldFormat", True) return CfgMgr.MergeCalibHitsTool(name, **kwargs)
def SignalOnlyMcEventCollTool(name="SignalOnlyMcEventCollTool", **kwargs): if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", 0) kwargs.setdefault("LastXing", 0) keys = ['SimpleMerge', 'NewMerge'] if set(keys).isdisjoint(set(digitizationFlags.experimentalDigi())): kwargs.setdefault("OnlySaveSignalTruth", True) return genericMergeMcEventCollTool(name, **kwargs)
def getSplitPileUpToolsAlg(name="SplitPileUpToolsAlg", **kwargs): kwargs.setdefault('PileUpTools', getSplitPileUpToolsList()) from Digitization.DigitizationFlags import digitizationFlags if digitizationFlags.doXingByXingPileUp(): from PileUpComps.PileUpCompsConf import PileUpToolsAlg return PileUpToolsAlg(name, **kwargs) else: from PileUpComps.PileUpCompsConf import DigitizationAlg return DigitizationAlg(name, **kwargs)
def getNewMergeMcEventCollTool_Base(name="NewMergeMcEventCollTool_Base", **kwargs): if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", -30000) kwargs.setdefault("LastXing", 30000) if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi( ): from OverlayCommonAlgs.OverlayFlags import overlayFlags kwargs.setdefault("TruthCollOutputKey", overlayFlags.bkgPrefix() + "TruthEvent") else: kwargs.setdefault("TruthCollOutputKey", "TruthEvent") kwargs.setdefault("TruthCollInputKey", "TruthEvent") if not digitizationFlags.doXingByXingPileUp(): # Algorithm approach kwargs.setdefault("PileUpMergeSvc", "PileUpMergeSvc") # Default `PileUpType` to "Unknown" kwargs.setdefault("PileUpType", -1) return CfgMgr.NewMergeMcEventCollTool(name, **kwargs)
def BCM_DigitizationTool(name="BCM_DigitizationTool", **kwargs): from Digitization.DigitizationFlags import digitizationFlags kwargs.setdefault("HitCollName", "BCMHits") if not digitizationFlags.doInDetNoise.get_Value(): kwargs.setdefault("ModNoise", [0., 0., 0., 0., 0., 0., 0., 0.]) else: kwargs.setdefault( "ModNoise", [90.82, 90.82, 90.82, 90.82, 90.82, 90.82, 90.82, 90.82]) kwargs.setdefault("ModSignal", [450.0, 450.0, 450.0, 450.0, 450.0, 450.0, 450.0, 450.0]) kwargs.setdefault("NinoThr", [330.0, 330.0, 330.0, 330.0, 330.0, 330.0, 330.0, 330.0]) kwargs.setdefault("EffDistanceParam", 4.0) kwargs.setdefault("EffSharpnessParam", 0.11) kwargs.setdefault("TimeDelay", 9.0) kwargs.setdefault("MIPDeposit", 0.33) # BCM with diamond #kwargs.setdefault("MIPDeposit", 0.25) # BCM with graphite if digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", BCM_FirstXing()) kwargs.setdefault("LastXing", BCM_LastXing()) from AthenaCommon.GlobalFlags import globalflags if globalflags.isOverlay(): from OverlayCommonAlgs.OverlayFlags import overlayFlags if overlayFlags.isOverlayMT(): kwargs.setdefault("OnlyUseContainerName", False) kwargs.setdefault("OutputRDOKey", overlayFlags.sigPrefix() + "BCM_RDOs") kwargs.setdefault("OutputSDOKey", overlayFlags.sigPrefix() + "BCM_SDO_Map") else: kwargs.setdefault("OutputRDOKey", overlayFlags.evtStore() + "+BCM_RDOs") kwargs.setdefault("OutputSDOKey", overlayFlags.evtStore() + "+BCM_SDO_Map") else: if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi( ): from OverlayCommonAlgs.OverlayFlags import overlayFlags kwargs.setdefault("OutputRDOKey", overlayFlags.bkgPrefix() + "BCM_RDOs") kwargs.setdefault("OutputSDOKey", overlayFlags.bkgPrefix() + "BCM_SDO_Map") else: kwargs.setdefault("OutputRDOKey", "BCM_RDOs") kwargs.setdefault("OutputSDOKey", "BCM_SDO_Map") from AthenaCommon import CfgMgr return CfgMgr.BCM_DigitizationTool(name, **kwargs)
def getAFP_PileUpTool(name="AFP_PileUpTool",**kwargs): from Digitization.DigitizationFlags import digitizationFlags kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc.get_Value() ) AFPRndmStream = "AFPRndEng" digitizationFlags.rndmSeedList.addSeed(AFPRndmStream, 3591, 2309736) # Configure bunch-crossing envelope if digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", AFP_FirstXing() ) kwargs.setdefault("LastXing", AFP_LastXing() ) return CfgMgr.AFP_PileUpTool(name, **kwargs)
def genericMergeMcEventCollTool(name="MergeMcEventCollTool", **kwargs): if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi( ): from OverlayCommonAlgs.OverlayFlags import overlayFlags kwargs.setdefault("TruthCollOutputKey", overlayFlags.bkgPrefix() + "TruthEvent") else: kwargs.setdefault("TruthCollOutputKey", "TruthEvent") kwargs.setdefault("TruthCollInputKey", "TruthEvent") if 'SimpleMerge' in digitizationFlags.experimentalDigi(): if not digitizationFlags.doXingByXingPileUp(): # Algorithm approach kwargs.setdefault("PileUpMergeSvc", "PileUpMergeSvc") return CfgMgr.SimpleMergeMcEventCollTool(name, **kwargs) elif 'NewMerge' in digitizationFlags.experimentalDigi(): if not digitizationFlags.doXingByXingPileUp(): # Algorithm approach kwargs.setdefault("PileUpMergeSvc", "PileUpMergeSvc") if digitizationFlags.doLowPtMinBias: kwargs.setdefault("ExpectLowPtMinBiasBackgroundCollection", True) if digitizationFlags.doHighPtMinBias: kwargs.setdefault("ExpectHighPtMinBiasBackgroundCollection", True) # Default `PileUpType` to "Unknown" kwargs.setdefault("PileUpType", -1) return CfgMgr.NewMergeMcEventCollTool(name, **kwargs) else: kwargs.setdefault("LowTimeToKeep", -50.5) kwargs.setdefault("HighTimeToKeep", 50.5) kwargs.setdefault("KeepUnstable", False) kwargs.setdefault("AbsEtaMax", 5.0) kwargs.setdefault("OutOfTimeAbsEtaMax", 3.0) kwargs.setdefault("rRange", 20.0) kwargs.setdefault("zRange", 200.0) #kwargs.setdefault("ptMin", 0.4*GeV) #kwargs.setdefault("EKinMin", 1.0*MeV) kwargs.setdefault("SaveCavernBackground", True) kwargs.setdefault("SaveInTimeMinBias", True) kwargs.setdefault("SaveOutOfTimeMinBias", True) kwargs.setdefault("SaveRestOfMinBias", False) kwargs.setdefault("AddBackgroundCollisionVertices", True) kwargs.setdefault("CompressOutputCollection", False) #kwargs.setdefault("CopyCompleteGenEvents", True) return CfgMgr.MergeMcEventCollTool(name, **kwargs)
def useLArFloat(): from Digitization.DigitizationFlags import digitizationFlags if digitizationFlags.doXingByXingPileUp() or isOverlay(): # temporary, remapping to LArHitFloat does not seeem to work # with this scheme... => larger memory usage return False # check for fast chain, running digitisation from hits in memory from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.DoFullChain: return False # use simplified transient LArHit with float E,time return True
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 BasicTRTDigitizationTool(name, **kwargs): from AthenaCommon.Resilience import protectedInclude protectedInclude("TRT_Digitization/TRT_Digitization_CommonOptions.py") kwargs.setdefault("PAI_Tool_Xe", "TRT_PAI_Process_Xe") kwargs.setdefault("PAI_Tool_Ar", "TRT_PAI_Process_Ar") kwargs.setdefault("PAI_Tool_Kr", "TRT_PAI_Process_Kr") from Digitization.DigitizationFlags import digitizationFlags #flag from Simulation/Digitization if not digitizationFlags.doInDetNoise.get_Value(): kwargs.setdefault("Override_noiseInSimhits", 0) kwargs.setdefault("Override_noiseInUnhitStraws", 0) #kwargs.setdefault("Override_useMagneticFieldMap=0) #TRT xenon range cut trtRangeCut = 0.05 if hasattr(digitizationFlags, 'TRTRangeCut'): trtRangeCut = digitizationFlags.TRTRangeCut.get_Value() kwargs.setdefault("Override_TrtRangeCutProperty", trtRangeCut) # Import Beam job properties from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == "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 digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", TRT_FirstXing()) kwargs.setdefault("LastXing", TRT_LastXing()) ##else: ## from AthenaCommon.DetFlags import DetFlags ## from AthenaCommon.AppMgr import ServiceMgr ## from PileUpComps.PileUpCompsConf import PileUpXingFolder ## if DetFlags.pileup.TRT_on(): ## TRTRange = PileUpXingFolder( "TRTRange" ) ## TRTRange.ItemList += ["TRTUncompressedHitCollection#TRTUncompressedHits"] ## #this is the time of the xing in ns ## TRTRange.FirstXing = TRT_FirstXing() ## TRTRange.LastXing = TRT_LastXing() ## TRTRange.CacheRefreshFrequency = 1.0; #default 0 no dataproxy reset ## # add TRTRange to known pileuo intervals ## ServiceMgr.PileUpMergeSvc.Intervals += [TRTRange] kwargs.setdefault("RandomSeedOffset", digitizationFlags.rndmSeedOffset1.get_Value()) return CfgMgr.TRTDigitizationTool(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 protectedInclude("PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py") include.block("PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py") protectedInclude("PixelConditionsServices/PixelDCSSvc_jobOptions.py") include.block("PixelConditionsServices/PixelDCSSvc_jobOptions.py") from AthenaCommon.AppMgr import ServiceMgr 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") kwargs.setdefault("EnableNoise", digitizationFlags.doInDetNoise.get_Value()) # Start of special cosmics tuning: if jobproperties.Beam.beamType == "cosmics": kwargs.setdefault("CosmicsRun", True) kwargs.setdefault("UseComTime", True) else: # For LVL1Latency, ToTMinCut, ApplyDupli and LowTOTduplication, first component [0] is always for IBL, even for run 1 production. # The order is IBL, BL, L1, L2, EC, DBM # For IBL and DBM, values of LVL1Latency and LowToTDupli are superseded by values driven by HitDiscCnfg settings, in PixelDigitizationTool.cxx LVL1Latency = [16, 150, 255, 255, 255, 16] kwargs.setdefault("LVL1Latency", LVL1Latency) ToTMinCut = [0, 4, 4, 4, 4, 0] kwargs.setdefault("ToTMinCut", ToTMinCut) ApplyDupli = [True, True, True, True, True, True] kwargs.setdefault("ApplyDupli", ApplyDupli) LowTOTduplication = [0, 7, 7, 7, 7, 0] kwargs.setdefault("LowTOTduplication", LowTOTduplication) if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", Pixel_FirstXing()) kwargs.setdefault("LastXing", Pixel_LastXing()) return CfgMgr.PixelDigitizationTool(name, **kwargs)
def getStandardPileUpToolsAlg(name="StandardPileUpToolsAlg", **kwargs): kwargs.setdefault('PileUpTools', getStandardPileUpToolsList()) kwargs.setdefault('ExtraInputs', [('xAOD::EventInfo', 'EventInfo')]) from Digitization.DigitizationFlags import digitizationFlags if digitizationFlags.doXingByXingPileUp(): if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi( ): from OverlayCommonAlgs.OverlayFlags import overlayFlags kwargs.setdefault('EventInfoKey', overlayFlags.bkgPrefix() + 'EventInfo') else: kwargs.setdefault('EventInfoKey', 'EventInfo') return CfgMgr.PileUpToolsAlg(name, **kwargs) else: return CfgMgr.DigitizationAlg(name, **kwargs)
def MergeRecoTimingObjTool(name="MergeRecoTimingObjTool", **kwargs): if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", TimingObj_FirstXing()) kwargs.setdefault("LastXing", TimingObj_LastXing()) kwargs.setdefault("RecoTimingObjInputKey", "EVNTtoHITS_timings") if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi( ): from OverlayCommonAlgs.OverlayFlags import overlayFlags kwargs.setdefault("RecoTimingObjOutputKey", overlayFlags.bkgPrefix() + "EVNTtoHITS_timings") else: kwargs.setdefault("RecoTimingObjOutputKey", "EVNTtoHITS_timings") return CfgMgr.MergeRecoTimingObjTool(name, **kwargs)
def getLowPtMinBiasCache(name="LowPtMinBiasCache", **kwargs): from Digitization.DigitizationFlags import digitizationFlags from AthenaCommon.BeamFlags import beamFlags kwargs.setdefault('CollPerXing', digitizationFlags.numberOfLowPtMinBias() ) 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('ReadDownscaleFactor', 1 ) kwargs.setdefault('EventSelector', getService('LowPtMinBiasEventSelector') ) 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 makeCavernBkgInputCol(nEvts, initialList): uberlist = [] refreshrate = 1 / 150.0 from Digitization.DigitizationFlags import digitizationFlags if (digitizationFlags.doXingByXingPileUp()): refreshrate = 1.0 bob = 65.0 * float(digitizationFlags.numberOfCavern.get_Value()) #print bob bob += bob * refreshrate * nEvts #print bob bob /= 25 * len(initialList) #print bob bill = 1 + int(bob) #print bill for i in range(0, bill): #print len(uberlist) uberlist += initialList #print len(uberlist) return uberlist
def getMergeTruthJetsTool(name="MergeTruthJetsTool", **kwargs): if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", TruthJet_FirstXing()) kwargs.setdefault("LastXing", TruthJet_LastXing()) if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi( ): from OverlayCommonAlgs.OverlayFlags import overlayFlags kwargs.setdefault("InTimeOutputTruthJetCollKey", overlayFlags.bkgPrefix() + "InTimeAntiKt4TruthJets") kwargs.setdefault( "OutOfTimeTruthJetCollKey", overlayFlags.bkgPrefix() + "OutOfTimeAntiKt4TruthJets") else: kwargs.setdefault("InTimeOutputTruthJetCollKey", "InTimeAntiKt4TruthJets") kwargs.setdefault("OutOfTimeTruthJetCollKey", "OutOfTimeAntiKt4TruthJets") return CfgMgr.MergeTruthJetsTool(name, **kwargs)
def makeMinBiasBkgInputCol(nEvts, initialList): uberlist = [] refreshrate = 1 / 150.0 from Digitization.DigitizationFlags import digitizationFlags if (digitizationFlags.doXingByXingPileUp()): refreshrate = 1.0 from AthenaCommon.AthenaCommonFlags import athenaCommonFlags bob = 65.0 * digitizationFlags.numberOfLowPtMinBias.get_Value() #print bob bob += bob * refreshrate * nEvts #print bob bob /= float(1000 * len(initialList)) #print bob bill = 1 + int(bob) #print bill for i in range(0, bill): #print len(uberlist) uberlist += initialList #print len(uberlist) return uberlist
def commonSCT_FastDigitizationConfig(name,**kwargs): # Setup the DCS folders and tool used in the sctSiliconConditionsTool from SCT_ConditionsTools.SCT_DCSConditionsToolSetup import SCT_DCSConditionsToolSetup sct_DCSConditionsToolSetup = SCT_DCSConditionsToolSetup() sct_DCSConditionsToolSetup.setup() kwargs.setdefault("ClusterMaker", "FastClusterMakerTool") # Import Digitization job properties from Digitization.DigitizationFlags import digitizationFlags # set the random service, stream name streamName = kwargs.setdefault("RndmEngine", "FastSCT_Digitization") kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc() ) # set rndm seeds if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName): digitizationFlags.rndmSeedList.addSeed(streamName, 49261510, 105132394 ) if digitizationFlags.doXingByXingPileUp(): kwargs.setdefault("FirstXing", FastSCT_FirstXing()) kwargs.setdefault("LastXing", FastSCT_LastXing() ) # Set up SCT_SiliconConditionsTool from SCT_ConditionsTools.SCT_SiliconConditionsToolSetup import SCT_SiliconConditionsToolSetup sct_SiliconConditionsToolSetup = SCT_SiliconConditionsToolSetup() sct_SiliconConditionsToolSetup.setDcsTool(sct_DCSConditionsToolSetup.getTool()) sct_SiliconConditionsToolSetup.setup() # Set up SCT_SiPropertiesTool from SiPropertiesTool.SCT_SiPropertiesToolSetup import SCT_SiPropertiesToolSetup sct_SiPropertiesToolSetup = SCT_SiPropertiesToolSetup() sct_SiPropertiesToolSetup.setSiliconTool(sct_SiliconConditionsToolSetup.getTool()) sct_SiPropertiesToolSetup.setup() # SiLorentzAngleTool for SCT_FastDigitizationTool from AthenaCommon.AppMgr import ToolSvc from SiLorentzAngleTool.SCTLorentzAngleToolSetup import SCTLorentzAngleToolSetup sctLorentzAngleToolSetup = SCTLorentzAngleToolSetup() kwargs.setdefault("LorentzAngleTool", sctLorentzAngleToolSetup.SCTLorentzAngleTool) from AthenaCommon import CfgMgr return CfgMgr.SCT_FastDigitizationTool(name,**kwargs)