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 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 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 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) # Random number engine kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) digitizationFlags.rndmSeedList.addSeed("Tile_HitVecToCnt", 4789899, 989240512) if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach kwargs.setdefault("FirstXing", Tile_FirstXing() ) kwargs.setdefault("LastXing", Tile_LastXing() ) return CfgMgr.TileHitVecToCntTool(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 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 BichselSimTool(name="BichselSimTool", **kwargs): kwargs.setdefault("DeltaRayCut", 117.) kwargs.setdefault("nCols", 5) kwargs.setdefault("LoopLimit", 100000) kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") return CfgMgr.BichselSimTool(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 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 getArrayBM(name="ArrayBM", **kwargs): from Digitization.DigitizationFlags import digitizationFlags kwargs.setdefault('IntensityPattern', digitizationFlags.BeamIntensityPattern.get_Value()) kwargs.setdefault('RandomSvc', digitizationFlags.rndmSvc() ) digitizationFlags.rndmSeedList.addSeed( "BEAMINT", 678, 91011 ) from PileUpComps.PileUpCompsConf import ArrayBM return ArrayBM(name, **kwargs)
def Ibl3DBichselChargeTool(name="Ibl3DBichselChargeTool", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") kwargs.setdefault("doBichsel", _doBichsel) kwargs.setdefault("doBichselBetaGammaCut", 0.7) # dEdx not quite consistent below this kwargs.setdefault("doDeltaRay", False) # needs validation kwargs.setdefault("BichselSimTool", "BichselSimTool") return CfgMgr.Ibl3DBichselChargeTool(name, **kwargs)
def PixelECBichselChargeTool(name="PixelECBichselChargeTool", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") kwargs.setdefault("doBichsel", _doBichsel) # kwargs.setdefault("doBichsel", False) kwargs.setdefault("doBichselBetaGammaCut", 0.7) # dEdx not quite consistent below this kwargs.setdefault("BichselSimTool", "BichselSimTool") return CfgMgr.PixelECBichselChargeTool(name, **kwargs)
def PixelECBichselChargeTool(name="PixelECBichselChargeTool", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") kwargs.setdefault("doBichsel", hasattr(digitizationFlags, "doBichselSimulation") and digitizationFlags.doBichselSimulation()) kwargs.setdefault("doBichselBetaGammaCut", 0.7) # dEdx not quite consistent below this kwargs.setdefault("doPU", True) kwargs.setdefault("BichselSimTool", "BichselSimTool") return CfgMgr.PixelECBichselChargeTool(name, **kwargs)
def RD53SimTool(name="RD53SimTool", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") kwargs.setdefault("BarrelAnalogthreshold", [-1, -1, -1, -1, -1]) kwargs.setdefault("EndcapAnalogthreshold", [-1, -1, -1, -1]) kwargs.setdefault("BarrelToTthreshold", [-1, -1, -1, -1, -1]) kwargs.setdefault("EndcapToTthreshold", [-1, -1, -1, -1]) return CfgMgr.RadDam__RD53SimTool(name, **kwargs)
def IblPlanarBichselChargeTool(name="IblPlanarBichselChargeTool", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") kwargs.setdefault("doBichsel", hasattr(digitizationFlags, "doBichselSimulation") and digitizationFlags.doBichselSimulation()) kwargs.setdefault("doBichselBetaGammaCut", 0.7) # dEdx not quite consistent below this kwargs.setdefault("doDeltaRay", False) # needs validation kwargs.setdefault("doPU", True) kwargs.setdefault("BichselSimTool", "BichselSimTool") return CfgMgr.IblPlanarBichselChargeTool(name, **kwargs)
def EnergyDepositionTool(name="EnergyDepositionTool", **kwargs): kwargs.setdefault("DeltaRayCut", 117.) kwargs.setdefault("nCols", 5) kwargs.setdefault("LoopLimit", 100000) kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") kwargs.setdefault("doBichsel", hasattr(digitizationFlags, "doBichselSimulation") and digitizationFlags.doBichselSimulation()) kwargs.setdefault("doBichselBetaGammaCut", 0.7) # dEdx not quite consistent below this kwargs.setdefault("doDeltaRay", False) # needs validation kwargs.setdefault("doPU", True) return CfgMgr.RadDam__EnergyDepositionTool(name, **kwargs)
def PixelBarrelBichselChargeTool(name="PixelBarrelBichselChargeTool", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") kwargs.setdefault("doBichsel", _doBichsel) # kwargs.setdefault("doBichsel", False) kwargs.setdefault("doBichselBetaGammaCut", 0.7) # dEdx not quite consistent below this kwargs.setdefault("doDeltaRay", False) # needs validation kwargs.setdefault("BichselSimTool", "BichselSimTool") # kwargs.setdefault("OutputFileName", digitizationFlags.BichselOutputFileName()) # kwargs.setdefault("doHITPlots", True) return CfgMgr.PixelBarrelBichselChargeTool(name, **kwargs)
def SpecialPixelGenerator(name="SpecialPixelGenerator", **kwargs): from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == "cosmics" : # random noise probability kwargs.setdefault("SpmNoiseProb", 1e-5) kwargs.setdefault("SpmNoBumpProb", 5e-4) kwargs.setdefault("SpmDisableProb", 2e-5) #kwargs.setdefault("SpmBadTOTProb", 5e-4) kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") return CfgMgr.SpecialPixelGenerator(name, **kwargs)
def PixelNoisyCellGenerator(name="PixelNoisyCellGenerator", **kwargs): from AthenaCommon.BeamFlags import jobproperties kwargs.setdefault("MergeCharge", True) NoiseShape = [0.00596, 0.03491, 0.07058, 0.11991, 0.17971, 0.24105, 0.29884, 0.35167, 0.39912, 0.44188, 0.48016, 0.51471, 0.54587, 0.57405, 0.59958, 0.62288, 0.64411, 0.66360, 0.68159, 0.69823, 0.71362, 0.72781, 0.74096, 0.75304, 0.76415, 0.77438, 0.78383, 0.79256, 0.80066, 0.80821, 0.81547, 0.82246, 0.82918, 0.83501, 0.84054, 0.84576, 0.85078, 0.85558, 0.86018, 0.86455, 0.86875, 0.87273, 0.87653, 0.88020, 0.88369, 0.88705, 0.89027, 0.89336, 0.89633, 0.89921, 0.90195, 0.90460, 0.90714, 0.90961, 0.91198, 0.91426, 0.91644, 0.91853, 0.92055, 0.92250, 0.92435, 0.92611, 0.92782, 0.92947, 0.93105, 0.93257, 0.93404, 0.93547, 0.93688, 0.93822, 0.93953, 0.94079, 0.94201, 0.94318, 0.94432, 0.94542, 0.94649, 0.94751, 0.94851, 0.94949, 0.95045, 0.95137, 0.95227, 0.95314, 0.95399, 0.95483, 0.95563, 0.95646, 0.95729, 0.95812, 0.95896, 0.95980, 0.96063, 0.96144, 0.96224, 0.96301, 0.96377, 0.96451, 0.96521, 0.96590, 0.96657, 0.96722, 0.96787, 0.96849, 0.96911, 0.96971, 0.97031, 0.97090, 0.97148, 0.97204, 0.97260, 0.97314, 0.97367, 0.97421, 0.97474, 0.97525, 0.97576, 0.97627, 0.97676, 0.97722, 0.97769, 0.97815, 0.97861, 0.97906, 0.97950, 0.97992, 0.98033, 0.98073, 0.98111, 0.98147, 0.98182, 0.98216, 0.98249, 0.98281, 0.98312, 0.98343, 0.98374, 0.98402, 0.98430, 0.98456, 0.98482, 0.98507, 0.98532, 0.98555, 0.98579, 0.98602, 0.98624, 0.98646, 0.98668, 0.98690, 0.98711, 0.98732, 0.98753, 0.98773, 0.98793, 0.98813, 0.98832, 0.98851, 0.98870, 0.98888, 0.98907, 0.98925, 0.98943, 0.98961, 0.98979, 0.98996, 0.99014, 0.99031, 0.99048, 0.99064, 0.99081, 0.99098, 0.99114, 0.99131, 0.99147, 0.99163, 0.99179, 0.99194, 0.99210, 0.99225, 0.99240, 0.99256, 0.99271, 0.99286, 0.99300, 0.99315, 0.99329, 0.99344, 0.99358, 0.99372, 0.99386, 0.99400, 0.99414, 0.99427, 0.99440, 0.99453, 0.99466, 0.99479, 0.99491, 0.99503, 0.99515, 0.99527, 0.99538, 0.99549, 0.99560, 0.99571, 0.99582, 0.99592, 0.99602, 0.99613, 0.99623, 0.99633, 0.99643, 0.99653, 0.99662, 0.99672, 0.99682, 0.99691, 0.99701, 0.99710, 0.99719, 0.99728, 0.99737, 0.99746, 0.99755, 0.99764, 0.99772, 0.99781, 0.99790, 0.99798, 0.99806, 0.99814, 0.99823, 0.99831, 0.99839, 0.99847, 0.99855, 0.99863, 0.99871, 0.99879, 0.99887, 0.99895, 0.99902, 0.99910, 0.99918, 0.99925, 0.99933, 0.99940, 0.99948, 0.99955, 0.99963, 0.99971, 0.99978, 0.99985, 0.99993, 1.00000] kwargs.setdefault("NoiseShape",NoiseShape) #print "Noise Shape = ",NoiseShape kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") if jobproperties.Beam.beamType != "cosmics" : kwargs.setdefault("RndNoiseProb", 1.e-10) return CfgMgr.PixelNoisyCellGenerator(name, **kwargs)
def SpecialPixelGenerator(name="SpecialPixelGenerator", **kwargs): from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == "cosmics": # random noise probability kwargs.setdefault("SpmNoiseProb", 1e-5) kwargs.setdefault("SpmNoBumpProb", 5e-4) kwargs.setdefault("SpmDisableProb", 2e-5) # kwargs.setdefault("SpmBadTOTProb", 5e-4) kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") return CfgMgr.SpecialPixelGenerator(name, **kwargs)
def CalibSvc(name="CalibSvc", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") from AthenaCommon.BeamFlags import jobproperties from AthenaCommon.Resilience import protectedInclude protectedInclude("PixelConditionsServices/PixelCalibSvc_jobOptions.py") from IOVDbSvc.CondDB import conddb conddb.addFolderSplitMC("PIXEL", "/PIXEL/ReadoutSpeed", "/PIXEL/ReadoutSpeed") if jobproperties.Beam.beamType == "cosmics": kwargs.setdefault("UsePixMapCondDB", True) return CfgMgr.CalibSvc(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 FrontEndSimTool(name="FrontEndSimTool", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == "cosmics" : kwargs.setdefault("UseComTime", True) kwargs.setdefault("TimeJitter", 25.0) kwargs.setdefault("TimeBCN",8.0) kwargs.setdefault("TimeZero", 100.0) else: kwargs.setdefault("TimeBCN",1.0) kwargs.setdefault("TimeZero", 5.0) kwargs.setdefault("TimePerBCO", 25.0) return CfgMgr.RadDam__FrontEndSimTool(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 FEI3SimTool(name="FEI3SimTool", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") kwargs.setdefault("BarrelAnalogthreshold", [-1, -1, -1, -1]) # first argument is dummy kwargs.setdefault("EndcapAnalogthreshold", [-1, -1, -1]) kwargs.setdefault("BarrelToTthreshold", [-1, 5, 5, 5]) # first argument is dummy kwargs.setdefault("EndcapToTthreshold", [ 5, 5, 5]) kwargs.setdefault("BarrelLatency", [ -1, 151, 256, 256]) kwargs.setdefault("EndcapLatency", [256, 256, 256]) kwargs.setdefault("BarrelHitDuplication", [False, False, False, False]) kwargs.setdefault("EndcapHitDuplication", [False, False, False]) kwargs.setdefault("BarrelSmallHitToT", [-1, -1, -1, -1]) kwargs.setdefault("EndcapSmallHitToT", [-1, -1, -1]) kwargs.setdefault("TimingTune", 2015) return CfgMgr.RadDam__FEI3SimTool(name, **kwargs)
def getBeamHaloCache(name="BeamHaloCache", **kwargs): from Digitization.DigitizationFlags import digitizationFlags kwargs.setdefault('IgnoreBeamLumi', True ) kwargs.setdefault('CollPerXing', digitizationFlags.numberOfBeamHalo() ) from Digitization import PileUpEventType kwargs.setdefault('PileUpEventType', PileUpEventType.HaloGas ) kwargs.setdefault('CollDistribution', "Poisson" ) kwargs.setdefault('ReadDownscaleFactor', 1 ) kwargs.setdefault('EventSelector', "BeamHaloEventSelector" ) 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 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 TimeSvc(name="TimeSvc", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") timeBCN = 5 timePerBCO = 25.0 if digitizationFlags.bunchSpacing.get_Value() > 0: timeBCN = max(int(digitizationFlags.bunchSpacing.get_Value()/timePerBCO),timeBCN) from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == "cosmics" : ## Timing for cosmics run kwargs.setdefault("TimeJitter", 25.) kwargs.setdefault("TimeZero", 100.) timeBCN = 8 else: kwargs.setdefault("TimeZero", 5.) timeBCN = 1 kwargs.setdefault("TimePerBCO", 25.0) kwargs.setdefault("TimeBCN",timeBCN) return CfgMgr.TimeSvc(name, **kwargs)
def TimeSvc(name="TimeSvc", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") timeBCN = 5 timePerBCO = 25.0 if digitizationFlags.bunchSpacing.get_Value() > 0: timeBCN = max(int(digitizationFlags.bunchSpacing.get_Value() / timePerBCO), timeBCN) from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == "cosmics": ## Timing for cosmics run kwargs.setdefault("TimeJitter", 25.0) kwargs.setdefault("TimeZero", 100.0) timeBCN = 8 else: kwargs.setdefault("TimeZero", 5.0) timeBCN = 1 kwargs.setdefault("TimePerBCO", 25.0) kwargs.setdefault("TimeBCN", timeBCN) return CfgMgr.TimeSvc(name, **kwargs)
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)
def PixelNoisyCellGenerator(name="PixelNoisyCellGenerator", **kwargs): from AthenaCommon.BeamFlags import jobproperties kwargs.setdefault("MergeCharge", True) NoiseShape = [ 0.00596, 0.03491, 0.07058, 0.11991, 0.17971, 0.24105, 0.29884, 0.35167, 0.39912, 0.44188, 0.48016, 0.51471, 0.54587, 0.57405, 0.59958, 0.62288, 0.64411, 0.66360, 0.68159, 0.69823, 0.71362, 0.72781, 0.74096, 0.75304, 0.76415, 0.77438, 0.78383, 0.79256, 0.80066, 0.80821, 0.81547, 0.82246, 0.82918, 0.83501, 0.84054, 0.84576, 0.85078, 0.85558, 0.86018, 0.86455, 0.86875, 0.87273, 0.87653, 0.88020, 0.88369, 0.88705, 0.89027, 0.89336, 0.89633, 0.89921, 0.90195, 0.90460, 0.90714, 0.90961, 0.91198, 0.91426, 0.91644, 0.91853, 0.92055, 0.92250, 0.92435, 0.92611, 0.92782, 0.92947, 0.93105, 0.93257, 0.93404, 0.93547, 0.93688, 0.93822, 0.93953, 0.94079, 0.94201, 0.94318, 0.94432, 0.94542, 0.94649, 0.94751, 0.94851, 0.94949, 0.95045, 0.95137, 0.95227, 0.95314, 0.95399, 0.95483, 0.95563, 0.95646, 0.95729, 0.95812, 0.95896, 0.95980, 0.96063, 0.96144, 0.96224, 0.96301, 0.96377, 0.96451, 0.96521, 0.96590, 0.96657, 0.96722, 0.96787, 0.96849, 0.96911, 0.96971, 0.97031, 0.97090, 0.97148, 0.97204, 0.97260, 0.97314, 0.97367, 0.97421, 0.97474, 0.97525, 0.97576, 0.97627, 0.97676, 0.97722, 0.97769, 0.97815, 0.97861, 0.97906, 0.97950, 0.97992, 0.98033, 0.98073, 0.98111, 0.98147, 0.98182, 0.98216, 0.98249, 0.98281, 0.98312, 0.98343, 0.98374, 0.98402, 0.98430, 0.98456, 0.98482, 0.98507, 0.98532, 0.98555, 0.98579, 0.98602, 0.98624, 0.98646, 0.98668, 0.98690, 0.98711, 0.98732, 0.98753, 0.98773, 0.98793, 0.98813, 0.98832, 0.98851, 0.98870, 0.98888, 0.98907, 0.98925, 0.98943, 0.98961, 0.98979, 0.98996, 0.99014, 0.99031, 0.99048, 0.99064, 0.99081, 0.99098, 0.99114, 0.99131, 0.99147, 0.99163, 0.99179, 0.99194, 0.99210, 0.99225, 0.99240, 0.99256, 0.99271, 0.99286, 0.99300, 0.99315, 0.99329, 0.99344, 0.99358, 0.99372, 0.99386, 0.99400, 0.99414, 0.99427, 0.99440, 0.99453, 0.99466, 0.99479, 0.99491, 0.99503, 0.99515, 0.99527, 0.99538, 0.99549, 0.99560, 0.99571, 0.99582, 0.99592, 0.99602, 0.99613, 0.99623, 0.99633, 0.99643, 0.99653, 0.99662, 0.99672, 0.99682, 0.99691, 0.99701, 0.99710, 0.99719, 0.99728, 0.99737, 0.99746, 0.99755, 0.99764, 0.99772, 0.99781, 0.99790, 0.99798, 0.99806, 0.99814, 0.99823, 0.99831, 0.99839, 0.99847, 0.99855, 0.99863, 0.99871, 0.99879, 0.99887, 0.99895, 0.99902, 0.99910, 0.99918, 0.99925, 0.99933, 0.99940, 0.99948, 0.99955, 0.99963, 0.99971, 0.99978, 0.99985, 0.99993, 1.00000, ] kwargs.setdefault("NoiseShape", NoiseShape) # print "Noise Shape = ",NoiseShape kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") if jobproperties.Beam.beamType != "cosmics": kwargs.setdefault("RndNoiseProb", 1.0e-10) return CfgMgr.PixelNoisyCellGenerator(name, **kwargs)
def PixelChargeSmearer(name="PixelChargeSmearer", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") kwargs.setdefault("ThermalNoise", 160.0) return CfgMgr.PixelChargeSmearer(name, **kwargs)
from PileUpComps.PileUpCompsConf import BkgStreamsCache from Digitization import PileUpEventType from EventSelectorAthenaPool.EventSelectorAthenaPoolConf import EventSelectorAthenaPool from Digitization.DigitizationFlags import digitizationFlags PileUpEventLoopMgr.OrigSelector = "EventSelector" minBiasCache = BkgStreamsCache("MinBiasCache") if hasattr(digitizationFlags, 'numberOfNDMinBias'): minBiasCache.CollPerXing = digitizationFlags.numberOfNDMinBias() elif hasattr(digitizationFlags, 'numberOfLowPtMinBias'): minBiasCache.CollPerXing = digitizationFlags.numberOfLowPtMinBias() else: raise AttributeError( "These job options require digitization jobproperties not present in this release! This job will crash." ) minBiasCache.RndmGenSvc = digitizationFlags.rndmSvc() minBiasCache.RndmStreamName = pupStream minBiasCache.PileUpEventType = PileUpEventType.MinimumBias minBiasCache.ReadDownscaleFactor = 10 # read one new event every event from EventSelectorAthenaPool.EventSelectorAthenaPoolConf import EventSelectorAthenaPool minBiasEvtSel = EventSelectorAthenaPool("minBiasEventSelector") if hasattr(digitizationFlags, 'NDMinBiasInputCols'): minBiasEvtSel.InputCollections = digitizationFlags.NDMinBiasInputCols() elif hasattr(digitizationFlags, 'LowPtMinBiasInputCols'): minBiasEvtSel.InputCollections = digitizationFlags.LowPtMinBiasInputCols() else: raise AttributeError( "These job options require digitization jobproperties not present in this release! This job will crash." ) minBiasEvtSel.KeepInputFilesOpen = kfOpen
def configure(self): mlog = logging.getLogger( 'TileDigitsGetter::configure:' ) mlog.info ('entering') # get handle to upstream object try: from TileSimAlgs.TileDigitsGetter import TileDigitsGetter theTileDigitsGetter=TileDigitsGetter() except: mlog.error("could not get handle to TileDigitsGetter Quit") print traceback.format_exc() return False if not theTileDigitsGetter.usable(): if not self.ignoreConfigError(): mlog.error("TileDigitsGetter unusable. Quit.") return False else: mlog.error("TileDigitsGetter unusable. Continue nevertheless") from TileConditions.TileInfoConfigurator import TileInfoConfigurator tileInfoConfigurator = TileInfoConfigurator() tileInfoConfigurator.setupCOOLPHYPULSE() # Instantiation of the C++ algorithm try: from TileSimAlgs.TileSimAlgsConf import TileDigitsMaker except: mlog.error("could not import TileSimAlgs.TileDigitsMaker") print traceback.format_exc() return False theTileDigitsMaker=TileDigitsMaker() self._TileDigitsMakerHandle = theTileDigitsMaker ; theTileDigitsMaker.TileHitContainer_DigiHSTruth="TileHitCnt_DigiHSTruth" from Digitization.DigitizationFlags import digitizationFlags theTileDigitsMaker.DoHSTruthReconstruction = digitizationFlags.doDigiTruth() # Configure TileDigitsMaker here # Check TileDigitization_jobOptions.py for full configurability theTileDigitsMaker.TileHitContainer="TileHitCnt" theTileDigitsMaker.TileInfoName="TileInfo" theTileDigitsMaker.CalibrationRun=False # Random number engine theTileDigitsMaker.RndmSvc=digitizationFlags.rndmSvc() digitizationFlags.rndmSeedList.addSeed("Tile_DigitsMaker", 4789899, 989240512) # Save integer numbers in digits vector if not pile-up premixing theTileDigitsMaker.IntegerDigits = not digitizationFlags.PileUpPremixing() # sets output key theTileDigitsMaker.TileDigitsContainer=self.outputKey() # register output in objKeyStore from RecExConfig.ObjKeyStore import objKeyStore objKeyStore.addStreamESD(self.outputType(),self.outputKey()) # now add algorithm to topSequence # this should always come at the end mlog.info(" now adding to topSequence") # get a handle on topalg from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileDigitsMaker; return True
def PixelCellDiscriminator(name="PixelCellDiscriminator", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") return CfgMgr.PixelCellDiscriminator(name, **kwargs)
def PixelRandomDisabledCellGenerator(name="PixelRandomDisabledCellGenerator", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") return CfgMgr.PixelRandomDisabledCellGenerator(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 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") kwargs.setdefault("PixelCablingSvc","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") pixTools = [] pixTools += ['PixelDiodeCrossTalkGenerator'] pixTools += ['PixelChargeSmearer'] if digitizationFlags.doInDetNoise.get_Value(): pixTools += ['PixelNoisyCellGenerator'] pixTools += ['PixelGangedMerger'] pixTools += ['SpecialPixelGenerator'] pixTools += ['PixelRandomDisabledCellGenerator'] pixTools += ['PixelCellDiscriminator'] kwargs.setdefault("PixelTools", pixTools) # Start of special cosmics tuning: if jobproperties.Beam.beamType == "cosmics" : kwargs.setdefault("UseComTime", True) if GeometryFlags.isSLHC(): LVL1Latency = [255, 255, 255, 255, 255, 16, 255] ToTMinCut = [0, 0, 0, 0, 0, 0, 0] ApplyDupli = [False, False, False, False, False, False, False] LowTOTduplication = [0, 0, 0, 0, 0, 0, 0] kwargs.setdefault("LVL1Latency", LVL1Latency) kwargs.setdefault("ToTMinCut", ToTMinCut) kwargs.setdefault("ApplyDupli", ApplyDupli) kwargs.setdefault("LowTOTduplication", LowTOTduplication) 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] ToTMinCut = [0, 6, 6, 6, 6, 0] ApplyDupli = [True, False, False, False, False, False] LowTOTduplication = [0, 7, 7, 7, 7, 0] kwargs.setdefault("LVL1Latency", LVL1Latency) kwargs.setdefault("ToTMinCut", ToTMinCut) kwargs.setdefault("ApplyDupli", ApplyDupli) 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 DBMChargeTool(name="DBMChargeTool", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") return CfgMgr.DBMChargeTool(name, **kwargs)
def PixelCellDiscriminator(name="PixelCellDiscriminator", **kwargs): kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc()) kwargs.setdefault("RndmEngine", "PixelDigitization") kwargs.setdefault("doITk", GeometryFlags.isSLHC()) return CfgMgr.PixelCellDiscriminator(name, **kwargs)