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
#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 ] )
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)
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:
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
# 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]
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()
#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'")
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)
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