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)
