diff --git a/README.md b/README.md index 8ab8aaa..d768b3e 100644 --- a/README.md +++ b/README.md @@ -28,8 +28,9 @@ mpirun -n python run_backend_reducer.py ``` where `` is the desired number of MPI ranks. It *must* match the number of ranks used for the backend-live-listener. -**Visualizer:** +**Visualizers for instrumentview and histogram:** ```sh +python run_instrumentvisualizer.py python run_visualizer.py ``` diff --git a/backend/MPIDataSplit.py b/backend/MPIDataSplit.py new file mode 100644 index 0000000..a63f9c9 --- /dev/null +++ b/backend/MPIDataSplit.py @@ -0,0 +1,6 @@ + + +def determine_data_split(index, num_processes): + target = index % num_processes + return target + diff --git a/backend/__init__.py b/backend/__init__.py index 9675c3a..e1dc38c 100644 --- a/backend/__init__.py +++ b/backend/__init__.py @@ -1,5 +1,7 @@ from backend_event_listener import BackendEventListener from backend_mantid_reducer import BackendMantidReducer -from result_publisher import ResultPublisher +from histogram_publisher import HistogramPublisher +from instrumentview_publisher import InstrumentViewPublisher +from spectraview_publisher import SpectraViewPublisher from zmq_queue import ZMQQueueServer from zmq_queue import ZMQQueueClient diff --git a/backend/backend_event_listener.py b/backend/backend_event_listener.py index b78d40a..16b0465 100644 --- a/backend/backend_event_listener.py +++ b/backend/backend_event_listener.py @@ -5,7 +5,7 @@ from logger import log from backend_worker import BackendWorker - +import MPIDataSplit # master connectes to main event stream and distributes it to all # packets are put in a queue @@ -60,10 +60,10 @@ def _distribute_stream(self, what, data): split = [] for i in range(self._comm.size): split.append([]) - for i in data: - detector_id = int(i[0]) - target = detector_id % self._comm.size - split[target].append(i) + for i in data: + detector_id = int(i[0]) + target = MPIDataSplit.determine_data_split(detector_id, self._comm.size) + split[target].append(i) else: split = None what = self._comm.scatter([what]*self._comm.size, root=0) @@ -72,3 +72,4 @@ def _distribute_stream(self, what, data): return what, data else: return what, numpy.array(data) + diff --git a/backend/backend_mantid_reducer.py b/backend/backend_mantid_reducer.py index 92c25da..eff69b0 100644 --- a/backend/backend_mantid_reducer.py +++ b/backend/backend_mantid_reducer.py @@ -13,6 +13,7 @@ from mantid_filter_transition import MantidFilterTransition from mantid_rebin_transition import MantidRebinTransition from gather_histogram_transition import GatherHistogramTransition +from gather_spectra_transition import GatherSpectraTransition class BackendMantidReducer(BackendWorker): @@ -30,6 +31,10 @@ def __init__(self, data_queue_in): self._rebin_transition = MantidRebinTransition(self._filter_transition) self._gather_histogram_transition = GatherHistogramTransition(self._rebin_transition) self._gather_histogram_transition.accumulate_data = True + self._rebin_for_instrumentview_transition = MantidRebinTransition(self._create_workspace_from_events_transition) + self._rebin_for_instrumentview_transition.set_bin_parameters('0,5,10') #set to single bin + self._gather_spectra_transition = GatherSpectraTransition(self._create_workspace_from_events_transition) + self._gather_spectra_transition.set_spectra_id('1') def _process_command(self, command): setattr(self, command[0], command[1]) @@ -76,8 +81,11 @@ def get_bin_boundaries(self): def get_bin_values(self): return self._rebin_transition.get_checkpoint()[-1].data.readY(0) + def get_spectra_id(self): + return self._gather_spectra_transition._spectra_id + def get_parameter_dict(self): - return {'bin_parameters':'str', 'filter_interval_parameters':'str', 'filter_pulses':'bool'} + return {'bin_parameters':'str', 'filter_interval_parameters':'str', 'filter_pulses':'bool', 'spectra_id':'str'} @property def bin_parameters(self): @@ -89,6 +97,16 @@ def bin_parameters(self, parameters): self._rebin_transition.set_bin_parameters(parameters) self._lock.release() + @property + def spectra_id(self): + return self._gather_spectra_transition._spectra_id + + @spectra_id.setter + def spectra_id(self, spectra): + self._lock.acquire() + self._gather_spectra_transition.set_spectra_id(spectra) + self._lock.release() + @property def filter_pulses(self): return self._filter_pulses diff --git a/backend/gather_spectra_transition.py b/backend/gather_spectra_transition.py new file mode 100644 index 0000000..723be07 --- /dev/null +++ b/backend/gather_spectra_transition.py @@ -0,0 +1,36 @@ +import numpy +from mpi4py import MPI +import random +from transition import Transition +from histogram_checkpoint import HistogramCheckpoint +import MPIDataSplit + +class GatherSpectraTransition(Transition): + def __init__(self, parent): + self._comm = MPI.COMM_WORLD + self._spectra_id = '1' #also set as 1 in backendreducer + super(GatherSpectraTransition, self).__init__(parents=[parent]) + + def _do_transition(self, data): + index = int(self._spectra_id) #workspaceIndex + target = MPIDataSplit.determine_data_split(index, self._comm.size) + data = data[0].data + x = data.readX(index) + y = data.readY(index) + if self._comm.Get_rank() == target: + packet = numpy.concatenate((x, y)) + requestXY = self._comm.isend(packet, dest=0) + requestXY.Wait() + if self._comm.Get_rank() == 0: + packet = self._comm.recv(source=target) + x,y = numpy.array_split(packet, 2) + return x, y, index + + + + def set_spectra_id(self, spectra_id): + self._spectra_id = spectra_id + self.trigger_rerun() + + def _create_checkpoint(self): + return HistogramCheckpoint() diff --git a/backend/histogram_publisher.py b/backend/histogram_publisher.py new file mode 100644 index 0000000..84a5d92 --- /dev/null +++ b/backend/histogram_publisher.py @@ -0,0 +1,64 @@ +import time +import numpy +import zmq + +from logger import log +import ports +from result_publisher import ResultPublisher + + +class HistogramPublisher(ResultPublisher): + def __init__(self, eventListener): + super(ResultPublisher, self).__init__(type(self).__name__) + self.eventListener = eventListener + self._update_rate = 1.0 + self.socket = None + self._last_count = 0 + + def run(self): + log.info("Starting ResultPublisher") + self.connect() + + self._publish_clear() + while True: + count = len(self.eventListener._gather_histogram_transition.get_checkpoint()) + if count != self._last_count: + self._publish_clear() + self._last_count = count + for i in range(count): + if self.eventListener._gather_histogram_transition.get_checkpoint()[i]: + self._publish(i) + time.sleep(self.update_rate) + + def connect(self): + context = zmq.Context() + self.socket = context.socket(zmq.PUB) + uri = 'tcp://*:{0:d}'.format(ports.result_stream) + self.socket.bind(uri) + log.info('Bound to ' + uri) + + def _create_header(self, command, index): + return { 'command':command, 'index':index } + + def _publish_clear(self): + header = self._create_header('clear', None) + self.socket.send_json(header) + + def _publish(self, index): + boundaries, values = self.eventListener._gather_histogram_transition.get_checkpoint()[index].data + packet = numpy.concatenate((boundaries, values)) +# print "this boundaries " +str(boundaries) + header = self._create_header('graphData', index) + self.socket.send_json(header, flags=zmq.SNDMORE) + self.socket.send(packet) + + def get_parameter_dict(self): + return {'update_rate':'float'} + + @property + def update_rate(self): + return self._update_rate + + @update_rate.setter + def update_rate(self, update_rate): + self._update_rate = update_rate diff --git a/backend/instrumentview_publisher.py b/backend/instrumentview_publisher.py new file mode 100644 index 0000000..b5900a1 --- /dev/null +++ b/backend/instrumentview_publisher.py @@ -0,0 +1,65 @@ +import time +import numpy +import zmq +import mantid.simpleapi as simpleapi +from logger import log +import ports +from controllable import Controllable + + +class InstrumentViewPublisher(Controllable): + def __init__(self, eventListener): + super(InstrumentViewPublisher, self).__init__(type(self).__name__) + self.eventListener = eventListener + self._update_rate = 1.0 + self.socket = None + self._last_count = 0 + + def run(self): + log.info("Starting InstrumentViewPublisher") + self.connect() + + self._publish_clear() + while True: + if self.eventListener._rebin_for_instrumentview_transition.get_checkpoint(): + self._publish() + time.sleep(self.update_rate) + + def connect(self): + context = zmq.Context() + self.socket = context.socket(zmq.PUB) + uri = 'tcp://*:{0:d}'.format(ports.instrumentview_result_stream) + self.socket.bind(uri) + log.info('Bound to ' + uri) + + def _create_header(self, command, index): + return { 'command':command, 'index':index } + + def _publish_clear(self): + header = self._create_header('clear', None) + self.socket.send_json(header) + + def _publish(self): + currentws = simpleapi.CloneWorkspace(self.eventListener._rebin_for_instrumentview_transition.get_checkpoint().data) + concatPacket = [] + concatIndex = [] + for i in range(currentws.getNumberHistograms()): + seriesX = currentws.readX(i) + seriesY = currentws.readY(i) + seriesE = currentws.readE(i) + packet = numpy.concatenate((seriesX, seriesY, seriesE)) #and index? + concatPacket= numpy.concatenate((concatPacket, packet)) + header = self._create_header('instrumentData', 1) + self.socket.send_json(header, flags=zmq.SNDMORE) + self.socket.send(concatPacket) + + def get_parameter_dict(self): + return {'update_rate':'float'} + + @property + def update_rate(self): + return self._update_rate + + @update_rate.setter + def update_rate(self, update_rate): + self._update_rate = update_rate diff --git a/backend/result_publisher.py b/backend/result_publisher.py index 33231e5..31a91f6 100644 --- a/backend/result_publisher.py +++ b/backend/result_publisher.py @@ -1,4 +1,3 @@ -import time import numpy import zmq @@ -6,53 +5,37 @@ import ports from controllable import Controllable - class ResultPublisher(Controllable): def __init__(self, eventListener): - super(ResultPublisher, self).__init__(type(self).__name__) - self.eventListener = eventListener - self._update_rate = 1.0 - self.socket = None - self._last_count = 0 + super(ResultPublisher, self).__init__(type(self).__name__) + self.eventListener = eventListener + self._update_rate = 1.0 + self.socket = None + self._last_count = 0 + self.ports = None def run(self): - log.info("Starting ResultPublisher") - self.connect() - - self._publish_clear() - while True: - count = len(self.eventListener._gather_histogram_transition.get_checkpoint()) - if count != self._last_count: - self._publish_clear() - self._last_count = count - for i in range(count): - if self.eventListener._gather_histogram_transition.get_checkpoint()[i]: - self._publish(i) - time.sleep(self.update_rate) + pass def connect(self): - context = zmq.Context() - self.socket = context.socket(zmq.PUB) - uri = 'tcp://*:{0:d}'.format(ports.result_stream) - self.socket.bind(uri) - log.info('Bound to ' + uri) + context = zmq.Context() + self.socket = context.socket(zmq.PUB) + uri = 'tcp://*:{0:d}'.format(self.ports) + self.socket.bind(uri) + log.info('Bound to ' + uri) - def _create_header(self, command, index): - return { 'command':command, 'index':index } + def _create_header(self,command,index): + return {'command':command, 'index':index} def _publish_clear(self): - header = self._create_header('clear', None) - self.socket.send_json(header) + header = self._create_header('clear', None) + self.socket.send_json(header) def _publish(self, index): - boundaries, values = self.eventListener._gather_histogram_transition.get_checkpoint()[index].data - packet = numpy.concatenate((boundaries, values)) - header = self._create_header('data', index) - self.socket.send_json(header, flags=zmq.SNDMORE) - self.socket.send(packet) + pass def get_parameter_dict(self): - return {'update_rate':'float'} + return {'update_rate':'float'} @property def update_rate(self): @@ -60,4 +43,4 @@ def update_rate(self): @update_rate.setter def update_rate(self, update_rate): - self._update_rate = update_rate + self._update_rate = update_rate diff --git a/backend/spectraview_publisher.py b/backend/spectraview_publisher.py new file mode 100644 index 0000000..e16b0b5 --- /dev/null +++ b/backend/spectraview_publisher.py @@ -0,0 +1,63 @@ +import time +import numpy +import zmq +import mantid.simpleapi as simpleapi +from logger import log +import ports +from controllable import Controllable + + +class SpectraViewPublisher(Controllable): + def __init__(self, eventListener): + super(SpectraViewPublisher, self).__init__(type(self).__name__) + self.eventListener = eventListener + self._update_rate = 1.0 + self.socket = None + self._last_count = 0 + + def run(self): + log.info("Starting SpectraViewPublisher") + self.connect() + + self._publish_clear() + while True: + if self.eventListener._create_workspace_from_events_transition.get_checkpoint(): + self._publish() + time.sleep(self.update_rate) + + def connect(self): + context = zmq.Context() + self.socket = context.socket(zmq.PUB) + uri = 'tcp://*:{0:d}'.format(ports.spectra_result_stream) + self.socket.bind(uri) + log.info('Bound to ' + uri) + + def _create_header(self, command, index): + return { 'command':command, 'index':index } + + def _publish_clear(self): + header = self._create_header('clear', None) + self.socket.send_json(header) + + def _publish(self): + try: + x, y = self.eventListener._gather_spectra_transition.get_checkpoint().data + except TypeError: + time.sleep(5) + x, y = self.eventListener._gather_spectra_transition.get_checkpoint().data + index = self.eventListener._gather_spectra_transition._spectra_id + packet = numpy.concatenate((x, y)) + header = self._create_header('spectraData', index) + self.socket.send_json(header, flags=zmq.SNDMORE) + self.socket.send(packet) + + def get_parameter_dict(self): + return {'update_rate':'float'} + + @property + def update_rate(self): + return self._update_rate + + @update_rate.setter + def update_rate(self, update_rate): + self._update_rate = update_rate diff --git a/picktabtest.py b/picktabtest.py new file mode 100644 index 0000000..744f6a2 --- /dev/null +++ b/picktabtest.py @@ -0,0 +1,43 @@ +from threading import Thread +import time +import random +import sys +import PyQt4 +import mantid.simpleapi as simpleapi +import mantidqtpython as mpy +import numpy + +ws = simpleapi.WorkspaceFactory.create("Workspace2D", 1000, 2,1) +simpleapi.AnalysisDataService.Instance().addOrReplace('POWDIFF_test', ws) +simpleapi.LoadInstrument(Workspace=ws, Filename='data/POWDIFF_Definition.xml', RewriteSpectraMap=True) +ws = simpleapi.Rebin(ws, "0,0.1,2") +simpleapi.AnalysisDataService.Instance().addOrReplace('POWDIFF_test', ws) +InstrumentWidget = mpy.MantidQt.MantidWidgets.InstrumentWidget +app = PyQt4.QtGui.QApplication(sys.argv) +iw = InstrumentWidget("POWDIFF_test") +iw.show() +picktab = iw.getTab("Pick") +picktab.__class__ = mpy.MantidQt.MantidWidgets.InstrumentWidgetPickTab +#picktab.get_currentPickID() +dir(picktab) + +x = 1 +def addtoY(): + x =1 + while 1: + time.sleep(1) + x+=1 + print x + + ws.dataY(2)[1]+=1 + ws.dataY(random.randint(1,999))[random.randint(1,9)] += random.randint(1,6) + simpleapi.AnalysisDataService.Instance().addOrReplace('POWDIFF_test', ws) #added this line + print "the detector ID is" + print picktab.get_currentPickID() + + +ws.dataY(1)[9] = 3 +ws.dataY(1)[8] = 9 +addThread = Thread(target=addtoY) +addThread.start() +app.exec_() diff --git a/ports.py b/ports.py index 5e99fbb..dc71da6 100644 --- a/ports.py +++ b/ports.py @@ -1,5 +1,7 @@ event_stream = 10001 streamer_control = 10002 result_stream = 10003 -result_publisher_control = 10004 +histogram_publisher_control = 10004 rebin_control = 10005 +instrumentview_result_stream = 10006 +spectra_result_stream = 10007 diff --git a/run_backend_reducer.py b/run_backend_reducer.py index 46dc1c9..551ba43 100644 --- a/run_backend_reducer.py +++ b/run_backend_reducer.py @@ -1,6 +1,8 @@ from logger import setup_global_logger from backend import BackendMantidReducer -from backend import ResultPublisher +from backend import HistogramPublisher +from backend import InstrumentViewPublisher +from backend import SpectraViewPublisher from backend import ZMQQueueServer from backend import ZMQQueueClient from parameter_control_server import ParameterControlServer @@ -36,11 +38,17 @@ reducer_controller_thread = threading.Thread(target=reducer_controller.run) reducer_controller_thread.start() - resultPublisher = ResultPublisher(reducer) - resultPublisher_thread = threading.Thread(target=resultPublisher.run) - resultPublisher_thread.start() - - parameterController = ParameterControlServer(controllees=[resultPublisher], port=ports.result_publisher_control) + histogramPublisher = HistogramPublisher(reducer) + histogramPublisher_thread = threading.Thread(target=histogramPublisher.run) + histogramPublisher_thread.start() + instrumentViewPublisher = InstrumentViewPublisher(reducer) + instrumentViewPublisher_thread = threading.Thread(target=instrumentViewPublisher.run) + instrumentViewPublisher_thread.start() + spectraViewPublisher = SpectraViewPublisher(reducer) + spectraViewPublisher_thread = threading.Thread(target=spectraViewPublisher.run) + spectraViewPublisher_thread.start() + parameterController = ParameterControlServer(controllees=[instrumentViewPublisher], port=ports.histogram_publisher_control) + parameterController = ParameterControlServer(controllees=[histogramPublisher], port=ports.histogram_publisher_control) parameterController_thread = threading.Thread(target=parameterController.run) parameterController_thread.start() diff --git a/run_instrumentvisualizer.py b/run_instrumentvisualizer.py new file mode 100644 index 0000000..4731802 --- /dev/null +++ b/run_instrumentvisualizer.py @@ -0,0 +1,26 @@ +from threading import Thread +import PyQt4 +import sys +from logger import setup_global_logger +import ports +import command_line_parser +from visualizer import DataListener +from visualizer import InstrumentView + +app = PyQt4.QtGui.QApplication(sys.argv) + +setup_global_logger(level=command_line_parser.get_log_level()) + +data_listener = DataListener(host=command_line_parser.get_host(), port=ports.instrumentview_result_stream) +data_listener_thread = Thread(target=data_listener.run) +data_listener_thread.daemon = True +instrumentview = InstrumentView(data_listener) +data_listener.clear.connect(instrumentview.clear) +data_listener.new_data.connect(instrumentview.updateInstrumentView) +data_listener_thread.start() + +## Start Qt event loop unless running in interactive mode or using pyside. +if __name__ == '__main__': + import sys + if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'): + app.instance().exec_() diff --git a/run_spectraVisualizer.py b/run_spectraVisualizer.py new file mode 100644 index 0000000..7296046 --- /dev/null +++ b/run_spectraVisualizer.py @@ -0,0 +1,27 @@ +from threading import Thread + +from pyqtgraph.Qt import QtGui + +from logger import setup_global_logger +import ports +import command_line_parser +from visualizer import DataListener +from visualizer import SpectraPlotter + + +setup_global_logger(level=command_line_parser.get_log_level()) + +data_listener = DataListener(host=command_line_parser.get_host(), port=ports.spectra_result_stream) +data_listener_thread = Thread(target=data_listener.run) +data_listener_thread.daemon = True +spectraPlotter = SpectraPlotter(data_listener) + +data_listener.clear.connect(spectraPlotter.clear) +data_listener.new_data.connect(spectraPlotter.update) +data_listener_thread.start() + +## Start Qt event loop unless running in interactive mode or using pyside. +if __name__ == '__main__': + import sys + if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'): + QtGui.QApplication.instance().exec_() diff --git a/visualizer/__init__.py b/visualizer/__init__.py index 0aaffd0..4f5a01a 100644 --- a/visualizer/__init__.py +++ b/visualizer/__init__.py @@ -1,2 +1,4 @@ -from visualizer import Plotter +from visualizer import InstrumentView from visualizer import DataListener +from visualizer import Plotter +from visualizer import SpectraPlotter diff --git a/visualizer/visualizer.py b/visualizer/visualizer.py index a89c2b0..f96ed0c 100644 --- a/visualizer/visualizer.py +++ b/visualizer/visualizer.py @@ -1,13 +1,75 @@ from collections import deque +from parameter_control_client import ParameterControlClient +from general_parameter_controller import GeneralParameterController import zmq - +import sys +import numpy +import PyQt4 +import mantid.simpleapi as simpleapi +import mantidqtpython as mpy +import random +from logger import log import pyqtgraph as pg from pyqtgraph.Qt import QtCore -import numpy +ConfigService = simpleapi.ConfigService -from logger import log +class InstrumentView(object): + def __init__(self, dataListener): + + self.dataListener = dataListener + ws = simpleapi.CreateSimulationWorkspace(Instrument='data/POWDIFF_Definition.xml', BinParams='1,0.5,2') + self._number_of_spectra = ws.getNumberHistograms() + ws = simpleapi.WorkspaceFactory.Instance().create("Workspace2D", self._number_of_spectra, 2, 1) + simpleapi.AnalysisDataService.Instance().addOrReplace('POWDIFF_test', ws) + simpleapi.LoadInstrument(Workspace=ws, Filename='data/POWDIFF_Definition.xml', RewriteSpectraMap=True) + ws = simpleapi.Rebin(ws, "0,5,10") + simpleapi.AnalysisDataService.Instance().addOrReplace('POWDIFF_test', ws) + ws.getAxis(0).setUnit('tof') + control_client = ParameterControlClient("localhost", 10005) + self.controller = GeneralParameterController(control_client) + + + InstrumentWidget = mpy.MantidQt.MantidWidgets.InstrumentWidget + self.iw = InstrumentWidget('POWDIFF_test') + self.iw.show() + + self.pickTab = self.iw.getTab("Pick") + self.pickTab.__class__ = mpy.MantidQt.MantidWidgets.InstrumentWidgetPickTab + #while getTab does return an InstrumentWidgetPickTab class object, python assumes it is still just an InstrumentWidget object until it is specifically cast + dir(self.pickTab) + #after being cast, the class attributes have not yet been updated, calling dir() does this + self.pickID = self.pickTab.get_currentPickID() + + def updateDetectorID(self): + if self.pickID != self.pickTab.get_currentPickID(): + self.pickID = self.pickTab.get_currentPickID() + self.controller.set_parameter_value('BackendMantidReducer', 'spectra_id', self.pickID) + #update this to be -1 and therefore null when mouse off spectragraph? + + + def clear(self): + ws = simpleapi.AnalysisDataService['POWDIFF_test'] + #could either delete workspace and go through the __init__ again or clear the data individually? + def updateInstrumentView(self): + #receive signal that it has updated here, then print out new number? + ws = simpleapi.AnalysisDataService['POWDIFF_test'] + simpleapi.AnalysisDataService.Instance().addOrReplace('POWDIFF_test', ws) + self.updateDetectorID() + while self.dataListener.data: + data = self.dataListener.data.popleft() + index = 0 + for packet in numpy.array_split(data, 1000): + x, y, e = numpy.array_split(packet, 3) + ws.dataY(index)[1] = y[0] #is 2 + ws.dataE(index)[1] = e[0] + ws.dataX(index)[0] = x[0] + ws.dataX(index)[1] = x[1] + ws.dataX(index)[2] = x[2] + index+=1 + #self.updateDetectorID() + class Plotter(object): def __init__(self, dataListener): self.dataListener = dataListener @@ -29,13 +91,40 @@ def update(self): self.curves[index].setData(x, y) self.plt1.enableAutoRange('xy', False) +class SpectraPlotter(object): + def __init__(self, dataListener): + self.dataListener = dataListener + self.win = pg.GraphicsWindow() + self.win.resize(800,350) + self.win.setWindowTitle('Spectra for dectector') + self.plt1 = self.win.addPlot() + self.curves = {} + self.old_index = None + self.firstData = True -class DataListener(QtCore.QObject): - clear = QtCore.pyqtSignal() - new_data = QtCore.pyqtSignal() + def clear(self): + self.curves = {} + self.plt1.clear() + + def update(self): + while self.dataListener.data: + index,x,y = self.dataListener.data.popleft() + if not self.firstData: #feels weird fast updating at the moment... maybe it can not update as much + self.plt1.removeItem(self.curves[1]) + self.firstData = False + self.win.setWindowTitle('Spectra for detector ' + str(index)) + y2 = numpy.append(y, [0]) #check best way to make y match x len + self.curves[1] = self.plt1.plot(x, y2)#stepMode=True, pen=(index), name=str(index)) + self.plt1.enableAutoRange('xy', True) + + +class DataListener(PyQt4.QtCore.QObject): + clear = PyQt4.QtCore.pyqtSignal() + new_data = PyQt4.QtCore.pyqtSignal() + def __init__(self, host, port): - QtCore.QObject.__init__(self) + PyQt4.QtCore.QObject.__init__(self) self.data = deque() self._host = host self._port = port @@ -45,10 +134,18 @@ def run(self): self.connect() while True: command, index = self._receive_header() - if command == 'data': - x,y = self.get_histogram() + if command == 'instrumentData': + data = numpy.frombuffer(self.socket.recv(), numpy.float64) + self.data.append((data)) + self.new_data.emit() + if command == 'graphData': + x,y = self.get_histogram() self.data.append((index,x,y)) self.new_data.emit() + if command == 'spectraData': + x, y = self.get_histogram() + self.data.append((index,x,y)) + self.new_data.emit() elif command == 'clear': self.clear.emit() @@ -58,12 +155,12 @@ def connect(self): uri = 'tcp://{0}:{1:d}'.format(self._host, self._port) self.socket.connect(uri) self.socket.setsockopt(zmq.SUBSCRIBE, '') - log.info('Substribed to result publisher at ' + uri) + log.info('Subscribed to result publisher at ' + uri) def get_histogram(self): data = numpy.frombuffer(self.socket.recv(), numpy.float64) x,y = numpy.array_split(data, 2) - return x,y + return x,y def _receive_header(self): header = self.socket.recv_json()