def getPixelPhysicsRegionTool(name='PixelPhysicsRegionTool', **kwargs):
kwargs.setdefault("RegionName", 'Pixel')
volumeList = ['Pixel::siLog', 'Pixel::siBLayLog']
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
if geoFlags.Run() == "RUN2" or (geoFlags.Run() == "UNDEFINED"
and geoFlags.isIBL()):
volumeList += ['Pixel::dbmDiamondLog']
kwargs.setdefault("VolumeList", volumeList)
kwargs.setdefault("ElectronCut", 0.05)
kwargs.setdefault("PositronCut", 0.05)
kwargs.setdefault("GammaCut", 0.05)
return CfgMgr.RegionCreator(name, **kwargs)
def toolInDetVKalMultiVxInJetTool(name, useBTagFlagsDefaults = True, **options):
"""Sets up a InDetVKalMultiVxInJetTool tool and returns it.
The following options have BTaggingFlags defaults:
OutputLevel default: BTaggingFlags.OutputLevel
getNegativeTail default: False
ConeForTag default: 1.0
MultiVertex default: True
input: name: The name of the tool (should be unique).
useBTagFlagsDefaults : Whether to use BTaggingFlags defaults for options that are not specified.
**options: Python dictionary with options for the tool.
output: The actual tool, which can then by added to ToolSvc via ToolSvc += output. Note however
that this tool also needs to be added to the main B-tagging tool."""
if useBTagFlagsDefaults:
defaults = { 'OutputLevel' : BTaggingFlags.OutputLevel,
'getNegativeTail' : False,
'ExistIBL' : geoFlags.isIBL(),
'ConeForTag' : 1.0,
'MultiVertex' : True }
for option in defaults:
options.setdefault(option, defaults[option])
options['name'] = name
from InDetVKalVxInJetTool.InDetVKalVxInJetToolConf import InDet__InDetVKalVxInJetTool
return InDet__InDetVKalVxInJetTool(**options)
def toolInDetVKalVxNegativeTagInJetTool(name,
useBTagFlagsDefaults=True,
**options):
"""Sets up a InDetVKalVxNegativeTagInJetTool tool and returns it.
The following options have BTaggingFlags defaults:
OutputLevel default: BTaggingFlags.OutputLevel
getNegativeTag default: True
CutA0 default: 2.0 (new tuned cuts for SV0 (Sara))
CutZVrt default: 2.0
CutPixelHits default: 2
input: name: The name of the tool (should be unique).
useBTagFlagsDefaults : Whether to use BTaggingFlags defaults for options that are not specified.
**options: Python dictionary with options for the tool.
output: The actual tool, which can then by added to ToolSvc via ToolSvc += output. Note however
that this tool also needs to be added to the main B-tagging tool."""
if useBTagFlagsDefaults:
defaults = {
'OutputLevel': BTaggingFlags.OutputLevel,
'ExistIBL': geoFlags.isIBL(),
# 'TrackSummaryTool' : None,
'getNegativeTag': True,
'CutA0': 2.0,
'CutZVrt': 2.0,
'CutPixelHits': 2
}
for option in defaults:
options.setdefault(option, defaults[option])
options['name'] = name
from InDetVKalVxInJetTool.InDetVKalVxInJetToolConf import InDet__InDetVKalVxInJetTool
return InDet__InDetVKalVxInJetTool(**options)
def toolInDetVKalMultiVxInJetTool(name, useBTagFlagsDefaults = True, **options):
"""Sets up a InDetVKalMultiVxInJetTool tool and returns it.
The following options have BTaggingFlags defaults:
OutputLevel default: BTaggingFlags.OutputLevel
getNegativeTail default: False
ConeForTag default: 1.0
MultiVertex default: True
input: name: The name of the tool (should be unique).
useBTagFlagsDefaults : Whether to use BTaggingFlags defaults for options that are not specified.
**options: Python dictionary with options for the tool.
output: The actual tool, which can then by added to ToolSvc via ToolSvc += output. Note however
that this tool also needs to be added to the main B-tagging tool."""
if useBTagFlagsDefaults:
defaults = { 'OutputLevel' : BTaggingFlags.OutputLevel,
'getNegativeTail' : False,
'ExistIBL' : geoFlags.isIBL(),
'ConeForTag' : 1.0,
'MultiVertex' : True }
for option in defaults:
options.setdefault(option, defaults[option])
options['name'] = name
from InDetVKalVxInJetTool.InDetVKalVxInJetToolConf import InDet__InDetVKalVxInJetTool
return InDet__InDetVKalVxInJetTool(**options)
def toolInDetVKalVxNegativeTagInJetTool(name, useBTagFlagsDefaults = True, **options):
"""Sets up a InDetVKalVxNegativeTagInJetTool tool and returns it.
The following options have BTaggingFlags defaults:
OutputLevel default: BTaggingFlags.OutputLevel
getNegativeTag default: True
CutA0 default: 2.0 (new tuned cuts for SV0 (Sara))
CutZVrt default: 2.0
CutPixelHits default: 2
input: name: The name of the tool (should be unique).
useBTagFlagsDefaults : Whether to use BTaggingFlags defaults for options that are not specified.
**options: Python dictionary with options for the tool.
output: The actual tool, which can then by added to ToolSvc via ToolSvc += output. Note however
that this tool also needs to be added to the main B-tagging tool."""
if useBTagFlagsDefaults:
defaults = { 'OutputLevel' : BTaggingFlags.OutputLevel,
'ExistIBL' : geoFlags.isIBL(),
# 'TrackSummaryTool' : None,
'getNegativeTag' : True,
'CutA0' : 2.0,
'CutZVrt' : 2.0,
'CutPixelHits' : 2 }
for option in defaults:
options.setdefault(option, defaults[option])
options['name'] = name
from InDetVKalVxInJetTool.InDetVKalVxInJetToolConf import InDet__InDetVKalVxInJetTool
return InDet__InDetVKalVxInJetTool(**options)
def generateInDetSensitiveDetectorList():
SensitiveDetectorList = []
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
isUpgrade = geoFlags.Run() == "RUN3" or geoFlags.Run() == "RUN4" or (
geoFlags.Run() == "UNDEFINED" and geoFlags.isSLHC())
isRUN2 = geoFlags.Run() == "RUN2" or (geoFlags.Run() == "UNDEFINED"
and geoFlags.isIBL())
isRUN1 = not (isRUN2 or isUpgrade)
from AthenaCommon.DetFlags import DetFlags
if (isRUN1 or isRUN2) and DetFlags.simulate.BCM_on():
SensitiveDetectorList += ['BCMSensorSD']
#if isRUN2 and DetFlags.simulation.DBM_on():
# SensitiveDetectorList += [ 'DBMSensorSD' ]
if DetFlags.simulate.pixel_on():
if isRUN1 or isRUN2:
SensitiveDetectorList += ['BLMSensorSD']
SensitiveDetectorList += ['PixelSensorSD']
if DetFlags.simulate.SCT_on():
if isUpgrade:
SensitiveDetectorList += ['SLHC_SctSensorSD']
else:
SensitiveDetectorList += ['SctSensorSD']
if DetFlags.simulate.TRT_on() and not isUpgrade:
SensitiveDetectorList += ['TRTSensitiveDetector']
return SensitiveDetectorList
def getIDETEnvelope(name="IDET", **kwargs):
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
isUpgrade = geoFlags.Run() == "RUN3" or geoFlags.Run() == "RUN4" or (
geoFlags.Run() == "UNDEFINED" and geoFlags.isSLHC())
isRUN2 = geoFlags.Run() == "RUN2" or (geoFlags.Run() == "UNDEFINED"
and geoFlags.isIBL())
isRUN1 = not (isRUN2 or isUpgrade)
kwargs.setdefault("DetectorName", "IDET")
innerRadius = 37. * mm # RUN1 default
if isRUN2:
innerRadius = 28.9 * mm #29.15*mm
if isUpgrade:
innerRadius = 32.15 * mm
kwargs.setdefault("InnerRadius", innerRadius)
kwargs.setdefault("OuterRadius", 1.148 * m)
kwargs.setdefault("dZ", 347.5 * cm)
SubDetectorList = []
from AthenaCommon.DetFlags import DetFlags
if DetFlags.geometry.pixel_on():
SubDetectorList += ['Pixel']
if DetFlags.geometry.SCT_on():
SubDetectorList += ['SCT']
if DetFlags.geometry.TRT_on() and not isUpgrade:
SubDetectorList += ['TRT']
SubDetectorList += ['IDetServicesMat']
kwargs.setdefault("SubDetectors", SubDetectorList)
return CfgMgr.CylindricalEnvelope(name, **kwargs)
def __init__(self, name="L1MuctpiTool"):
LVL1MUCTPI__L1MuctpiTool.__init__(self, name)
# Create a logger:
from AthenaCommon.Logging import logging
logger = logging.getLogger("L1MuctpiTool")
# Set properties of the LUT overlap handling:
self.OverlapStrategyName = "LUT"
self.DumpLUT = False
self.LUTXMLFile = "UNDEFINED"
self.RunPeriod = "UNDEFINED"
self.FlaggingMode = False
self.MultiplicityStrategyName = "INCLUSIVE"
# Decide which LUT to use, based on which run we are simulating:
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
if (geoFlags.Run() == "RUN1") or ((geoFlags.Run() == "UNDEFINED") and
(geoFlags.isIBL() == False)):
self.LUTXMLFile = "TrigConfMuctpi/data10_7TeV.periodI.physics_Muons.MuCTPI_LUT.NoBEOverlaps_composedEF.v002.xml"
self.RunPeriod = "RUN1"
logger.info(
"Configuring MuCTPI simulation with Run 1 configuration file:")
logger.info(
" TrigConfMuctpi/data10_7TeV.periodI.physics_Muons.MuCTPI_LUT.NoBEOverlaps_composedEF.v002.xml"
)
logger.info(" with a RunPeriod=RUN1")
elif (geoFlags.Run() == "RUN2") or ((geoFlags.Run() == "UNDEFINED") and
(geoFlags.isIBL() == True)):
self.LUTXMLFile = "TrigConfMuctpi/data10_7TeV.periodI.physics_Muons.MuCTPI_LUT.NoBEOverlaps_composedEF.v002_modifiedBB.xml"
self.RunPeriod = "RUN2"
logger.info(
"Configuring MuCTPI simulation with Run 2 configuration file:")
logger.info(
" TrigConfMuctpi/data10_7TeV.periodI.physics_Muons.MuCTPI_LUT.NoBEOverlaps_composedEF.v002_modifiedBB.xml"
)
logger.info(" with a RunPeriod=RUN2")
else:
self.LUTXMLFile = "TrigConfMuctpi/data10_7TeV.periodI.physics_Muons.MuCTPI_LUT.NoBEOverlaps_composedEF.v002_modifiedBB.xml"
self.RunPeriod = "RUN2"
logger.warning(
"Couldn't determine which run to simulate, using Run 2 configuration file:"
)
logger.warning(
" TrigConfMuctpi/data10_7TeV.periodI.physics_Muons.MuCTPI_LUT.NoBEOverlaps_composedEF.v002_modifiedBB.xml"
)
logger.warning(" with a RunPeriod=RUN2")
pass
# Set properties for NIM outputs ot L1Topo conversion from RoI to eta/phi
self.GeometryXMLFile = "TrigConfMuctpi/TestMioctGeometry_2016_05_30_CS_2600573263.xml"
# Turn on the NIM output creation by default:
self.DoNIMOutput = True
# The bit settings were extracted from here:
# https://savannah.cern.ch/bugs/?90300#comment14
self.NIMBarrelBit = 29
self.NIMEndcapBit = 30
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 SurfaceChargesTool(name="SurfaceChargesTool", **kwargs):
if hasattr(digitizationFlags, "doBichselSimulation") and digitizationFlags.doBichselSimulation():
kwargs.setdefault("PixelBarrelChargeTool","PixelBarrelBichselChargeTool")
kwargs.setdefault("PixelECChargeTool","PixelECBichselChargeTool")
kwargs.setdefault("IblPlanarChargeTool","IblPlanarBichselChargeTool")
kwargs.setdefault("Ibl3DChargeTool","Ibl3DBichselChargeTool")
else:
kwargs.setdefault("PixelBarrelChargeTool","PixelBarrelChargeTool")
kwargs.setdefault("PixelECChargeTool","PixelECChargeTool")
kwargs.setdefault("IblPlanarChargeTool","IblPlanarChargeTool")
kwargs.setdefault("Ibl3DChargeTool","Ibl3DChargeTool")
kwargs.setdefault("DBMChargeTool","DBMChargeTool") # No separate implementation when using Bichsel model
kwargs.setdefault("doITk", GeometryFlags.isSLHC())
return CfgMgr.SurfaceChargesTool(name, **kwargs)
def SurfaceChargesTool(name="SurfaceChargesTool", **kwargs):
if _doBichsel:
kwargs.setdefault("PixelBarrelChargeTool", "PixelBarrelBichselChargeTool")
kwargs.setdefault("PixelECChargeTool", "PixelECBichselChargeTool")
kwargs.setdefault("IblPlanarChargeTool", "IblPlanarBichselChargeTool")
kwargs.setdefault("Ibl3DChargeTool", "Ibl3DBichselChargeTool")
else:
kwargs.setdefault("PixelBarrelChargeTool", "PixelBarrelChargeTool")
kwargs.setdefault("PixelECChargeTool", "PixelECChargeTool")
kwargs.setdefault("IblPlanarChargeTool", "IblPlanarChargeTool")
kwargs.setdefault("Ibl3DChargeTool", "Ibl3DChargeTool")
kwargs.setdefault("DBMChargeTool", "DBMChargeTool") # No separate implementation when using Bichsel model
kwargs.setdefault("doITk", GeometryFlags.isSLHC())
return CfgMgr.SurfaceChargesTool(name, **kwargs)
def getTRTSensitiveDetector(name="TRTSensitiveDetector", **kwargs):
bare_collection_name = "TRTUncompressedHits"
mergeable_collection_suffix = "_G4"
merger_input_property = "TRTUncompressedHits"
hits_collection_name = generate_mergeable_collection_name(
bare_collection_name, mergeable_collection_suffix,
merger_input_property)
logicalVolumeNames = ["TRT::Gas", "TRT::GasMA"]
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
if geoFlags.Run() == "RUN2":
## RUN2 configuration
logicalVolumeNames += [
"TRT::Gas_Ar", "TRT::GasMA_Ar", "TRT::Gas_Kr", "TRT::GasMA_Kr"
]
kwargs.setdefault("LogicalVolumeNames", logicalVolumeNames)
kwargs.setdefault("OutputCollectionNames", [hits_collection_name])
return CfgMgr.TRTSensitiveDetectorTool(name, **kwargs)
def toolInDetVKalVxInJetTool(name, useBTagFlagsDefaults = True, **options):
"""Sets up a InDetVKalVxInJetTool tool and returns it.
The following options have BTaggingFlags defaults:
TrackSummaryTool default: None (not needed for b-tagging)
OutputLevel default: BTaggingFlags.OutputLevel
input: name: The name of the tool (should be unique).
useBTagFlagsDefaults : Whether to use BTaggingFlags defaults for options that are not specified.
**options: Python dictionary with options for the tool.
output: The actual tool, which can then by added to ToolSvc via ToolSvc += output. Note however
that this tool also needs to be added to the main B-tagging tool."""
if useBTagFlagsDefaults:
defaults = { 'OutputLevel' : BTaggingFlags.OutputLevel,
'ExistIBL' : geoFlags.isIBL(),
# 'TrackSummaryTool' : None }
}
for option in defaults:
options.setdefault(option, defaults[option])
options['name'] = name
from InDetVKalVxInJetTool.InDetVKalVxInJetToolConf import InDet__InDetVKalVxInJetTool
return InDet__InDetVKalVxInJetTool(**options)
def getPixelDetectorTool(name="PixelDetectorTool", **kwargs):
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags
if GeometryFlags.isSLHC():
kwargs.setdefault("ServiceBuilderTool", "InDetServMatBuilderToolSLHC")
else:
kwargs.setdefault("ServiceBuilderTool", "")
from AthenaCommon.DetFlags import DetFlags
if DetFlags.digitize.pixel_on() or DetFlags.haveRDO.pixel_on(
) or DetFlags.haveRIO.pixel_on():
# PixelLorentzAngleSvc needed for digi and reco
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, 'PixelLorentzAngleSvc'):
from SiLorentzAngleSvc.SiLorentzAngleSvcConf import SiLorentzAngleSvc
PixelLorentzAngleSvc = SiLorentzAngleSvc(
name="PixelLorentzAngleSvc",
SiConditionsServices=None,
UseMagFieldSvc=False,
DetectorName="Pixel")
ServiceMgr += PixelLorentzAngleSvc
kwargs.setdefault("LorentzAngleSvc", "PixelLorentzAngleSvc")
else:
# PixelLorentzAngleSvc not needed for simulation
kwargs.setdefault("LorentzAngleSvc", "")
return CfgMgr.PixelDetectorTool(name, **kwargs)
def toolInDetVKalVxInJetTool(name, useBTagFlagsDefaults=True, **options):
"""Sets up a InDetVKalVxInJetTool tool and returns it.
The following options have BTaggingFlags defaults:
TrackSummaryTool default: None (not needed for b-tagging)
OutputLevel default: BTaggingFlags.OutputLevel
input: name: The name of the tool (should be unique).
useBTagFlagsDefaults : Whether to use BTaggingFlags defaults for options that are not specified.
**options: Python dictionary with options for the tool.
output: The actual tool, which can then by added to ToolSvc via ToolSvc += output. Note however
that this tool also needs to be added to the main B-tagging tool."""
if useBTagFlagsDefaults:
defaults = {
'OutputLevel': BTaggingFlags.OutputLevel,
'ExistIBL': geoFlags.isIBL(),
# 'TrackSummaryTool' : None }
}
for option in defaults:
options.setdefault(option, defaults[option])
options['name'] = name
from InDetVKalVxInJetTool.InDetVKalVxInJetToolConf import InDet__InDetVKalVxInJetTool
return InDet__InDetVKalVxInJetTool(**options)
TemperatureFolder="/PIXEL/HLT/DCS/TEMPERATURE",
HVFolder="/PIXEL/HLT/DCS/HV",
TemperatureFieldName="temperature",
HVFieldName="HV")
else:
if not conddb.folderRequested('/PIXEL/DCS/TEMPERATURE'):
conddb.addFolder("DCS_OFL", "/PIXEL/DCS/TEMPERATURE")
if not conddb.folderRequested('/PIXEL/DCS/HV'):
conddb.addFolder("DCS_OFL", "/PIXEL/DCS/HV")
if not conddb.folderRequested('/PIXEL/DCS/FSMSTATUS'):
conddb.addFolder("DCS_OFL", "/PIXEL/DCS/FSMSTATUS")
if not conddb.folderRequested('/PIXEL/DCS/FSMSTATE'):
conddb.addFolder("DCS_OFL", "/PIXEL/DCS/FSMSTATE")
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
if (rec.doMonitoring() and globalflags.DataSource() == 'data'
and geoFlags.Run() == "RUN2"
and conddb.dbdata == "CONDBR2"):
# geoFlags.isIBL() == True may work too instead of geoFlags.Run() == "RUN2"
if not conddb.folderRequested('/PIXEL/DCS/PIPES'):
conddb.addFolder("DCS_OFL", "/PIXEL/DCS/PIPES")
if not conddb.folderRequested('/PIXEL/DCS/LV'):
conddb.addFolder("DCS_OFL", "/PIXEL/DCS/LV")
if not conddb.folderRequested('/PIXEL/DCS/HVCURRENT'):
conddb.addFolder("DCS_OFL", "/PIXEL/DCS/HVCURRENT")
# not used anymore
# if not conddb.folderRequested('/PIXEL/DCS/PLANTS'):
# conddb.addFolder("DCS_OFL","/PIXEL/DCS/PLANTS")
InDetPixelDCSSvc = PixelDCSSvc(
RegisterCallback=TRUE,
TemperatureFolder="/PIXEL/DCS/TEMPERATURE",
"/TRT/Cond/StatusHT")
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Cond/Status", "/TRT/Cond/Status")
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Cond/StatusPermanent",
"/TRT/Cond/StatusPermanent")
# Pixel module distortions
conddb.addFolderSplitOnline("INDET", "/Indet/Onl/PixelDist",
"/Indet/PixelDist")
# IBL stave distortions
conddb.addFolderSplitOnline("INDET", "/Indet/Onl/IBLDist", "/Indet/IBLDist")
# Adding protection against new dynamic folder scheme;
# In future we might want to add also to MC DB
# Solution below is not pretty but in response to JIRA ATLASSIM-2746
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
if geoFlags.useDynamicAlignFolders():
conddb.addFolderSplitOnline("INDET", "/Indet/Onl/AlignL1/ID",
"/Indet/AlignL1/ID")
conddb.addFolderSplitOnline("INDET", "/Indet/Onl/AlignL2/PIX",
"/Indet/AlignL2/PIX")
conddb.addFolderSplitOnline("INDET", "/Indet/Onl/AlignL2/SCT",
"/Indet/AlignL2/SCT")
conddb.addFolderSplitOnline("INDET", "/Indet/Onl/AlignL3",
"/Indet/AlignL3")
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/AlignL1/TRT",
"/TRT/AlignL1/TRT")
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/AlignL2", "/TRT/AlignL2")
else:
conddb.addFolderSplitOnline("INDET", "/Indet/Onl/Align", "/Indet/Align")
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Align", "/TRT/Align")
def Initiate(ConfInstance=None):
"""Sets up the basic global tools required for B-Tagging. This function is idempotent; it will not run again if it has run once. It is
typically called by other functions in this file to make sure the basic global tools exist.
The function returns True if B-Tagging is initialized or has been before. It returns False if it B-Tagging has been switched off for various
reasons (these are checked in the checkFlagsUsingBTaggingFlags function).
If the B-tagging calibration broker has been registered we assume initiation has already been performed; this allows users to setup their own initiation code."""
if ConfInstance is None:
from BTagging.BTaggingConfiguration import getConfiguration
ConfInstance = getConfiguration()
if ConfInstance._Initialized:
return True
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
# The Run() parameter only exists for ATLAS-R1(...) and ATLAS-R2(...) geo tags,
# not for ATLAS-GEO(...) and ATLAS-IBL(...) ones. Hence if Run() is undefined,
# presence of IBL is used to switch between Run1/Run2
if (geoFlags.Run() == "RUN1" or (geoFlags.Run() == "UNDEFINED" and geoFlags.isIBL() == False)):
print ConfInstance.BTagTag()+' - INFO - Setting up Run 1 configuration'
BTaggingFlags.JetFitterNN=True
BTaggingFlags.SV2 =True
BTaggingFlags.JetFitterCharm=False
if ConfInstance.getTool("BTagCalibrationBrokerTool"):
print ConfInstance.BTagTag()+' - INFO - BTagCalibrationBrokerTool already exists prior to default initialization; assuming user set up entire initialization him/herself. Note however that if parts of the initalization were not set up, and a later tool requires them, they will be set up at that point automatically with default settings.'
ConfInstance._Initialized = True
return True
print ConfInstance.BTagTag()+' - INFO - Initializing default basic tools'
if ConfInstance.checkFlagsUsingBTaggingFlags():
#Print the flags
BTaggingFlags.Print()
#If debugging do a check of the tool collection structure
if(BTaggingFlags.OutputLevel < 3):
from BTagging.BTaggingConfiguration import checkToolCollectionStructure
checkToolCollectionStructure()
#Get TheTruthCollectionKey from input
TheTruthCollectionKey = 'TruthEvents'
BTaggingFlags.RetagJets = BTaggingFlags.Jets
if BTaggingFlags.AutoInspectInputFile:
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat == 'pool':
try:
from RecExConfig.InputFilePeeker import inputFileSummary
BTaggingFlags.RetagJets = []
for i in inputFileSummary['eventdata_items']:
if i[0] == 'McEventCollection':
# TheTruthCollectionKey = i[1] # disable taking the name from the input file?
pass
elif i[0] == 'JetCollection':
jetC1 = (i[1]).replace('AODJets','')
jetC = jetC1.replace('Jets','')
if jetC in BTaggingFlags.Jets:
BTaggingFlags.RetagJets += [ jetC ]
except Exception, err:
print ConfInstance.BTagTag()+' - WARNING - Automatic inspection of input file failed (file too old?)'
print ConfInstance.BTagTag()+' - Using ', TheTruthCollectionKey, ' as truth key'
# print ConfInstance.BTagTag()+' - Re-tagging these jet collections: ', BTaggingFlags.RetagJets
#
# ============ Setup basic services
#
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
if not hasattr(svcMgr, 'THistSvc'):
from GaudiSvc.GaudiSvcConf import THistSvc
svcMgr += THistSvc()
if not 'topSequence' in dir():
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
#
# ========== Add tools now
#
# -------------- Calibration Broker --------------
from AthenaCommon.AppMgr import ToolSvc
from AthenaCommon.Resilience import treatException,protectedInclude
if ConfInstance._name == "":
protectedInclude("BTagging/BTagCalibBroker_jobOptions.py") # New file which includes the file from JetCalibration and also registers it via registerTool() so it will be recognized by the various addTool() functions.
BTagCalibrationBrokerTool = ConfInstance.getTool("BTagCalibrationBrokerTool") # In case this variable is needed
elif ConfInstance._name == "Trig":
protectedInclude("BTagging/BTagCalibBroker_Trig_jobOptions.py")
BTagCalibrationBrokerTool = ConfInstance.getTool("BTagCalibrationBrokerTool")
else:
print ConfInstance.BTagTag()+' - ERROR - Configuration instance "'+ConfInstance._name+'" has no calibration broker setup specified!'
raise RuntimeError
# -------------- \Calibration Broker --------------
global BTagJetTruthMatching
global BTagLeptonTruthTool
global thisBTagLabeling
# FF: disable cone-based labelling as this is now being done as a part of jet reconstruction
BTagJetTruthMatching = None
BTagLeptonTruthTool = None
thisBTagLabeling = None
# -- to label jets with truth information
#from JetRec.JetRecFlags import jetFlags
#if jetFlags.useTruth():
# # Jet Label
# if BTaggingFlags.jetTruthMatching == 'matchQuark' or BTaggingFlags.jetTruthMatching == 'jetTrackTruthMatching':
# BTagJetTruthMatching = addTool("BTagJetTruthMatching",
# ToolSvc = ToolSvc,
# Verbose = BTaggingFlags.OutputLevel < 3,
# options = {'subtype' : BTaggingFlags.jetTruthMatching},
# SuppressNonCloneWarning=True)
# BTagJetTruthMatching.McEventCollection = TheTruthCollectionKey
# else:
# BTagJetTruthMatching = None
# print("#BTAG# - WARNING - BTaggingFlags.jetTruthMatching has unsupported value!")
# # Lepton Truth Match
# #BTagLeptonTruthTool = addTool('BTagLeptonTruthTool', ToolSvc = ToolSvc, Verbose = BTaggingFlags.OutputLevel < 3)
# #BTagLeptonTruthTool.McEventCollection = TheTruthCollectionKey
# BTagLeptonTruthTool = None # TEMPORARY: BTagLeptonTruthTool not implemented yet?
# # Labeling tool
# thisBTagLabeling = addTool("thisBTagLabeling", ToolSvc = ToolSvc, Verbose = BTaggingFlags.OutputLevel < 3,
# options = {'JetTruthMatchTool' : BTagJetTruthMatching,
# #'LeptonTruthTool' : BTagLeptonTruthTool}, TEMPORARY: BTagLeptonTruthTool not implemented yet?
# },
# SuppressNonCloneWarning=True)
#else:
# BTagJetTruthMatching = None
# BTagLeptonTruthTool = None
# thisBTagLabeling = None
# NOTE: These variables no longer serve any purpose, since any tool can be retrieved using getTool
# -- for reference mode:
if BTaggingFlags.Runmodus == 'reference':
svcMgr.THistSvc.Output += ["RefFile DATAFILE='BTagCalibALL.root' OPT='RECREATE'"]
#for key in BTaggingFlags.Jets:
# for tagger in ['JetProb','IP1D','IP2D','IP2DSpc','IP3D','IP3DSpc','SV1','SV2','SoftMu','SoftEl','JetFitterTagNN','JetFitterCOMBNN']:
# if BTaggingFlags.IsEnabled(tagger):
# RefileName = "BTaggingRef"+tagger+key+".root"
# svcMgr.THistSvc.Output += ["RefFile"+tagger+key+" DATAFILE='"+RefileName+"' OPT='RECREATE'"]
ConfInstance._Initialized = True
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
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)
# Configuration functions for IP2DTag
# Author: Wouter van den Wollenberg (2013-2014)
from BTagging.BTaggingFlags import BTaggingFlags
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
btagrun1 = (geoFlags.Run() == "RUN1" or (geoFlags.Run() == "UNDEFINED" and geoFlags.isIBL() == False))
metaIP2DTag = { 'IsATagger' : True,
'xAODBaseName' : 'IP2D',
'DependsOn' : ['AtlasExtrapolator',
'BTagTrackToVertexTool',
'InDetVKalVxInJetTool',
'BTagFullLinearizedTrackFactory',
'BTagTrackToVertexIPEstimator',
'IP2DDetailedTrackGradeFactory',
'IP2DBasicTrackGradeFactory',
'SVForIPTool_IP2D',
'IP2DTrackSelector',
'IP2DNewLikelihoodTool'],
'PassByPointer' : {'SVForIPTool' : 'SVForIPTool_IP2D',
'trackSelectorTool' : 'IP2DTrackSelector',
'trackGradeFactory' : 'IP2DDetailedTrackGradeFactory',
# 'trackToVertexTool' : 'BTagTrackToVertexTool',
'TrackToVertexIPEstimator' : 'BTagTrackToVertexIPEstimator',
'LikelihoodTool' : 'IP2DNewLikelihoodTool'},
# 'PassByName' : {'SecVxFinderNameForV0Removal' : 'InDetVKalVxInJetTool',
# 'SecVxFinderNameForIPSign' : 'InDetVKalVxInJetTool'},
# 'PassTracksAs' : 'trackAssociation',
'PassTracksAs' : 'trackAssociationName',
'JetCollectionList' : 'jetCollectionList',
'ToolCollection' : 'IP2DTag' }
#############rec.doApplyAODFix.set_Value_and_Lock(False)
include("RecExCommon/RecExCommon_topOptions.py")
from AthenaCommon.AlgSequence import AlgSequence
algSeq = AlgSequence()
##########################################################################################################################################################
##########################################################################################################################################################
### GEO Business
from AthenaCommon.GlobalFlags import globalflags
print "detDescr from global flags= "+str(globalflags.DetDescrVersion)
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
print "geoFlags.Run() = "+geoFlags.Run()
print "geoFlags.isIBL() = "+str( geoFlags.isIBL() )
##########################################################################################################################################################
##########################################################################################################################################################
### VD: this is if you want to re-tag with another calibration file
from BTagging.BTaggingFlags import BTaggingFlags
#### if the new file is already in the datatbase: simple edit the name
#BTaggingFlags.CalibrationTag = 'BTagCalibRUN12-08-07'
#### if you want to use your own calibration file use this part below
#BTaggingFlags.CalibrationFromLocalReplica = True
#BTaggingFlags.CalibrationFolderRoot = '/GLOBAL/BTagCalib/'
#BTaggingFlags.CalibrationTag = 'Run2DC14' ## '0801C' ##'k0002'
def getATLAS_RegionCreatorList():
regionCreatorList = []
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
isUpgrade = geoFlags.Run() == "RUN3" or geoFlags.Run() == "RUN4" or (
geoFlags.Run() == "UNDEFINED" and geoFlags.isSLHC())
isRUN2 = geoFlags.Run() == "RUN2" or (geoFlags.Run() == "UNDEFINED"
and geoFlags.isIBL())
from G4AtlasApps.SimFlags import simFlags
from AthenaCommon.DetFlags import DetFlags
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType() == 'cosmics' or \
(simFlags.CavernBG.statusOn and not 'Signal' in simFlags.CavernBG.get_Value() ):
regionCreatorList += [
'SX1PhysicsRegionTool', 'BedrockPhysicsRegionTool',
'CavernShaftsConcretePhysicsRegionTool'
]
#regionCreatorList += ['CavernShaftsAirPhysicsRegionTool'] # Not used currently
if DetFlags.ID_on():
if DetFlags.pixel_on():
regionCreatorList += ['PixelPhysicsRegionTool']
if DetFlags.SCT_on():
regionCreatorList += ['SCTPhysicsRegionTool']
if DetFlags.TRT_on() and not isUpgrade:
regionCreatorList += ['TRTPhysicsRegionTool']
if isRUN2:
regionCreatorList += ['TRT_ArPhysicsRegionTool'
] #'TRT_KrPhysicsRegionTool'
# FIXME dislike the ordering here, but try to maintain the same ordering as in the old configuration.
if DetFlags.bpipe_on():
if simFlags.BeamPipeSimMode.statusOn and simFlags.BeamPipeSimMode(
) != "Normal":
regionCreatorList += ['BeampipeFwdCutPhysicsRegionTool']
if simFlags.ForwardDetectors.statusOn and simFlags.ForwardDetectors(
) == 2:
regionCreatorList += ['FWDBeamLinePhysicsRegionTool']
if DetFlags.Calo_on():
if DetFlags.geometry.LAr_on():
## Shower parameterization overrides the calibration hit flag
if simFlags.LArParameterization.statusOn and simFlags.LArParameterization() > 0 \
and simFlags.CalibrationRun.statusOn and simFlags.CalibrationRun.get_Value() in ['LAr','LAr+Tile','DeadLAr']:
print 'You requested both calibration hits and frozen showers / parameterization in the LAr.'
print ' Such a configuration is not allowed, and would give junk calibration hits where the showers are modified.'
print ' Please try again with a different value of either simFlags.LArParameterization (' + str(
simFlags.LArParameterization(
)) + ') or simFlags.CalibrationRun (' + str(
simFlags.CalibrationRun.get_Value()) + ')'
raise RuntimeError('Configuration not allowed')
if simFlags.LArParameterization() > 0:
regionCreatorList += [
'EMBPhysicsRegionTool', 'EMECPhysicsRegionTool',
'HECPhysicsRegionTool', 'FCALPhysicsRegionTool'
]
# FIXME 'EMBPhysicsRegionTool' used for parametrization also - do we need a second instance??
regionCreatorList += [
'EMECParaPhysicsRegionTool', 'FCALParaPhysicsRegionTool',
'FCAL2ParaPhysicsRegionTool'
]
if simFlags.LArParameterization.get_Value() > 1:
regionCreatorList += [
'PreSampLArPhysicsRegionTool',
'DeadMaterialPhysicsRegionTool'
]
elif simFlags.LArParameterization(
) is None or simFlags.LArParameterization() == 0:
regionCreatorList += [
'EMBPhysicsRegionTool', 'EMECPhysicsRegionTool',
'HECPhysicsRegionTool', 'FCALPhysicsRegionTool'
]
## FIXME _initPR never called for FwdRegion??
#if simFlags.ForwardDetectors.statusOn:
# if DetFlags.geometry.FwdRegion_on():
# regionCreatorList += ['FwdRegionPhysicsRegionTool']
if DetFlags.Muon_on():
regionCreatorList += [
'DriftWallPhysicsRegionTool', 'DriftWall1PhysicsRegionTool',
'DriftWall2PhysicsRegionTool'
]
if simFlags.CavernBG.statusOn and simFlags.CavernBG.get_Value(
) != 'Read' and not (simFlags.RecordFlux.statusOn
and simFlags.RecordFlux()):
regionCreatorList += ['MuonSystemFastPhysicsRegionTool']
return regionCreatorList
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
#
# InDet GeoModel initialization
#
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.JobProperties import jobproperties
from AthenaCommon.DetFlags import DetFlags
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags
if GeometryFlags.isSLHC():
#SLHC specific code
from AthenaCommon.AppMgr import ToolSvc
# Treat CTB separately
if ( jobproperties.Global.DetGeo() == "ctbh8" or jobproperties.Global.DetGeo() == "ctbh6" ):
from AtlasGeoModel import InDetGMCTB
elif ( DetFlags.detdescr.ID_on() ):
from GeoModelSvc.GeoModelSvcConf import GeoModelSvc
GeoModelSvc = GeoModelSvc()
if not hasattr(svcMgr,'InDetGeometryDBSvc'):
from GeometryDBSvc.GeometryDBSvcConf import GeometryDBSvc
svcMgr+=GeometryDBSvc("InDetGeometryDBSvc")
if GeometryFlags.isSLHC():
#SLHC specific code
# General service builder tool for SLHC
from InDetServMatGeoModel.InDetServMatGeoModelConf import InDetServMatBuilderToolSLHC
InDetServMatBuilderToolSLHC = InDetServMatBuilderToolSLHC()
if rn is None:
try:
from G4AtlasApps.SimFlags import simFlags
if simFlags.RunNumber.statusOn:
rn = simFlags.RunNumber()
except:
msg.info("No SimFlags available - looks like HLT job")
if rn is None:
try:
from RecExConfig.AutoConfiguration import GetRunNumber
rn = GetRunNumber()
except:
msg.info("No Run Number available - assume latest cabling")
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
if geoFlags.Run() == "RUN1":
if rn > 219651: # choose RUN2 cabling for old geometry tags starting from 26-MAR-2013
TileCablingType = 4
msg.warning("Forcing RUN2 cabling for run %s with geometry %s" %
(rn, gbltg))
elif geoFlags.Run() == "RUN2":
if (
globalflags.DataSource() != 'data' and rn >= 310000
) or rn >= 343000 or rn < 1: # choose RUN2a cabling for R2 geometry tags starting from 31-Jan-2018
TileCablingType = 5
msg.info(
"Forcing RUN2a (2018) cabling for run %s with geometry %s" %
(rn, gbltg))
else:
TileCablingType = 4
msg.info(
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# Configuration functions for IP2DNegTag
# Author: Wouter van den Wollenberg (2013-2014)
from BTagging.BTaggingFlags import BTaggingFlags
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
from IOVDbSvc.CondDB import conddb
btagrun1 = False
if conddb.dbdata == 'COMP200':
btagrun1 = True
elif conddb.isMC:
btagrun1 = (geoFlags.Run() == "RUN1" or
(geoFlags.Run() == "UNDEFINED" and geoFlags.isIBL() == False))
metaIP2DNegTag = {
'IsATagger':
True,
'xAODBaseName':
'IP2DNeg',
'DependsOn': [
'AtlasExtrapolator', 'BTagTrackToVertexTool', 'InDetVKalVxInJetTool',
'BTagFullLinearizedTrackFactory', 'BTagTrackToVertexIPEstimator',
'IP2DNegNewLikelihoodTool', 'IP2DNegTrackSelector',
'SVForIPTool_IP2DNeg', 'IP2DNegBasicTrackGradeFactory',
'IP2DNegDetailedTrackGradeFactory'
],
'PassByPointer': {
'SVForIPTool': 'SVForIPTool_IP2DNeg',
'trackSelectorTool': 'IP2DNegTrackSelector',
'trackGradeFactory': 'IP2DNegDetailedTrackGradeFactory',
# 'trackToVertexTool' : 'BTagTrackToVertexTool',
def PixelCellDiscriminator(name="PixelCellDiscriminator", **kwargs):
kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
kwargs.setdefault("RndmEngine", "PixelDigitization")
kwargs.setdefault("doITk", GeometryFlags.isSLHC())
return CfgMgr.PixelCellDiscriminator(name, **kwargs)
"AtlasDerivation"):
rec.doApplyAODFix.set_Value_and_Lock(False)
include("RecExCommon/RecExCommon_topOptions.py")
from AthenaCommon.AlgSequence import AlgSequence
algSeq = AlgSequence()
### GEO Business
from AthenaCommon.GlobalFlags import globalflags
print "detDescr from global flags= " + str(globalflags.DetDescrVersion)
from AtlasGeoModel.InDetGMJobProperties import GeometryFlags as geoFlags
print "geoFlags.Run() = " + geoFlags.Run()
print "geoFlags.isIBL() = " + str(geoFlags.isIBL())
###############################################################
### THIS is the full retagging configuration
### this is if you want to re-tag with another calibration file
from BTagging.BTaggingConfiguration import getConfiguration
from BTagging.BTaggingFlags import BTaggingFlags
#### if the new file is already in the datatbase: simple edit the name
#BTaggingFlags.CalibrationTag = 'BTagCalibRUN12-08-18'
#### if you want to use your own calibration file use this part below
if RETAG & (LocalCalibSuffix != 'WHATEVER'):
BTaggingFlags.CalibrationFromLocalReplica = True
BTaggingFlags.TrigCalibrationFolderRoot = '/GLOBAL/TrigBTagCalib/'
BTaggingFlags.TrigCalibrationTag = LocalCalibSuffix
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")
# HACK For PixelCablingSvc configuration
# from PixelCabling.PixelCablingConf import PixelCablingSvc
# pixelCablingSvc = PixelCablingSvc()
# ServiceMgr += pixelCablingSvc
# protectedInclude ("PixelCabling/SelectPixelMap.py" )
# include.block( "PixelCabling/SelectPixelMap.py" )
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")
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)
elif GeometryFlags.isSLHC():
kwargs.setdefault("doITk", True)
LVL1Latency = [255, 255, 255, 255, 255, 16, 255]
ToTMinCut = [0, 0, 0, 0, 0, 0, 0]
ApplyDupli = [0, 0, 0, 0, 0, 0, 0]
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, 4, 4, 4, 4, 0]
ApplyDupli = [True, True, True, True, True, True]
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)
