def configureServices(self):
# Pass the input file names to the data service.
from Configurables import TbDataSvc
TbDataSvc().Input = self.getProp("InputFiles")
TbDataSvc().AlignmentFile = self.getProp("AlignmentFile")
TbDataSvc().PixelConfigFile = self.getProp("PixelConfigFile")
TbDataSvc().TimingConfigFile = self.getProp("TimingConfigFile")
TbDataSvc().EtaConfigFiles = self.getProp("EtaConfigFiles")
ApplicationMgr().ExtSvc += [TbDataSvc()]
# Add the geometry service which keeps track of alignment,
# the timing service, which tracks event boundaries,
# and the pixel service, which stores masked pixels,
# clock phases and per column timing offsets.
from Configurables import TbGeometrySvc, TbTimingSvc, TbPixelSvc
ApplicationMgr().ExtSvc += [
TbGeometrySvc(), TbTimingSvc(),
TbPixelSvc()
]
# Use TimingAuditor for timing, suppress printout from SequencerTimerTool
from Configurables import AuditorSvc, SequencerTimerTool
ApplicationMgr().ExtSvc += ['ToolSvc', 'AuditorSvc']
ApplicationMgr().AuditAlgorithms = True
AuditorSvc().Auditors += ['TimingAuditor']
if not SequencerTimerTool().isPropertySet("OutputLevel"):
SequencerTimerTool().OutputLevel = 4
def defineMonitors(self):
for prop in self.getProp("Monitors"):
if prop not in self.knownMonitors():
if prop in self.knownAuditors():
from Configurables import AuditorSvc
AuditorSvc().Auditors.append(prop)
theConf = getConfigurable(prop)
theConf.Enable = True
else:
raise RuntimeError("Unknown monitor '%s'" % prop)
if "SC" in self.getProp("Monitors"):
ApplicationMgr().StatusCodeCheck = True
# Ensure output is always kept
getConfigurable("StatusCodeSvc").OutputLevel = INFO
if "FPE" in self.getProp("Monitors"):
#importOptions( "$STDOPTS/FPEAudit.opts" )
from Configurables import AuditorSvc
ApplicationMgr().ExtSvc += ['AuditorSvc']
AuditorSvc().Auditors += ["FPEAuditor"]
def defineMonitors(self):
# get all defined monitors
monitors = self.getProp("Monitors") + LHCbApp().getProp("Monitors")
# Currently no Boole specific monitors, so pass them all to LHCbApp
LHCbApp().setProp("Monitors", monitors)
# Use TimingAuditor for timing, suppress printout from SequencerTimerTool
from Configurables import ApplicationMgr, AuditorSvc, SequencerTimerTool
ApplicationMgr().ExtSvc += ['AuditorSvc']
ApplicationMgr().AuditAlgorithms = True
AuditorSvc().Auditors += ['TimingAuditor']
SequencerTimerTool().OutputLevel = WARNING
def configOnline(appMgr, level):
appMgr.SvcOptMapping += ["LHCb::OnlineRunable/EmptyEventLoop"]
appMgr.HistogramPersistency = "NONE"
appMgr.EvtSel = "NONE"
appMgr.EventLoop = "LHCb::OnlineRunable/EmptyEventLoop"
appMgr.Runable = "LHCb::OnlineRunable/Runable"
appMgr.OutputLevel = 3
from Configurables import LHCb__OnlineRunable as Runable
Runable("Runable").Wait = 3
from Configurables import AuditorSvc
AuditorSvc().Auditors = []
configMsgSvc(appMgr, 2 if level == 'top' else 3)
OnlineEnv = importOnline()
OnlineEnv.end_config(False)
def __apply_configuration__(self):
GaudiKernel.ProcessJobOptions.PrintOff()
GaudiKernel.ProcessJobOptions.PrintOn()
log.info("Initializing sequences!")
self.setOtherProps(
RecSysConf(), ["SpecialData", "Context", "OutputType", "DataType"])
#if self.isPropertySet("RecoSequence") :
#self.setOtherProp(RecSysConf(),["RecoSequence"])
RecSysConf().RecoSequence = self.CheckRecoSequence()
# there is a bug in setOtherProps, so we cannot use it to set the MoniSequence.
if not self.getProp("OnlineMode"):
self.setOtherProps(RecMoniConf(), ["Context", "DataType"])
RecMoniConf().MoniSequence = self.getProp("MoniSequence")
else:
self.setOtherProps(RecMoniConf(), ["Context", "DataType"])
RecMoniConf().MoniSequence = self.getProp("MoniSequence")
RecMoniConf().Context = "Offline"
RecMoniConf().OutputLevel = FATAL
RecMoniConf().Histograms = "OfflineFull"
self.defineGeometry()
self.defineEvents()
self.defineOptions()
# database hacking for online.
if self.getProp('UseDBSnapshot'): self.configureDBSnapshot()
# Use TimingAuditor for timing, suppress printout from SequencerTimerTool
from Configurables import (ApplicationMgr, AuditorSvc,
SequencerTimerTool)
ApplicationMgr().ExtSvc += ['ToolSvc', 'AuditorSvc']
ApplicationMgr().AuditAlgorithms = True
AuditorSvc().Auditors += ['TimingAuditor']
SequencerTimerTool().OutputLevel = 4
log.info(self)
log.info(LHCbApp())
log.info(RecSysConf())
log.info(TrackSys())
if not self.getProp("OnlineMode"):
log.info(RecMoniConf())
log.info(TAlignment())
log.info(DstConf())
GaudiKernel.ProcessJobOptions.PrintOff()
def _defineMonitors(self):
"""
Define monitors
"""
from Configurables import (ApplicationMgr, AuditorSvc,
SequencerTimerTool)
ApplicationMgr().ExtSvc += ['ToolSvc', 'AuditorSvc']
ApplicationMgr().AuditAlgorithms = True
AuditorSvc().Auditors += ['TimingAuditor']
SequencerTimerTool().OutputLevel = 4
# Do not print event number at every event
printfreq = self.getProp("PrintFreq")
if (printfreq == 0):
log.warning("Print frequence cannot be 0")
printfreq = 1000
EventSelector().PrintFreq = printfreq
# Change the column size of Timing table
from Configurables import TimingAuditor, SequencerTimerTool
TimingAuditor().addTool(SequencerTimerTool, name="TIMER")
if not TimingAuditor().TIMER.isPropertySet("NameSize"):
TimingAuditor().TIMER.NameSize = 50
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
createcells = CreateCaloCells("CreateCaloCells",
doCellCalibration=True,
calibTool=calibcells,
addCellNoise=False, filterCellNoise=False,
OutputLevel=DEBUG)
createcells.hits.Path="ECalHits"
createcells.cells.Path="caloCells"
out = PodioOutput("out", filename="output_ecalInclinedDigi_test.root",
OutputLevel=DEBUG)
out.outputCommands = ["keep *"]
#CPU information
from Configurables import AuditorSvc, ChronoAuditor
chra = ChronoAuditor()
audsvc = AuditorSvc()
audsvc.Auditors = [chra]
geantsim.AuditExecute = True
createcells.AuditExecute = True
out.AuditExecute = True
ApplicationMgr(
TopAlg = [geantsim,
createcells,
out
],
EvtSel = 'NONE',
EvtMax = 1,
ExtSvc = [podioevent, geoservice],
)
def rawDataToNtuple(options):
# print options
required_options = [
"runNumber", "start", "end", "outputdir", "nEvtsPerStep", "totsteps"
]
for check_opts in required_options:
if not options.has_key(check_opts):
print "Please specify minimal options!"
print "Option \'" + check_opts + "\' is missing!"
sys.exit()
start = options["start"]
end = options["end"]
runNumber = options["runNumber"]
outputdir = options["outputdir"]
totsteps = options["totsteps"]
nEvtsPerStep = options["nEvtsPerStep"]
from Configurables import DDDBConf, CondDB, CondDBAccessSvc, NTupleSvc, EventClockSvc, Brunel, LHCbApp
# if options.has_key("IgnoreHeartBeat"):
# CondDB().IgnoreHeartBeat = options["IgnoreHeartBeat"]
if options.has_key("addCondDBLayer"):
altag = "HEAD"
if options.has_key("addCondDBLayer_tag"):
altag = options["addCondDBLayer_tag"]
CondDB().addLayer(
CondDBAccessSvc("myCond",
ConnectionString="sqlite_file:" +
options["addCondDBLayer"] + "/LHCBCOND",
DefaultTAG=altag))
# Need this line so as to not get db errors- should be fixed properly at some point
CondDB().IgnoreHeartBeat = True
CondDB().EnableRunStampCheck = False
# customDBs = glob.glob('/group/rich/ActiveDBSlices/*.db')
# for db in customDBs:
# CondDB().addLayer( CondDBAccessSvc(os.path.basename(db), ConnectionString="sqlite_file:"+db+"/LHCBCOND", DefaultTAG="HEAD") )
# importOptions('$STDOPTS/DecodeRawEvent.py')
#importOptions("$STDOPTS/RootHist.opts")
#importOptions("$STDOPTS/RawDataIO.opts")
#DEBUG by DisplayingHitMaps=False
from Configurables import MDMRich1Algorithm
mdmAlg = MDMRich1Algorithm("Rich1MDCS")
mdmAlg.NumberOfEventsPerStep = nEvtsPerStep
mdmAlg.StoreHistos = False
mdmAlg.DEBUG = False
if options.has_key("StoreHistos"):
mdmAlg.StoreHistos = options["StoreHistos"]
if options.has_key("DEBUG"):
mdmAlg.DEBUG = options["DEBUG"]
print "start step: " + str(start)
print "stop step: " + str(end)
print "processing " + str(nEvtsPerStep * (end - start)) + " events"
tuplestring = "NTuple_Run%i_Steps%04d-%04d.root" % (runNumber, start, end)
if options.has_key("TupleName"):
tuplestring = options["TupleName"]
histoname = "Histos_Run%i_Steps%04d-%04d.root" % (runNumber, start, end)
if options.has_key("HistoName"):
histoname = options["HistoName"]
if outputdir != "":
tuplestring = "%s/%s" % (outputdir, tuplestring)
histoname = "%s/%s" % (outputdir, histoname)
tuplename = "RICHTUPLE1 DATAFILE=\'%s\' TYP=\'ROOT\' OPT=\'NEW\'" % (
tuplestring)
# Currently put in manually. Edit here to use correct db and conddb tags
LHCbApp().DDDBtag = "dddb-20150724"
LHCbApp().CondDBtag = "cond-20160123"
if options.has_key("DDDBtag"):
LHCbApp().DDDBtag = options["DDDBtag"]
if options.has_key("CondDBtag"):
LHCbApp().CondDBtag = options["CondDBtag"]
#customDBs = glob.glob('/group/rich/ActiveDBSlices/*.db')
#for db in customDBs:
# CondDB().addLayer( CondDBAccessSvc(os.path.basename(db), ConnectionString="sqlite_file:"+db+"/LHCBCOND", DefaultTAG="HEAD") )
ApplicationMgr().TopAlg += [mdmAlg]
ApplicationMgr().ExtSvc += ['DataOnDemandSvc']
ApplicationMgr().EvtMax = end * nEvtsPerStep
# Timing information for application
from Configurables import AuditorSvc, SequencerTimerTool
ApplicationMgr().ExtSvc += ['AuditorSvc']
ApplicationMgr().AuditAlgorithms = True
AuditorSvc().Auditors += ['TimingAuditor']
SequencerTimerTool().OutputLevel = 4
LHCbApp().TimeStamp = True
HistogramPersistencySvc().OutputFile = histoname
NTupleSvc().Output = [tuplename]
EventSelector().PrintFreq = 10
EventSelector().PrintFreq = nEvtsPerStep
EventSelector().FirstEvent = start * nEvtsPerStep
print "First event: " + str(start * nEvtsPerStep)
print "Last event: " + str(end * nEvtsPerStep)
#get data, will look in local cluster first, then on castor
isLocal = True
if options.has_key("isLocal"):
isLocal = options["isLocal"]
DATA_and_Year = (getData(runNumber, start, end, totsteps, isLocal))
DATA = DATA_and_Year["DATA"]
if not len(DATA) > 0:
print "Data not found in local, switching to CASTOR"
DATA_and_Year = getData(runNumber, start, end, totsteps, not isLocal)
DATA = DATA_and_Year["DATA"]
if not len(DATA) > 0:
print "DATA not found anywhere!"
sys.exit()
LHCbApp.DataType = str(DATA_and_Year["year"])
EventSelector().Input = DATA
EventClockSvc().EventTimeDecoder = "OdinTimeDecoder"
appMgr = GaudiPython.AppMgr()
appMgr.HistogramPersistency = "ROOT"
#appMgr.OutputLevel=DEBUG
evtSvc = appMgr.evtSvc()
esel = appMgr.evtsel()
esel.PrintFreq = nEvtsPerStep
appMgr.initialize()
appMgr.run(nEvtsPerStep * (end - start))
appMgr.stop()
appMgr.finalize()
ApplicationMgr().ExtSvc += [outputSvc]
from Configurables import GaudiSequencer as Sequence
from Configurables import LHCb__RawEventCopy as RawEventCopy
from Configurables import DeterministicPrescaler
from PRConfig.TestFileDB import test_file_db
test_file_db['2015HLTValidationData_L0filtered_0x0050'].run(configurable=app)
from Configurables import LHCbTimingAuditor, LHCbSequencerTimerTool, AuditorSvc
from Configurables import SequencerTimerTool
SequencerTimerTool().OutputLevel = 4
ApplicationMgr().ExtSvc.append('AuditorSvc')
ta = LHCbTimingAuditor('TIMER', Enable=True)
ta.addTool(LHCbSequencerTimerTool, name='TIMER')
AuditorSvc().Auditors.append(ta)
sequence = GaudiSequencer("TopSequence", IgnoreFilterPassed=True)
def groupName(subs):
return sorted(subs)[0]
groups = {("Full", "TurboFull"): 0.5, ("Turbo", ): 0.2}
filters = {}
for substreams, fraction in groups.iteritems():
gn = sorted(substreams)[0]
scaler = DeterministicPrescaler(gn + "Scaler", AcceptFraction=fraction)
for substream in substreams:
#importOptions("$APPCONFIGOPTS/Brunel/DataType-2011.py")
importOptions("$APPCONFIGOPTS/Brunel/DataType-2012.py")
from GaudiConf import IOHelper
##IOHelper('MDF').inputFiles(['/afs/cern.ch/user/r/rlambert/public/forMarkus/run_69669_large_2ev.mdf']);
##IOHelper('MDF').inputFiles(['castor://castorlhcb.cern.ch//castor/cern.ch/grid/lhcb/data/2011/RAW/FULL/LHCb/COLLISION11/102907/102907_0000000002.raw']);
##IOHelper('MDF').inputFiles(['castor://castorlhcb.cern.ch//castor/cern.ch/grid/lhcb/data/2011/RAW/FULL/LHCb/COLLISION11/97114/097114_0000000004.raw?svcClass=lhcbtape'])
##IOHelper('MDF').inputFiles(['/castorfs/cern.ch/grid/lhcb/data/2011/RAW/FULL/LHCb/COLLISION11/97114/097114_0000000004.raw'])
IOHelper('MDF').inputFiles([
'castor://castorlhcb.cern.ch//castor/cern.ch/grid/lhcb/data/2012/RAW/FULL/LHCb/COLLISION12/133586/133586_0000000309.raw'
])
from Configurables import Brunel, AuditorSvc, OutputStream
ApplicationMgr().ExtSvc.insert(0, AuditorSvc())
Brunel().EvtMax = 10
Brunel().OutputType = 'DST'
Brunel().Persistency = 'ROOT'
Brunel().OutputLevel = 4
MessageSvc().OutputLevel = 4
AuditorSvc().Auditors.append("TES::TraceAuditor")
OutputStream(
'DstWriter').Output = "DATAFILE='PFN:someFile.dst' TYP='ROOT' OPT='REC'"
def fixstuff():
for stream in IOHelper().activeStreams():
if IOHelper().detectStreamType(stream) == "FSR":
stream.Output = stream.Output.replace("SVC='RootCnvSvc'",
"SVC='FileRecordCnvSvc'")
# Full-like line
# does not influence what is kept since it is filtered by the stream filter
'Hlt2DiMuonBDecision': list(set(ALL_RAWBANKS) - set(['DstData'])),
# Let's try to keep some Muon banks for a muon line and Rich for charm
'Hlt2DiMuonBTurboDecision': DEFAULT_TURBO_BANKS + ['Muon'],
'Hlt2CharmHadDspToPimPipPipTurboDecision': DEFAULT_TURBO_BANKS + ['Rich'],
'Hlt2CharmHadD02KmPipTurboDecision': DEFAULT_TURBO_BANKS + ['Rich'],
# Very important line, so let's keep everything
'Hlt2CharmHadDpToKmPipPip_ForKPiAsymTurboDecision': ALL_RAWBANKS,
}
ApplicationMgr().ExtSvc.append(svc.getFullName())
# Setup the timing table
LHCbTimingAuditor('TIMER').addTool(LHCbSequencerTimerTool, name="TIMER")
ApplicationMgr().ExtSvc.append('AuditorSvc')
AuditorSvc().Auditors.append(LHCbTimingAuditor('TIMER'))
ApplicationMgr().AuditAlgorithms = True
# Setup the input data
test_file_db['HltDAQ-routingbits_full'].run(configurable=LHCbApp())
# LHCbApp().SkipEvents =
EventSelector().PrintFreq = 100
# Get rid of warnings
IODataManager().DisablePFNWarning = True
HistogramPersistencySvc().OutputLevel = 5
LoKiSvc().Welcome = False
# Filter nanofied events if the file is HLT2 accepted
content_filter = HltRoutingBitsFilter('RBFilter')
content_filter.RequireMask = [0x0, 0x0, 0x80000000]
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,
]
from Configurables import ApplicationMgr
ApplicationMgr(
TopAlg=[gen, hepmc_converter, geantsim, out],
EvtSel='NONE',
EvtMax=5000,
# order is important, as GeoSvc is needed by SimG4Svc
ExtSvc=[
auditorsvc_handle,
podioevent,
def configOnline(app, alg, name):
from Configurables import ApplicationMgr, UpdateAndReset
appMgr = ApplicationMgr()
## Configure saving of histograms
ur = UpdateAndReset()
ur.saveHistograms = 1
appMgr.TopAlg.insert(0, ur)
from Configurables import LoKiSvc
LoKiSvc().Welcome = False
import OnlineEnv
app.DDDBtag = OnlineEnv.DDDBTag
app.CondDBtag = OnlineEnv.CondDBTag
from Configurables import CondDB
conddb = CondDB()
conddb.IgnoreHeartBeat = True
conddb.UseDBSnapshot = True
conddb.EnableRunChangeHandler = True
conddb.EnableRunStampCheck = False
conddb.Tags['ONLINE'] = 'fake'
import ConditionsMap
conddb.RunChangeHandlerConditions = ConditionsMap.RunChangeHandlerConditions
from Gaudi.Configuration import EventLoopMgr
EventLoopMgr().Warnings = False
from Configurables import MonitorSvc
MonitorSvc().disableDimPropServer = 1
MonitorSvc().disableDimCmdServer = 1
MonitorSvc().ExpandCounterServices = 0;
MonitorSvc().ExpandNameInfix = "<part>_x_<program>/";
MonitorSvc().PartitionName = OnlineEnv.PartitionName;
MonitorSvc().ProgramName = name + "_00";
# setup the histograms and the monitoring service
appMgr.ExtSvc.append( 'MonitorSvc' )
from Configurables import RootHistCnv__PersSvc
RootHistCnv__PersSvc().OutputEnabled = False
from Gaudi.Configuration import allConfigurables
# set up the event selector
if 'EventSelector' in allConfigurables :
del allConfigurables['EventSelector']
input = 'Events'
mepMgr = OnlineEnv.mepManager(OnlineEnv.PartitionID,OnlineEnv.PartitionName,[input],True)
mepMgr.ConnectWhen = "start";
appMgr.Runable = OnlineEnv.evtRunable(mepMgr)
appMgr.SvcOptMapping.append('LHCb::OnlineEvtSelector/EventSelector')
appMgr.SvcOptMapping.append('LHCb::FmcMessageSvc/MessageSvc')
appMgr.ExtSvc.append(mepMgr)
eventSelector = OnlineEnv.mbmSelector(input = input, type = 'ONE', decode = False, event_type = 2)
appMgr.ExtSvc.append(eventSelector)
appMgr.ExtSvc.append(mepMgr)
appMgr.OutputLevel = 3
OnlineEnv.evtDataSvc()
eventSelector.REQ1 = 'EvType=2;TriggerMask=0x0,0x4,0x0,0x0;VetoMask=0,0,0,0x300;MaskType=ANY;UserType=USER;Frequency=PERC;Perc=100.0'
appMgr.EvtSel = eventSelector
from Configurables import AuditorSvc
AuditorSvc().Auditors = []
configMsgSvc( appMgr )
OnlineEnv.end_config(False)
#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 ] )
def _configureOnline(self):
from Configurables import LoKiSvc
LoKiSvc().Welcome = False
import OnlineEnv
EventLoopMgr().Warnings = False
app = ApplicationMgr()
# setup the histograms and the monitoring service
from Configurables import MonitorSvc
MonitorSvc().disableDimPropServer = 1
MonitorSvc().disableDimCmdServer = 1
MonitorSvc().disableMonRate = 0
MonitorSvc().CounterUpdateInterval = 15
app.ExtSvc.append('MonitorSvc')
if self.getProp('EnableUpdateAndReset'):
from Configurables import UpdateAndReset
if not self.getProp('Simulation'):
app.TopAlg = [UpdateAndReset()] + app.TopAlg
HistogramPersistencySvc().OutputFile = ''
HistogramPersistencySvc().Warnings = False
from Configurables import RootHistCnv__PersSvc
RootHistCnv__PersSvc().OutputEnabled = False
# set up the event selector
if 'EventSelector' in allConfigurables:
del allConfigurables['EventSelector']
# Enable Hlt2 ZeroMQ based monitoring
if self.getProp("HltLevel") == "Hlt2":
app.ExtSvc += ['HltMonitorSvc/Hlt2MonSvc', 'HltInfoSvc']
## Setup Checkpoint & forking: Do this EXACTLY here. Just befor the MEPManager & event selector.
## It will not work if these are created before.
if OnlineEnv.MooreStartupMode == 1:
self._configureOnlineForking()
elif OnlineEnv.MooreStartupMode == 2:
self._configureOnlineCheckpointing()
importOptions('$MBM_SETUP_OPTIONS')
mbm_setup = allConfigurables['OnlineEnv']
task_type = os.environ['TASK_TYPE']
input_buffer = mbm_setup.__getattribute__(task_type +
'_Input') #'Events'
output_buffer = mbm_setup.__getattribute__(task_type +
'_Output') #'Send'
self.__buffers = [input_buffer, output_buffer]
TAE = (OnlineEnv.TAE != 0)
mepMgr = OnlineEnv.mepManager(OnlineEnv.PartitionID,
OnlineEnv.PartitionName, self.__buffers,
False)
mepMgr.PartitionBuffers = True
mepMgr.PartitionName = OnlineEnv.PartitionName
mepMgr.PartitionID = OnlineEnv.PartitionID
mepMgr.ConnectWhen = 'start'
app.Runable = OnlineEnv.evtRunable(mepMgr)
app.ExtSvc.append(mepMgr)
if TAE:
eventSelector = OnlineEnv.mbmSelector(input=input_buffer,
TAE=TAE,
decode=False)
elif self.getProp('HltLevel') == "Hlt2" or self.getProp(
'ForceMDFInput'):
eventSelector = OnlineEnv.mbmSelector(
input=input_buffer, TAE=TAE,
decode=False) # decode=False for HLT2 ONLY!!!!!
else:
eventSelector = OnlineEnv.mbmSelector(input=input_buffer,
TAE=TAE,
decode=True)
app.ExtSvc.append(eventSelector)
OnlineEnv.evtDataSvc()
if self.getProp('REQ1'): eventSelector.REQ1 = self.getProp('REQ1')
from Configurables import AuditorSvc
AuditorSvc().Auditors = []
# Now setup the message service
self._configureOnlineMessageSvc()
from PRConfig import TestFileDB
TestFileDB.test_file_db["2012_raw_default"].run()
from Configurables import createODIN, EventCountAlg, PostScaler
ApplicationMgr().TopAlg += [
createODIN(),
EventCountAlg(),
PostScaler(),
GaudiSequencer("WAAAATUP")
]
from Configurables import LHCbTimingAuditor, LHCbSequencerTimerTool, TimingAuditor, AuditorSvc
LHCbTimingAuditor().addTool(LHCbSequencerTimerTool, name="TIMER")
LHCbTimingAuditor().TIMER.SummaryFile = "timing.dat"
LHCbTimingAuditor().TIMER.OutputLevel = DEBUG
LHCbTimingAuditor().TIMER.NameSize = 2
ApplicationMgr().ExtSvc.append('AuditorSvc')
AuditorSvc().Auditors.append(LHCbTimingAuditor())
LHCbTimingAuditor().Enable = True
LHCbTimingAuditor().OutputLevel = VERBOSE
AuditorSvc().Auditors.append(TimingAuditor())
TimingAuditor().Enable = True
from Configurables import IODataManager
IODataManager().DisablePFNWarning = True
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)
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, ]
from Configurables import ApplicationMgr
ApplicationMgr( TopAlg = [ gen, hepmc_converter, geantsim, out],
EvtSel = 'NONE',
EvtMax = 5000,
# order is important, as GeoSvc is needed by SimG4Svc
ExtSvc = [auditorsvc_handle, podioevent, geoservice, geantservice,],
OutputLevel=DEBUG,
)
for svc in ApplicationMgr().ExtSvc: