def configure(self):
mlog = logging.getLogger( 'LArDigitGetter.py::configure :' )
mlog.info ('entering')
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
try:
from AthenaCommon import CfgGetter
# if using new scheme for pileup
from Digitization.DigitizationFlags import digitizationFlags
if digitizationFlags.doXingByXingPileUp():
# Defined in LArDigitizationConfig.py
job.PileUpToolsAlg.PileUpTools += [ CfgGetter.getPrivateTool("LArPileUpTool", checkType=True) ]
job.PileUpToolsAlg.PileUpTools["LArPileUpTool"].DigitContainer = self.outputKey()
job.PileUpToolsAlg.PileUpTools["LArPileUpTool"].DigitContainer_DigiHSTruth = self.outputKey_DigiHSTruth()
job.PileUpToolsAlg.PileUpTools["LArPileUpTool"].DoDigiTruthReconstruction = digitizationFlags.doDigiTruth()
else:
# Defined in LArDigitizationConfig.py
print "call CfgGetter for digitmaker1 "
job += CfgGetter.getAlgorithm("digitmaker1", tryDefaultConfigurable=True)
job.digitmaker1.LArPileUpTool.DigitContainer = self.outputKey()
job.digitmaker1.LArPileUpTool.DigitContainer_DigiHSTruth = self.outputKey_DigiHSTruth()
#job.digitmaker1.LArPileUpTool.DigitContainer_DigiHSTruth = "LArDigitContainer_DigiHSTruth"
job.digitmaker1.LArPileUpTool.DoDigiTruthReconstruction = digitizationFlags.doDigiTruth()
# if pileup or overlay
from AthenaCommon.DetFlags import DetFlags
from LArDigitization.LArDigitizationConfig import isOverlay
if DetFlags.pileup.LAr_on() or isOverlay():
from AthenaCommon.AppMgr import ServiceMgr
# Defined in LArDigitizationConfig.py
ServiceMgr.PileUpMergeSvc.Intervals += [ CfgGetter.getPrivateTool("LArRangeEM", checkType=True) ]
ServiceMgr.PileUpMergeSvc.Intervals += [ CfgGetter.getPrivateTool("LArRangeHEC", checkType=True) ]
ServiceMgr.PileUpMergeSvc.Intervals += [ CfgGetter.getPrivateTool("LArRangeFCAL", checkType=True) ]
except Exception as configException:
print configException
print "ERROR Problem with configuration"
return True
from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigitTool
MuonRdoToMuonDigitTool = MuonRdoToMuonDigitTool("TgcRdoToTgcDigit",
DecodeMdtRDO=False,
DecodeRpcRDO=False,
DecodeTgcRDO=True,
DecodeCscRDO=False)
ToolSvc += MuonRdoToMuonDigitTool
from AthenaCommon import CfgGetter
from TgcOverlay.TgcOverlayConf import TgcOverlay
job += TgcOverlay()
job.TgcOverlay.mainInputTGC_Name = "TGC_DIGITS"
job.TgcOverlay.overlayInputTGC_Name = "TGC_DIGITS"
#job.TgcOverlay.DigitizationTool = CfgGetter.getPrivateTool("TgcDigitizationTool", checkType=True)
job.TgcOverlay.DigitizationTool = CfgGetter.getPrivateTool(
"Tgc_OverlayDigitizationTool")
job.TgcOverlay.ConvertRDOToDigitTool = MuonRdoToMuonDigitTool
#job.TgcOverlay.DigitizationTool.EvtStore = job.TgcOverlay.MCStore
job.TgcOverlay.ConvertRDOToDigitTool.RetrievePrivateCopy = True
job.TgcOverlay.ConvertRDOToDigitTool.DataStore = job.TgcOverlay.DataStore
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.doSignal == True:
job.TgcOverlay.CopyObject = True
from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import TgcDigitToTgcRDO
job += TgcDigitToTgcRDO()
job.TgcDigitToTgcRDO.Store = job.TgcOverlay.OutputStore
## User algorithms
from AthenaCommon.AppMgr import ServiceMgr
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc("THistSvc")
#ServiceMgr.THistSvc.Output = ["atlasTest DATAFILE='atlasTest.muons.histo.root' OPT='RECREATE'"];
ServiceMgr.THistSvc.Output = ["truth DATAFILE='truth.root' OPT='RECREATE'"];
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon import CfgGetter
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TruthTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("EvgenTruthTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("CaloEntryLayerTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("MuonEntryLayerTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("MuonExitLayerTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("PixelHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("SCT_HitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TrtHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("EMBHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("EMECHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("FCALHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("HECHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TileHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools["TileHitsTestTool"].TestMBTS=True
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("MDTHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("RPCHitsTestTool", checkType=True)]
def getPileUpMergeSvc(name="PileUpMergeSvc", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
if not digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
IntervalsList = []
from AthenaCommon.DetFlags import DetFlags
## Truth information
if DetFlags.pileup.Truth_on():
IntervalsList += [
CfgGetter.getPrivateTool("TruthJetRange", checkType=True)
]
if DetFlags.writeRDOPool.Muon_on(
): #possibly this should be digitize.Muon_on()
IntervalsList += [
CfgGetter.getPrivateTool("TrackRange", checkType=True)
]
if DetFlags.writeRDOPool.Calo_on(
): #possibly this should be digitize.Calo_on()
IntervalsList += [
CfgGetter.getPrivateTool("CalibRange", checkType=True)
]
## Forward Detector Digitization
if DetFlags.pileup.Lucid_on():
IntervalsList += [
CfgGetter.getPrivateTool("LucidRange", checkType=True)
]
if DetFlags.pileup.ZDC_on():
IntervalsList += [
CfgGetter.getPrivateTool("ZdcRange", checkType=True)
]
if DetFlags.pileup.ALFA_on():
IntervalsList += [
CfgGetter.getPrivateTool("ALFARange", checkType=True)
]
if DetFlags.pileup.AFP_on():
IntervalsList += [
CfgGetter.getPrivateTool("AFPRange", checkType=True)
]
## Inner Detector Digitization
if DetFlags.pileup.BCM_on():
IntervalsList += [
CfgGetter.getPrivateTool("BCM_Range", checkType=True)
]
if DetFlags.pileup.pixel_on():
if 'doFastPixelDigi' in digitizationFlags.experimentalDigi():
IntervalsList += [
CfgGetter.getPrivateTool("FastPixelRange", checkType=True)
]
else:
IntervalsList += [
CfgGetter.getPrivateTool("PixelRange", checkType=True)
]
if DetFlags.pileup.SCT_on():
if 'doFastSCT_Digi' in digitizationFlags.experimentalDigi():
IntervalsList += [
CfgGetter.getPrivateTool("FastSCTRange", checkType=True)
]
else:
IntervalsList += [
CfgGetter.getPrivateTool("SiliconRange", checkType=True)
]
if DetFlags.pileup.TRT_on():
if 'doFastTRT_Digi' in digitizationFlags.experimentalDigi():
IntervalsList += [
CfgGetter.getPrivateTool("FastTRTRange", checkType=True)
]
else:
IntervalsList += [
CfgGetter.getPrivateTool("TRTRange", checkType=True)
]
## Calo Digitization
from LArDigitization.LArDigitizationConfig import isOverlay
if DetFlags.pileup.LAr_on() or isOverlay():
IntervalsList += [
CfgGetter.getPrivateTool("LArRangeEM", checkType=True)
]
IntervalsList += [
CfgGetter.getPrivateTool("LArRangeHEC", checkType=True)
]
IntervalsList += [
CfgGetter.getPrivateTool("LArRangeFCAL", checkType=True)
]
if hasattr(DetFlags.pileup, 'HGTD_on') and DetFlags.pileup.HGTD_on(
): # No HGTD in Overlay samples (yet!)
IntervalsList += [
CfgGetter.getPrivateTool("LArRangeHGTD", checkType=True)
]
if DetFlags.pileup.Tile_on():
IntervalsList += [
CfgGetter.getPrivateTool("TileRange", checkType=True)
]
## Muon System Digitization
if DetFlags.pileup.CSC_on():
IntervalsList += [
CfgGetter.getPrivateTool("CscRange", checkType=True)
]
if DetFlags.pileup.MDT_on():
IntervalsList += [
CfgGetter.getPrivateTool("MdtRange", checkType=True)
]
if DetFlags.pileup.RPC_on():
IntervalsList += [
CfgGetter.getPrivateTool("RpcRange", checkType=True)
]
if DetFlags.pileup.TGC_on():
IntervalsList += [
CfgGetter.getPrivateTool("TgcRange", checkType=True)
]
if DetFlags.pileup.sTGC_on():
IntervalsList += [
CfgGetter.getPrivateTool("sTgcRange", checkType=True)
]
if DetFlags.pileup.Micromegas_on():
IntervalsList += [
CfgGetter.getPrivateTool("MMRange", checkType=True)
]
# RecoTimingObj
if DetFlags.pileup.any_on():
IntervalsList += [
CfgGetter.getPrivateTool("TimingObjRange", checkType=True)
]
kwargs.setdefault("Intervals", IntervalsList)
from PileUpTools.PileUpToolsConf import PileUpMergeSvc
return PileUpMergeSvc(name, **kwargs)
# note: some of these tests will need an active DecDescManager
# so please use something like
# preExec='simFlags.ReleaseGeoModel=False;'
# with your transform
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from G4AtlasApps.SimFlags import simFlags
simFlags.ReleaseGeoModel=False;
if not hasattr(job, 'G4TestAlg'):
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon import CfgGetter
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TruthTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("PixelHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("SCT_HitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TrtHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("EMBHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("EMECHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("FCALHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("HECHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TileHitsTestTool", checkType=True)]
##job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("MDTHitsTestTool", checkType=True)]
##job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("RPCHitsTestTool", checkType=True)]
##job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("CSCHitsTestTool", checkType=True)]
##job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TGCHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("LArActiveCaloCalibHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("LArInactiveCaloCalibHitsTestTool", checkType=True)]
##job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("LArDeadMaterialCaloCalibHitsTestTool", checkType=True)]
include.block("MdtOverlay/MdtOverlay_jobOptions.py")
#from Digitization.DigitizationFlags import jobproperties
from AthenaCommon import CfgGetter
#from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigitTool
#MuonRdoToMuonDigitTool = MuonRdoToMuonDigitTool (
# "MdtRdoToMdtDigit",
# DecodeMdtRDO = True,
# DecodeRpcRDO = False,
# DecodeTgcRDO = False,
# DecodeCscRDO = False )
#ToolSvc += CfgGetter.getPrivateTool("MdtRdoToMdtDigit")
ToolSvc += CfgGetter.getPrivateTool("MdtRdoToMdtDigit")
#job += MdtRdoToMdtDigit()
#include ( "MDT_Digitization/MdtDigitizationTool_jobOptions.py" )
#if readBS and isRealData:
# ToolSvc.MdtDigitizationTool.GetT0FromBD = True
#t if readBS and isRealData:
#t if not hasattr(ToolSvc, 'Mdt_OverlayDigitizationTool'):
# t from AthenaCommon import CfgGetter
# t ToolSvc += CfgGetter.getPrivateTool("Mdt_OverlayDigitizationTool")
#, checkType=True)
# ToolSvc.Mdt_OverlayDigitizationTool.GetT0FromBD = True
#jobproperties.Digitization.rndmSeedList.addSeed("MDTResponse", 49261510,105132394 )
#jobproperties.Digitization.rndmSeedList.addSeed("MDT_Digitization", 393242561, 857132381 )
simFlags.ReleaseGeoModel = False
include("G4AtlasApps/G4Atlas.flat.configuration.py")
## Add the G4 sim to the alg sequence after the generator
from AthenaCommon.CfgGetter import getAlgorithm
job += getAlgorithm("G4AtlasAlg",tryDefaultConfigurable=True)
# User algorithms
from AthenaCommon.AppMgr import ServiceMgr
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc("THistSvc")
ServiceMgr.THistSvc.Output = ["truth DATAFILE='truth.root' OPT='RECREATE'"];
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon import CfgGetter
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TruthTestTool", checkType=True)]
#job.G4TestAlg.SimTestTools.['TruthTestTool'].DumpMcEvent=5
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool( "EvgenTruthTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("PixelHitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("SCT_HitsTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TrtHitsTestTool", checkType=True)]
## Check of memory during the RTT tests
from G4AtlasApps.atlas_utilities import MemorySnooper
job += MemorySnooper()
ServiceMgr.EventSelector.SkipEvents = 0
## User algorithms
from AthenaCommon.AppMgr import ServiceMgr
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc("THistSvc")
# This line doesn't seem to be needed
#ServiceMgr.THistSvc.Output = ["atlasTest DATAFILE='atlasTest_2.muons.histo.root' OPT='RECREATE'"];
ServiceMgr.THistSvc.Output = ["truth DATAFILE='truth_2.root' OPT='RECREATE'"]
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon import CfgGetter
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TruthTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("PixelHitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("SCT_HitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TrtHitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("EMBHitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("EMECHitsTestTool", checkType=True)
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, 'THistSvc'):
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc("THistSvc")
ServiceMgr.THistSvc.Output = ["truth DATAFILE='truth.root' OPT='RECREATE'"];
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
if not hasattr(job, 'G4TestAlg'):
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon import CfgGetter
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TruthTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("ALFA_SimHitsTestTool", checkType=True)]
# note: some of these tests will need an active DecDescManager
# so please use something like
# preExec='simFlags.ReleaseGeoModel=False;'
# with your transform
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from G4AtlasApps.SimFlags import simFlags
simFlags.ReleaseGeoModel = False
if not hasattr(job, 'G4TestAlg'):
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon import CfgGetter
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TruthTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("PixelHitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("SCT_HitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TrtHitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("EMBHitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("EMECHitsTestTool", checkType=True)
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from AthenaCommon import CfgGetter
job.PileUpToolsAlg.PileUpTools += [ CfgGetter.getPrivateTool("ALFA_PileUpTool", checkType=True) ]
alfaPileUpTool = job.PileUpToolsAlg.PileUpTools[ "ALFA_PileUpTool" ]
printfunc('Be aware that the job is running with NSW TDR setup!')
else:
GeoModelSvc.MuonVersionOverride = "MuonSpectrometer-R.07.00-NSW"
printfunc(GeoModelSvc)
#***************************************************** HERE setup MuonDetectorManager
from MuonGeoModel.MuonGeoModelConf import MuonDetectorTool
MuonDetectorTool = MuonDetectorTool()
MuonDetectorTool.StationSelection = 2
MuonDetectorTool.SelectedStations = ["EIL1"]
MuonDetectorTool.SelectedStations += ["EIL2"]
MuonDetectorTool.SelectedStations += ["EIS*"]
MuonDetectorTool.SelectedStations += ["EIL10"]
MuonDetectorTool.SelectedStations += ["EIL11"]
MuonDetectorTool.SelectedStations += ["CSS*"]
MuonDetectorTool.SelectedStations += ["CSL*"]
MuonDetectorTool.SelectedStations += ["T4E*"]
MuonDetectorTool.SelectedStations += ["T4F*"]
from AGDD2GeoSvc.AGDD2GeoSvcConf import AGDDtoGeoSvc
Agdd2GeoSvc = AGDDtoGeoSvc()
if not "NSWAGDDTool/NewSmallWheel" in Agdd2GeoSvc.Builders.__str__():
from AthenaCommon import CfgGetter
Agdd2GeoSvc.Builders += [
CfgGetter.getPrivateTool("NewSmallWheel", checkType=True)
]
theApp.CreateSvc += ["AGDDtoGeoSvc"]
ServiceMgr += Agdd2GeoSvc
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, 'THistSvc'):
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc("THistSvc")
ServiceMgr.THistSvc.Output = [
"truth DATAFILE='truth.root' OPT='RECREATE'"
]
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
if not hasattr(job, 'G4TestAlg'):
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon import CfgGetter
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TruthTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("LucidSimHitsTestTool", checkType=True)
]
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, 'THistSvc'):
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc("THistSvc")
ServiceMgr.THistSvc.Output = [
"truth DATAFILE='truth.root' OPT='RECREATE'"
]
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
if not hasattr(job, 'G4TestAlg'):
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon import CfgGetter
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TruthTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("ZDCHitsTestTool", checkType=True)
]
# now add config class to algsequence()
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
# this will create one digitization with all default properties
from AthenaCommon import CfgGetter
job.PileUpToolsAlg.PileUpTools += [
CfgGetter.getPrivateTool("BCM_DigitizationTool", checkType=True)
]
job = AlgSequence()
if not hasattr(job, 'G4TestAlg'):
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon.DetFlags import DetFlags
from G4AtlasApps.SimFlags import simFlags
simFlags.ReleaseGeoModel = False
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
from AthenaCommon import CfgGetter
if DetFlags.Truth_on():
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TruthTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("BeamTruthTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("EvgenTruthTestTool", checkType=True)
]
if DetFlags.pixel_on():
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("PixelHitsTestTool", checkType=True)
]
if DetFlags.SCT_on():
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("SCT_HitsTestTool", checkType=True)
]
###############################################################
#
# TRT Digitization
#
#==============================================================
from AthenaCommon import CfgGetter
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from Digitization.DigitizationFlags import digitizationFlags
if 'doSplitDigi' in jobproperties.Digitization.experimentalDigi():
job.PileUpToolsAlg.PileUpTools += [
CfgGetter.getPrivateTool("TRTDigitizationToolHS", checkType=True)
]
job.PileUpToolsAlg.PileUpTools += [
CfgGetter.getPrivateTool("TRTDigitizationToolPU", checkType=True)
]
else:
job.PileUpToolsAlg.PileUpTools += [
CfgGetter.getPrivateTool("TRTDigitizationTool", checkType=True)
]
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()
ToolSvc+=InDetServMatBuilderToolSLHC
if ( DetFlags.detdescr.pixel_on() ):
from AthenaCommon import CfgGetter
GeoModelSvc.DetectorTools += [ CfgGetter.getPrivateTool("PixelDetectorTool", checkType=True) ]
if (DetFlags.detdescr.BCM_on() ) :
from AthenaCommon.AppMgr import ToolSvc
from BCM_GeoModel.BCM_GeoModelConf import InDetDD__BCM_Builder
bcmTool = InDetDD__BCM_Builder()
ToolSvc += bcmTool
GeoModelSvc.DetectorTools['PixelDetectorTool'].BCM_Tool = bcmTool
from BLM_GeoModel.BLM_GeoModelConf import InDetDD__BLM_Builder
blmTool = InDetDD__BLM_Builder()
ToolSvc += blmTool
GeoModelSvc.DetectorTools['PixelDetectorTool'].BLM_Tool = blmTool
GeoModelSvc.DetectorTools['PixelDetectorTool'].useDynamicAlignFolders = GeometryFlags.useDynamicAlignFolders()
job += getAlgorithm("G4AtlasAlg", tryDefaultConfigurable=True)
# User algorithms
from AthenaCommon.AppMgr import ServiceMgr
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc("THistSvc")
ServiceMgr.THistSvc.Output = ["truth DATAFILE='truth.root' OPT='RECREATE'"]
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon import CfgGetter
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TruthTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("EvgenTruthTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("PixelHitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("SCT_HitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TrtHitsTestTool", checkType=True)
]
## Check of memory during the RTT tests
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
from AthenaCommon.DetFlags import DetFlags
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
if (DetFlags.detdescr.Muon_on()):
from AthenaCommon import CfgGetter
from AthenaCommon.AppMgr import ToolSvc, ServiceMgr, theApp
from AGDD2GeoSvc.AGDD2GeoSvcConf import AGDDtoGeoSvc
AGDD2Geo = AGDDtoGeoSvc()
if not "MuonAGDDTool/MuonSpectrometer" in AGDD2Geo.Builders.__str__():
AGDD2Geo.Builders += [
CfgGetter.getPrivateTool("MuonSpectrometer", checkType=True)
]
if (MuonGeometryFlags.hasSTGC() and MuonGeometryFlags.hasMM()):
if not "NSWAGDDTool/NewSmallWheel" in AGDD2Geo.Builders.__str__():
AGDD2Geo.Builders += [
CfgGetter.getPrivateTool("NewSmallWheel", checkType=True)
]
theApp.CreateSvc += ["AGDDtoGeoSvc"]
ServiceMgr += AGDD2Geo
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from AthenaCommon import CfgGetter
from Digitization.DigitizationFlags import jobproperties
if jobproperties.Digitization.doXingByXingPileUp(): # PileUpTool approach
job.PileUpToolsAlg.PileUpTools += [ CfgGetter.getPrivateTool("TgcDigitizationTool", checkType=True) ]
else : # Algorithm approach
job += CfgGetter.getAlgorithm("TGCDigitizer", tryDefaultConfigurable=True)
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from AthenaCommon import CfgGetter
job.PileUpToolsAlg.PileUpTools += [
CfgGetter.getPrivateTool("AFP_PileUpTool", checkType=True)
]
afpPileUpTool = job.PileUpToolsAlg.PileUpTools["AFP_PileUpTool"]
## User algorithms
from AthenaCommon.AppMgr import ServiceMgr
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc("THistSvc")
#ServiceMgr.THistSvc.Output = ["atlasTest DATAFILE='atlasTest.muons.histo.root' OPT='RECREATE'"];
ServiceMgr.THistSvc.Output = ["truth DATAFILE='truth.root' OPT='RECREATE'"]
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from G4AtlasTests.G4AtlasTestsConf import G4TestAlg
job += G4TestAlg()
from AthenaCommon import CfgGetter
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TruthTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("EvgenTruthTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("CaloEntryLayerTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("MuonEntryLayerTestTool", checkType=True)
]
#job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("MuonExitLayerTestTool", checkType=True)]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("PixelHitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigitTool
MuonRdoToMuonDigitTool = MuonRdoToMuonDigitTool("RpcRdoToRpcDigit",
DecodeMdtRDO=False,
DecodeRpcRDO=True,
DecodeTgcRDO=False,
DecodeCscRDO=False)
ToolSvc += MuonRdoToMuonDigitTool
#old way
#include ( "RPC_Digitization/RpcDigitizationTool_jobOptions.py" )
#jobproperties.Digitization.rndmSeedList.addSeed("RPC_Digitization", 49261510, 105132394 )
#new way
if not hasattr(ToolSvc, 'Rpc_OverlayDigitizationTool'):
from AthenaCommon import CfgGetter
RpcDigitizationTool = CfgGetter.getPrivateTool(
"Rpc_OverlayDigitizationTool")
from RpcOverlay.RpcOverlayConf import RpcOverlay
job += RpcOverlay()
job.RpcOverlay.mainInputRPC_Name = "RPC_DIGITS"
job.RpcOverlay.overlayInputRPC_Name = "RPC_DIGITS"
job.RpcOverlay.DigitizationTool = RpcDigitizationTool
job.RpcOverlay.ConvertRDOToDigitTool = MuonRdoToMuonDigitTool
#job.RpcOverlay.DigitizationTool.EvtStore = job.RpcOverlay.MCStore
job.RpcOverlay.ConvertRDOToDigitTool.RetrievePrivateCopy = True
job.RpcOverlay.ConvertRDOToDigitTool.DataStore = job.RpcOverlay.DataStore
from OverlayCommonAlgs.OverlayFlags import overlayFlags
if overlayFlags.doSignal == True:
job.RpcOverlay.CopyObject = True