OutputLevel=DEBUG)
geantsim = SimG4Alg("SimG4Alg",
outputs=["SimG4SaveCalHits/saveHCalHits"],
eventProvider=pgun,
OutputLevel=DEBUG)
# PODIO algorithm
from Configurables import PodioOutput
out = PodioOutput("out", OutputLevel=DEBUG)
out.outputCommands = ["keep *"]
out.filename = "output_hcalSim_e" + str(int(
energy / 1000)) + "GeV_eta036_1events.root"
#CPU information
from Configurables import AuditorSvc, ChronoAuditor
chra = ChronoAuditor()
audsvc = AuditorSvc()
audsvc.Auditors = [chra]
geantsim.AuditExecute = True
# ApplicationMgr
from Configurables import ApplicationMgr
ApplicationMgr(
TopAlg=[geantsim, out],
EvtSel='NONE',
EvtMax=num_events,
# order is important, as GeoSvc is needed by G4SimSvc
ExtSvc=[podioevent, geoservice, geantservice, audsvc],
OutputLevel=DEBUG)
def expertMonitoring(self, sequence):
# Define the RICH ntuple file
if self.getProp("NTupleProduce"):
from Configurables import NTupleSvc
NTupleSvc().Output += [
"RICHTUPLE1 DATAFILE='rich.tuples.root' TYP='ROOT' OPT='NEW'"
]
checks = self.getHistoOptions("Monitors")
tkTypes = self.getTrackTypes("RecoTrackTypes")
check = "RichFuncCKResPlots"
if check in checks:
if "HistoProduce" in self.richTools().ckResolution().properties():
self.richTools().ckResolution(
).HistoProduce = self.getProp("Histograms") != "None"
check = "RichPixelPositions"
if check in checks:
from Configurables import Rich__Rec__MC__PixelPositionMonitor
seq = self.newSeq(sequence, check)
seq.Members += [
Rich__Rec__MC__PixelPositionMonitor("RiRecPixelPosMoni")
]
check = "HPDHitPlots"
if check in checks:
from Configurables import (Rich__Rec__HPDHitsMoni, GaudiSequencer)
seq = self.newSeq(sequence, check)
seq.IgnoreFilterPassed = True
seq.Members += [Rich__Rec__HPDHitsMoni("HPDHitsMoni")]
if not self.getProp("Simulation"):
lSeq = self.newSeq(seq, check + "L0")
lSeq.ReturnOK = True
lSeq.Members = self.l0Filters() + [
Rich__Rec__HPDHitsMoni("HPDL0HitsMoni")
]
check = "RichTrackGeometry"
if check in checks:
from Configurables import Rich__Rec__MC__TrackGeomMoni
seq = self.newSeq(sequence, check)
for trackType in tkTypes:
name = "RiRec" + self.trackSelName(trackType) + "GeomMoni"
seq.Members += [
self.createMonitor(Rich__Rec__MC__TrackGeomMoni, name,
trackType)
]
check = "RichTrackResolution"
if check in checks:
from Configurables import Rich__Rec__MC__TrackResolutionMoni
seq = self.newSeq(sequence, check)
for trackType in tkTypes:
name = "RiRec" + self.trackSelName(trackType) + "TkResMoni"
seq.Members += [
self.createMonitor(Rich__Rec__MC__TrackResolutionMoni,
name, trackType)
]
check = "RichCKThetaResolution"
if check in checks:
from Configurables import Rich__Rec__MC__CherenkovAngleMonitor
seq = self.newSeq(sequence, check)
for trackType in tkTypes:
name = "RiRecPhotAng" + self.trackSelName(trackType) + "Moni"
seq.Members += [
self.createMonitor(Rich__Rec__MC__CherenkovAngleMonitor,
name, trackType)
]
check = "RichTrackCKResolutions"
if check in checks:
from Configurables import Rich__Rec__MC__CherenkovResMoni
seq = self.newSeq(sequence, check)
for trackType in tkTypes:
name = "RiRec" + self.trackSelName(trackType) + "CKResMoni"
seq.Members += [
self.createMonitor(Rich__Rec__MC__CherenkovResMoni, name,
trackType)
]
check = "RichPhotonSignal"
if check in checks:
from Configurables import Rich__Rec__MC__PhotonSignalMonitor
seq = self.newSeq(sequence, check)
for trackType in tkTypes:
name = "RiRecPhotSig" + self.trackSelName(trackType) + "TkMoni"
seq.Members += [
self.createMonitor(Rich__Rec__MC__PhotonSignalMonitor,
name, trackType)
]
check = "RichPhotonGeometry"
if check in checks:
from Configurables import Rich__Rec__MC__PhotonGeomMonitor
seq = self.newSeq(sequence, check)
for trackType in tkTypes:
name = "RiRecPhotGeom" + self.trackSelName(
trackType) + "TkMoni"
seq.Members += [
self.createMonitor(Rich__Rec__MC__PhotonGeomMonitor, name,
trackType)
]
check = "RichPhotonTrajectory"
if check in checks:
from Configurables import Rich__Rec__MC__PhotonTrajectoryMonitor
seq = self.newSeq(sequence, check)
for trackType in tkTypes:
name = "RiRecPhotTraj" + self.trackSelName(
trackType) + "TkMoni"
seq.Members += [
self.createMonitor(Rich__Rec__MC__PhotonTrajectoryMonitor,
name, trackType)
]
check = "RichPhotonRecoCompare"
if check in checks:
from Configurables import Rich__Rec__MC__PhotonRecoCompare
seq = self.newSeq(sequence, check)
self.toolRegistry().Tools += [
"Rich::Rec::PhotonRecoUsingQuarticSoln/BaselinePhotonReco"
]
for trackType in tkTypes:
name = "RiRecPhotCompare" + self.trackSelName(
trackType) + "TkMoni"
seq.Members += [
self.createMonitor(Rich__Rec__MC__PhotonRecoCompare, name,
trackType)
]
check = "PhotonRecoEfficiency"
if check in checks:
recotools = [
"Rich::Rec::PhotonCreator/ForcedRichPhotonCreator",
"Rich::Rec::PhotonRecoUsingQuarticSoln/ForcedPhotonReco",
"Rich::Rec::SimplePhotonPredictor/ForcedRichPhotonPredictor"
]
self.toolRegistry().Tools += recotools
self.recoConf().toolRegistry().Tools += recotools
seq = self.newSeq(sequence, check)
for trackType in tkTypes:
context = self.getTrackContext(trackType)
from Configurables import (Rich__Rec__PhotonCreator,
Rich__Rec__SimplePhotonPredictor)
forcedCreator = Rich__Rec__PhotonCreator(
context + ".ForcedRichPhotonCreator")
forcedCreator.MinAllowedCherenkovTheta = [0.0, 0.0, 0.0]
forcedCreator.MaxAllowedCherenkovTheta = [999, 999, 999]
forcedCreator.MinPhotonProbability = [1e-99, 1e-99, 1e-99]
forcedCreator.NSigma = [999, 999, 999]
forcedCreator.PhotonPredictor = "ForcedRichPhotonPredictor"
forcedCreator.PhotonRecoTool = "ForcedPhotonReco"
forcedPredictor = Rich__Rec__SimplePhotonPredictor(
context + ".ForcedRichPhotonPredictor")
forcedPredictor.MinTrackROI = [0.0, 0.0, 0.0]
forcedPredictor.MaxTrackROI = [9999, 9999, 9999]
from Configurables import Rich__Rec__MC__PhotonRecoEffMonitor
name = "RiRecPhotEff" + self.trackSelName(trackType) + "TkMoni"
mon = self.createMonitor(Rich__Rec__MC__PhotonRecoEffMonitor,
name, trackType)
seq.Members += [mon]
check = "RichPhotonRayTracingTests"
if check in checks:
from Configurables import Rich__Rec__MC__PhotonRayTraceTest
seq = self.newSeq(sequence, check)
self.toolRegistry().Tools += [
"Rich::Rec::PhotonRecoUsingQuarticSoln/BaselinePhotonReco"
]
for trackType in tkTypes:
name = "RiRecPhotRayTrace" + self.trackSelName(
trackType) + "TkMoni"
seq.Members += [
self.createMonitor(Rich__Rec__MC__PhotonRayTraceTest, name,
trackType)
]
check = "RichTrackRayTracingTests"
if check in checks:
from Configurables import Rich__Rec__MC__PhotonRecoRayTraceTest
seq = self.newSeq(sequence, check)
moniA = Rich__Rec__MC__PhotonRecoRayTraceTest(
"PhotRayTraceTestSimple")
moniA.FullHPDsInRayTracing = False
moniB = Rich__Rec__MC__PhotonRecoRayTraceTest(
"PhotRayTraceTestFull")
moniB.FullHPDsInRayTracing = True
seq.Members += [moniA, moniB]
check = "RichStereoFitterTests"
if check in checks:
from Configurables import Rich__Rec__MC__StereoPhotonFitTest
seq = self.newSeq(sequence, check)
for trackType in tkTypes:
name = "RiRecStereoFitter" + self.trackSelName(
trackType) + "TkMoni"
seq.Members += [
self.createMonitor(Rich__Rec__MC__StereoPhotonFitTest,
name, trackType)
]
check = "RichGhostTracks"
if check in checks:
from Configurables import Rich__Rec__MC__GhostTrackMoni
seq = self.newSeq(sequence, check)
seq.Members += [
self.createMonitor(Rich__Rec__MC__GhostTrackMoni,
"RichGhostsMoni")
]
check = "RichDataObjectChecks"
if check in checks:
from Configurables import Rich__Rec__DataObjVerifier
seq = self.newSeq(sequence, check)
moni = Rich__Rec__DataObjVerifier("RichRecObjPrint")
moni.PrintPixels = True
moni.PrintTracks = True
moni.PrintSegments = True
moni.PrintPhotons = True
seq.Members += [moni]
check = "RichRecoTiming"
if check in checks:
from Configurables import (AuditorSvc, ChronoAuditor,
Rich__Rec__TimeMonitor)
# Enable ChronoAuditor
chronoAuditor = "ChronoAuditor"
if chronoAuditor not in AuditorSvc().Auditors:
AuditorSvc().Auditors += [chronoAuditor]
ChronoAuditor().Enable = True
seq = self.newSeq(sequence, check)
cont = self.getProp("Context")
# RICH reconstruction only (tracks,pixels,photons)
moni = self.createMonitor(Rich__Rec__TimeMonitor, "RichRecoTime")
moni.TimingName = "RichRecInit" + cont + "Seq"
moni.Algorithms = [moni.TimingName]
seq.Members += [moni]
# RICH PID only
moni = self.createMonitor(Rich__Rec__TimeMonitor, "RichPIDTime")
moni.TimingName = "Rich" + cont + "PIDSeq"
moni.Algorithms = [moni.TimingName]
seq.Members += [moni]
# overall RICH reconstruction
moni = self.createMonitor(Rich__Rec__TimeMonitor,
"OverallRichTime")
moni.TimingName = "RecoRICHSeq"
moni.Algorithms = [moni.TimingName]
seq.Members += [moni]
# overall track reconstruction
moni = self.createMonitor(Rich__Rec__TimeMonitor,
"OverallTrackTime")
moni.TimingName = "RecoTrSeq"
moni.Algorithms = [moni.TimingName]
seq.Members += [moni]
check = "RichTracksToTextFile"
if check in checks:
from Configurables import Rich__Rec__MC__DumpRichTracksToTextFileAlg as RichTracksToText
moni = self.createMonitor(RichTracksToText, "RichTracksToText")
sequence.Members += [moni]
check = "RichHitsToTextFile"
if check in checks:
from Configurables import Rich__Rec__MC__DumpRichHitsToTextFileAlg as RichHitsToText
moni = self.createMonitor(RichHitsToText, "RichHitsToText")
sequence.Members += [moni]
check = "RichPerfFromData"
if check in checks:
pass
#from Configurables import StrippingTCK
#stck = StrippingTCK(HDRLocation = '/Event/Strip/Phys/DecReports', TCK=0x36112100)
#
#Configure DaVinci
#
# Change the column size of Timing table
from Configurables import TimingAuditor, SequencerTimerTool
TimingAuditor().addTool(SequencerTimerTool, name="TIMER")
TimingAuditor().TIMER.NameSize = 60
from Configurables import AuditorSvc, ChronoAuditor
AuditorSvc().Auditors.append(ChronoAuditor("Chrono"))
from Configurables import StrippingReport
sr = StrippingReport(Selections=sc.selections())
from Configurables import AlgorithmCorrelationsAlg
ac = AlgorithmCorrelationsAlg(Algorithms=list(set(sc.selections())))
DaVinci().HistogramFile = 'DV_stripping_histos_sels.root'
DaVinci().EvtMax = 100000
DaVinci().PrintFreq = 1000
DaVinci().appendToMainSequence([sc.sequence()])
DaVinci().appendToMainSequence([sr])
#DaVinci().appendToMainSequence( [ ac ] )
# next, create the G4 algorithm, giving the list of names of tools ("XX/YY")
g4pconverter = SimG4GeantinosFromEdmTool()
geantsim = SimG4Alg("SimG4Alg",
outputs=[savehcaltool, savetrajectorytool],
eventProvider=g4pconverter)
## ouput
from Configurables import PodioOutput
out = PodioOutput("out", OutputLevel=INFO)
out.outputCommands = ["keep *"]
out.filename = 'output_hcal_geantscan.root'
from Configurables import ChronoAuditor
chronoauditor = ChronoAuditor()
from Configurables import MemStatAuditor
memauditor = MemStatAuditor()
from Configurables import MemoryAuditor
memauditor2 = MemoryAuditor()
from Configurables import AuditorSvc
auditorsvc_handle = AuditorSvc()
auditorsvc_handle.Auditors = [
chronoauditor,
memauditor,
memauditor2,
]
