def GetFSRdict( filename, queue ): FSR = { "TimeSpanFSR" : {'earliest': 0, 'latest': 0}, "LumiFSRBeamCrossing" : {'key': 0, 'incr': 0, 'integral':0}, "LumiFSRBeam1" : {'key': 0, 'incr': 0, 'integral':0}, "LumiFSRBeam2" : {'key': 0, 'incr': 0, 'integral':0}, "LumiFSRNoBeam" : {'key': 0, 'incr': 0, 'integral':0}, "EventCountFSR" : {'input': 0, 'output': 0, 'statusFlag': 0}} options = "from LumiAlgs.LumiFsrReaderConf import LumiFsrReaderConf as LumiFsrReader; LumiFsrReader().OutputLevel = INFO; LumiFsrReader().inputFiles = ['%s'] ;" %filename options += "LumiFsrReader().Persistency='ROOT'; LumiFsrReader().EvtMax = 1; from Configurables import LHCbApp; LHCbApp().Persistency='ROOT'; from Configurables import CondDB, DDDBConf;" options += " CondDB().UseLatestTags=['%s']; DDDBConf(DataType='%s');"%( 2011, 2011 ) exec options app = AppMgr() app.run( 1 ) fsr = app.filerecordsvc() lst = fsr.getHistoNames() if lst : for l in lst : ob = fsr.retrieveObject( l ) if "LumiFSR" in l: assert ob.numberOfObjects() == 1 k = ob.containedObject( 0 ) runs, files, keys, increment, integral = LumiFSR( k ) FSR[l[l.rfind( '/' ) + 1:]]['runs'] = runs FSR[l[l.rfind( '/' ) + 1:]]['files'] = files FSR[l[l.rfind( '/' ) + 1:]]['key'] = keys FSR[l[l.rfind( '/' ) + 1:]]['incr'] = increment FSR[l[l.rfind( '/' ) + 1:]]['integral'] = integral if "TimeSpanFSR" in l: FSR["TimeSpanFSR"]['earliest'] = ob.containedObject( 0 ).earliest() FSR["TimeSpanFSR"]['latest'] = ob.containedObject( 0 ).latest() if "EventCountFSR" in l: FSR["EventCountFSR"]['input'] = ob.input() FSR["EventCountFSR"]['output'] = ob.output() FSR["EventCountFSR"]['statusFlag'] = ob.statusFlag() app.stop() app.finalize() queue.put( FSR )
def extractAlignmentParameters( elementsWithTESAndCondDBNodes, since, until, valueExtractor=lambda detElm: getGlobalPositionFromGeometryInfo( detElm.geometry()), DDDBtag="default", CondDBtag="default", alignDBs=[]): """ The method talking to the detector svc Extract from all DetectorElements down from each element in elementsWithTESAndCondDBNodes ( format { elm : ( detTES, [ condDBNode ] ) } ), alignment parameters using valueExtractor, for all iovs between since and until (datetimes), using the CondDBNodes. The default database is configured with database tags DDDBtag and CondDBtag, and all alignDBs [ (tag, connectString) ] are added as layers to the CondDB. Returns a dict { element : [ ( (iovBegin, iovEnd), alignmentTree ) ] } """ # Static configuration of the application manager from Configurables import LHCbApp, ApplicationMgr from LHCbKernel.Configuration import FATAL, ERROR, WARNING, INFO, DEBUG, VERBOSE ApplicationMgr().AppName = "AlignmentCollector" ApplicationMgr().OutputLevel = ERROR LHCbApp().DDDBtag = DDDBtag LHCbApp().CondDBtag = CondDBtag # >>> This part stolen from Det/DetCond/tests/scripts/getIOVs.py ApplicationMgr().TopAlg = ["LoadDDDB"] from Configurables import EventClockSvc, FakeEventTime ecs = EventClockSvc( InitialTime=toTimeStamp(datetime(2010, 1, 1, 12, tzinfo=pytz.utc))) ecs.addTool(FakeEventTime, "EventTimeDecoder") ecs.EventTimeDecoder.StartTime = ecs.InitialTime ecs.EventTimeDecoder.TimeStep = toTimeStamp(timedelta(days=1)) # <<< + "lhcbcond" below layers = ["LHCBCOND"] if len(alignDBs) > 0: from Configurables import CondDB, CondDBAccessSvc for i, (connectString, tag) in enumerate(alignDBs): layerName = "AlignCond%i" % i alignCond = CondDBAccessSvc(layerName) alignCond.ConnectionString = connectString alignCond.DefaultTAG = tag CondDB().addLayer(alignCond) layers.append(layerName) # run a gaudi application from GaudiPython import AppMgr, gbl gaudi = AppMgr() gaudi.createSvc("UpdateManagerSvc") updateManagerSvc = gaudi.service("UpdateManagerSvc", interface="IUpdateManagerSvc") gaudi.initialize() conddbReaders = list( gaudi.service(name, gbl.ICondDBReader) for name in reversed(layers)) detDataSvc = updateManagerSvc.detDataSvc() alignmentTrees = dict( (detName, []) for detName in elementsWithTESAndCondDBNodes.iterkeys()) for detName, (detPath, condNodes) in elementsWithTESAndCondDBNodes.iteritems(): ### get the IOVs for all elements, and combine them timeLine = [("gap", (since, until))] for layerReader in conddbReaders: timeLineUpdated = list(timeLine) alreadyInserted = 0 for i, (typ, (gapBegin, gapEnd)) in enumerate(timeLine): if typ == "gap": iovs = combinedIOVs([ list((max(toDateTime(iov.since.ns()), gapBegin), min(toDateTime(iov.until.ns()), gapEnd)) for iov in layerReader.getIOVs( node, gbl.ICondDBReader.IOV( gbl.Gaudi.Time(toTimeStamp(gapBegin)), gbl.Gaudi.Time(toTimeStamp(gapEnd))), 0)) for node in TrackingAlignmentCondDBNodes[detName] ]) if len(iovs) != 0: updatedTimeSlice = list( ("iov", (begin, end)) for begin, end in iovs) if updatedTimeSlice[0][1][0] > gapBegin: updatedTimeSlice.insert( 0, ("gap", (gapBegin, updatedTimeSlice[0][1][0]))) if updatedTimeSlice[-1][1][1] < gapEnd: updatedTimeSlice.append( ("gap", (updatedTimeSlice[-1][1][1], gapEnd))) timeLineUpdated[i + alreadyInserted:i + alreadyInserted + 1] = updatedTimeSlice alreadyInserted += len(updatedTimeSlice) - 1 logging.debug("timeline after adding %s : %s" % (layerReader, timeLine)) timeLine = timeLineUpdated iovs = list(timespan for typ, timespan in timeLine if typ == "iov") ### For every IOV, extract the parameters for begin, end in iovs: detDataSvc.setEventTime( gbl.Gaudi.Time(toTimeStamp(begin + (end - begin) / 2))) updateManagerSvc.newEvent() motionSystem = None if detName != "Velo" else gaudi.detSvc( ).getObject("/dd/Conditions/Online/Velo/MotionSystem") logging.info("Extracting parameters for %s between %s and %s" % (detName, begin, end)) detTree = getAlignableTreeFromDetectorElement( gaudi.detSvc().getObject(detPath), nodeValue=valueExtractor, parentName=detPath, motionSystem=motionSystem) detTree.name = detName alignmentTrees[detName].append(((begin, end), detTree)) gaudi.finalize() gaudi.exit() return alignmentTrees
class Monitor(Task): def __init__(self, name, queues, condition): Task.__init__(self, name) self._config = dict() self._name = name self._inQueue = queues[0] self._outQueue = queues[1] self._condition = condition def configure(self, configuration): from Configurables import LHCbApp app = LHCbApp() for (attr, value) in configuration.items(): if hasattr(app, attr): setattr(app, attr, value) self._config[attr] = value EventSelector().Input = self._config['Input'] if 'Catalogs' in self._config.keys(): FileCatalog().Catalogs = self._config['Catalogs'] from Configurables import DecodeRawEvent importOptions("$L0DUOPTS/L0DUConfig.opts") EventPersistencySvc().CnvServices.append('LHCb::RawDataCnvSvc') EventSelector().PrintFreq = 1000 from Configurables import CondDB CondDB().Online = True from Configurables import GaudiSequencer as Sequence from Configurables import createODIN, HltRoutingBitsFilter seq = Sequence("MonitorSequence") physFilter = HltRoutingBitsFilter("PhysFilter", RequireMask=[0x0, 0x4, 0x0]) co = createODIN() seq.Members = [co, physFilter] from DAQSys.Decoders import DecoderDB from itertools import product for stage, t in product(('Hlt1', 'Hlt2'), ('Dec', 'Sel', 'Vertex')): an = "{0}{1}ReportsDecoder".format(stage, t) seq.Members += [ DecoderDB["Hlt%sReportsDecoder/%s" % (t, an)].setup() ] ApplicationMgr().TopAlg = [seq] self._extra_config(seq) def _extra_config(self, seq): pass def _pre_init(self): pass def _post_init(self): self._filter = self._appMgr.algorithm('PhysFilter')._ialg def initialize(self): # Configure the app by instantiating the AppMgr self._appMgr = AppMgr() # Get the EventDataSvc for later use self._evtSvc = self._appMgr.evtSvc() # Initialize self._pre_init() self._appMgr.initialize() self._post_init() self._condition.acquire() self._condition.notify() self._condition.release() def run(self): nEvents = self._config['EvtMax'] event = 1 while True: self._condition.acquire() self._appMgr.run(1) # Get the ODIN if not self._evtSvc['DAQ']: self.done() break # Get the event time info = self.make_info() if not info: self._condition.release() continue event += 1 if info: self._outQueue.put(info) if event == nEvents: self.done() break else: ## self._condition.wait() self._condition.release() try: message = self._inQueue.get(False) if message == "BREAK": self._condition.release() break except Queue.Empty: pass def make_info(self): pass def finalize(self): self._appMgr.stop() self._appMgr.finalize() def done(self): # Max events reached, signal done to the main process self._outQueue.put('DONE') self._condition.release() def name(self): return self._name def filterPassed(self): return self._filter.filterPassed()