class PicoPlotter(QtGui.QDialog):
def set_class_vars(self):
self.script = ones
self.n_show = 30
self.live_data = np.full(self.n_show, None)
def __init__(self, parent):
super(PicoPlotter, self).__init__()
self.parent = parent
self.set_class_vars()
self.populate()
def populate(self):
self.setWindowTitle('Live plotter')
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
'''Changed nav toolbar'''
self.nav.addAction('Reset optimizer', self.reset_opt)
self.layout = QtGui.QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
self.canvas.ax.set_ylim((0, 5e-5))
self.canvas.ax.set_xlim((0, .04))
width = self.canvas.width()
height = self.nav.height() + self.canvas.height() + 20
self.setFixedSize(width, height)
def reset_opt(self):
self.live_data = np.full(self.n_show, None)
def live_plot(self):
try:
this_shot = self.script(self.parent.data)
empty_data = np.where(self.live_data == None)
if len(empty_data[0]) == 0:
self.live_data[0:self.n_show - 1] = self.live_data[1:self.n_show]
self.live_data[-1] = this_shot
else:
self.live_data[empty_data[0][0]] = this_shot
except AttributeError:
print('Not loaded')
'''def ones(self):
return 1
'''
def show_window(self):
self.live_plot()
self.canvas.ax.clear()
self.canvas.ax.plot(self.live_data)
# self.canvas.ax.title(np.std(self.live_data))
self.canvas.draw()
class FFTPlotter(QtGui.QDialog):
def __init__(self, data, ts, t):
super(FFTPlotter, self).__init__()
self.populate()
self.show_plot(data, ts, t)
def populate(self):
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
'''Changed nav toolbar'''
self.layout = QtGui.QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
#self.canvas.ax.set_ylim((0, 5e-5))
#self.canvas.ax.set_xlim((0, .04))
width = self.canvas.width()
height = self.nav.height() + self.canvas.height() + 20
self.setFixedSize(width, height)
def show_plot(self, data, ts, t):
print('hello!!')
Pxx, freqs, t0 = show_fft(data, ts, t)
self.setWindowTitle('FFT at time {} s'.format(t0))
self.canvas.ax.clear()
self.canvas.ax.plot(freqs * 1e-6, Pxx)
print(max(freqs * 1e-6))
#self.canvas.ax.set_xlim((0, 20))
self.canvas.ax.set_xlabel("Freq (MHz)")
self.canvas.draw()
class PMTViewer(QtGui.QDialog):
pmt_name = None
data_dir = None
def __init__(self, reactor, cxn=None):
super(PMTViewer, self).__init__(None)
self.reactor = reactor
self.cxn = cxn
print self.data_dir
self.update_id = np.random.randint(0, 2**31 - 1)
self.loading = False
self.connect()
@inlineCallbacks
def connect(self):
if self.cxn is None:
self.cxn = connection()
cname = 'pmt - {} - client'.format(self.pmt_name)
yield self.cxn.connect(name=cname)
self.populate()
yield self.connect_signals()
def populate(self):
self.setWindowTitle(self.pmt_name)
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
self.layout = QtGui.QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
width = self.canvas.width()
height = self.nav.height() + self.canvas.height() + 20
self.setFixedSize(width, height)
self.setWindowTitle('pmt_viewer')
@inlineCallbacks
def connect_signals(self):
pmt_server = yield self.cxn.get_server('pmt')
yield pmt_server.signal__update(self.update_id)
yield pmt_server.addListener(listener=self.receive_update,
source=None,
ID=self.update_id)
def receive_update(self, c, signal_json):
signal = json.loads(signal_json)
for message_type, message in signal.items():
print message_type, message
device_message = message.get(self.pmt_name)
if (message_type == 'record') and (device_message is not None):
self.replot(device_message)
def replot(self, rel_data_path):
abs_data_path = os.path.join(self.data_dir, rel_data_path) + '.hdf5'
with h5py.File(abs_data_path) as h5f:
gnd = h5f['gnd']
exc = h5f['exc']
bac = h5f['bac']
self.canvas.ax.clear()
self.canvas.ax.plot(gnd, label='gnd')
self.canvas.ax.plot(exc, label='exc')
self.canvas.ax.plot(bac, label='bac')
self.canvas.ax.legend()
self.canvas.draw()
def closeEvent(self, x):
self.reactor.stop()
class AnalogVoltageEditor(QtGui.QDialog):
sequence_parameters = {}
def __init__(self,
channel,
sequence,
config,
reactor=None,
cxn=None,
parent=None):
super(AnalogVoltageEditor, self).__init__(parent)
self.channel = str(channel)
self.sequence = sequence
self.ramp_maker = RampMaker
self.config = config
self.reactor = reactor
self.cxn = cxn
self.loading = False
self.connect()
@inlineCallbacks
def connect(self):
if self.cxn is None:
self.cxn = connection()
yield self.cxn.connect()
self.context = yield self.cxn.context()
# yield self.get_sequence_parameters()
yield self.populate()
self.connect_signals()
@inlineCallbacks
def populate(self):
self.setWindowTitle(self.channel)
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
self.ramp_table = RampTable(self.ramp_maker)
self.ramp_scroll = QtGui.QScrollArea()
self.buttons = QtGui.QDialogButtonBox(
QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel,
QtCore.Qt.Horizontal, self)
self.ramp_scroll.setWidget(self.ramp_table)
self.ramp_scroll.setFixedHeight(
self.ramp_table.height() +
self.ramp_scroll.horizontalScrollBar().height() - 10)
self.ramp_scroll.setWidgetResizable(True)
self.buttons.button(QtGui.QDialogButtonBox.Ok).setDefault(False)
self.layout = QtGui.QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.layout.addWidget(self.ramp_scroll)
self.layout.addWidget(self.buttons)
self.setLayout(self.layout)
width = self.canvas.width()
height = self.nav.height() + self.canvas.height(
) + self.ramp_scroll.height() + 20
self.setFixedSize(width, height)
yield self.set_columns()
yield self.replot()
@inlineCallbacks
def connect_signals(self):
# pyqt signals
for c in self.ramp_table.cols:
c.ramp_select.currentIndexChanged.connect(self.replot)
for pw in c.parameter_widgets.values():
for pb in pw.pboxes.values():
pb.returnPressed.connect(self.replot)
for i, c in enumerate(self.ramp_table.cols):
c.add.clicked.connect(self.add_column(i))
c.dlt.clicked.connect(self.dlt_column(i))
c.zero_button.clicked.connect(self.zero_column(i))
c.prev_button.clicked.connect(self.prev_column(i))
c.next_button.clicked.connect(self.next_column(i))
# c.all_zero.clicked.connect(self.all_zero(i))
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
# labrad signals
conductor = yield self.cxn.get_server(self.config.conductor_servername)
yield conductor.signal__parameters_updated(
self.config.conductor_update_id)
yield conductor.addListener(listener=self.receive_parameters,
source=None,
ID=self.config.conductor_update_id)
@inlineCallbacks
def get_sequence_parameters(self):
conductor = yield self.cxn.get_server(self.config.conductor_servername)
sp = yield conductor.set_sequence_parameters()
self.sequence_parameters = json.loads(sp)
@inlineCallbacks
def receive_parameters(self, c, signal):
yield self.replot()
@inlineCallbacks
def set_columns(self):
self.loading = True
for c in self.ramp_table.cols:
c.hide()
for s, c in zip(self.sequence[self.channel], self.ramp_table.cols):
ramp_type = s['type']
c.show()
c.ramp_select.setCurrentIndex(c.ramp_select.findText(ramp_type))
for k in c.parameter_widgets[ramp_type].pboxes.keys():
c.parameter_widgets[ramp_type].pboxes[k].display(s[k])
self.loading = False
yield self.replot()
def add_column(self, i):
def ac():
sequence = self.get_sequence()
for c in sequence.keys():
sequence[c].insert(i, sequence[c][i])
scroll_position = self.ramp_scroll.horizontalScrollBar().value()
self.set_sequence(sequence)
self.ramp_scroll.horizontalScrollBar().setValue(scroll_position)
return ac
def dlt_column(self, i):
def dc():
sequence = self.get_sequence()
for c in sequence.keys():
sequence[c].pop(i)
scroll_position = self.ramp_scroll.horizontalScrollBar().value()
self.set_sequence(sequence)
self.ramp_scroll.horizontalScrollBar().setValue(scroll_position)
return dc
def zero_column(self, i):
def zc():
sequence = self.get_sequence()
dt = sequence[self.channel][i]['dt']
sequence[self.channel][i] = {'dt': dt, 'type': 's', 'vf': 0.0}
scroll_position = self.ramp_scroll.horizontalScrollBar().value()
self.set_sequence(sequence)
self.ramp_scroll.horizontalScrollBar().setValue(scroll_position)
return zc
def prev_column(self, i):
def pc():
sequence = self.get_sequence()
if i > 0:
dt = sequence[self.channel][i]['dt']
sequence[self.channel][i] = deepcopy(sequence[self.channel][i -
1])
sequence[self.channel][i]['dt'] = dt
scroll_position = self.ramp_scroll.horizontalScrollBar().value()
self.set_sequence(sequence)
self.ramp_scroll.horizontalScrollBar().setValue(scroll_position)
return pc
def next_column(self, i):
def nc():
sequence = self.get_sequence()
if i < len(sequence[self.channel]) - 1:
dt = sequence[self.channel][i]['dt']
sequence[self.channel][i] = deepcopy(sequence[self.channel][i +
1])
sequence[self.channel][i]['dt'] = dt
scroll_position = self.ramp_scroll.horizontalScrollBar().value()
self.set_sequence(sequence)
self.ramp_scroll.horizontalScrollBar().setValue(scroll_position)
return nc
# def all_zero(self, i):
# def az():
# sequence = self.get_sequence()
# for i in range(0, len(sequence[self.channel])):
# dt = sequence[self.channel][i]['dt']
# sequence[self.channel][i] = {'dt': dt, 'type': 's', 'vf': 0.0}
# i += 1
# self.set_sequence(sequence)
# return az
def set_sequence(self, sequence):
self.sequence = sequence
self.set_columns()
@inlineCallbacks
def get_plottable_sequence(self):
sequence = self.ramp_table.get_channel_sequence()
parameters = {'sequencer': get_sequence_parameters(sequence)}
parameters_json = json.dumps(parameters)
conductor = yield self.cxn.get_server(self.config.conductor_servername)
pv_json = yield conductor.get_parameter_values(parameters_json, True)
parameter_values = json.loads(pv_json)['sequencer']
plottable_sequence = substitute_sequence_parameters(
sequence, parameter_values)
returnValue(self.ramp_maker(plottable_sequence).get_plottable())
def get_sequence(self):
channel_sequence = self.ramp_table.get_channel_sequence()
self.sequence.update({self.channel: channel_sequence})
return self.sequence
@inlineCallbacks
def replot(self, c=None):
if not self.loading:
T, V = yield self.get_plottable_sequence()
self.canvas.make_figure(T, V)
self.canvas.draw()
def getEditedSequence(self):
return self.get_sequence()
def keyPressEvent(self, c):
if QtGui.QApplication.keyboardModifiers() == QtCore.Qt.ControlModifier:
if c.key() == QtCore.Qt.Key_Return:
self.buttons.accepted.emit()
if c.key() == QtCore.Qt.Key_Q:
self.buttons.rejected.emit()
else:
QtGui.QWidget().keyPressEvent(c)
class ElectrodeEditor(QtGui.QDialog):
sequence_parameters = {}
def __init__(self,
channels,
sequence,
electrode_sequence,
config,
reactor=None,
cxn=None,
parent=None):
super(ElectrodeEditor, self).__init__(parent)
self.channels = channels
self.sequence = sequence
self.ramp_maker = RampMaker
self.config = config
self.reactor = reactor
self.cxn = cxn
self.lookup = self.generateChannelLookup(self.channels)
self.electrode_sequence = self.check_electrode_sequence(
electrode_sequence)
self.sequence_length = len(electrode_sequence)
self.presets = {}
self.loading = False
self.connect()
def generateChannelLookup(self, channels):
lookup = {}
for i, nl in enumerate(
sorted(self.channels, key=lambda nl: nl.split('@')[1])):
lookup[self.config.electrode_channel_map[i]] = nl
return lookup
def check_electrode_sequence(self, electrode_sequence):
dummy = self.sequence.keys()[0]
dummy_seq = self.sequence[dummy]
if len(electrode_sequence) != len(dummy_seq):
electrode_sequence = []
for x in dummy_seq:
v = deepcopy(zero_sequence(x['dt']))
electrode_sequence.append(v)
return electrode_sequence
@inlineCallbacks
def connect(self):
if self.cxn is None:
self.cxn = connection()
yield self.cxn.connect()
self.context = yield self.cxn.context()
# yield self.get_sequence_parameters()
self.populate()
yield self.connect_signals()
yield self.update_presets()
def populate(self):
self.setWindowTitle("Electrode control")
self.canvas = MplCanvas(self.config.electrode_channel_map)
self.nav = NavigationToolbar(self.canvas, self)
self.ramp_table = RampTable(self.ramp_maker, self.sequence_length)
self.ramp_scroll = QtGui.QScrollArea()
self.buttons = QtGui.QDialogButtonBox(
QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel,
QtCore.Qt.Horizontal, self)
self.ramp_scroll.setWidget(self.ramp_table)
self.ramp_scroll.setFixedHeight(
self.ramp_table.height() +
self.ramp_scroll.horizontalScrollBar().height() - 10)
self.ramp_scroll.setWidgetResizable(True)
self.buttons.button(QtGui.QDialogButtonBox.Ok).setDefault(False)
self.layout = QtGui.QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.layout.addWidget(self.ramp_scroll)
self.layout.addWidget(self.buttons)
self.setLayout(self.layout)
width = self.canvas.width()
height = self.nav.height() + self.canvas.height(
) + self.ramp_scroll.height() + 20
self.setFixedSize(width, height)
@inlineCallbacks
def connect_signals(self):
# pyqt signals
for c in self.ramp_table.cols:
c.ramp_select.currentIndexChanged.connect(self.replot)
for pw in c.parameter_widgets.values():
for key, pb in pw.pboxes.items():
if key == 'vi' or key == 'vf':
pb.currentIndexChanged.connect(self.replot)
else:
pb.returnPressed.connect(self.replot)
for i, c in enumerate(self.ramp_table.cols):
# c.add.clicked.connect(self.add_column(i))
# c.dlt.clicked.connect(self.dlt_column(i))
c.zero_button.clicked.connect(self.zero_column(i))
c.prev_button.clicked.connect(self.prev_column(i))
c.next_button.clicked.connect(self.next_column(i))
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.electrode = yield self.cxn.get_server(
self.config.electrode_servername)
yield self.electrode.signal__presets_changed(
self.config.electrode_update_id)
yield self.electrode.addListener(listener=self._update_presets,
source=None,
ID=self.config.electrode_update_id)
# labrad signals
self.conductor = yield self.cxn.get_server(
self.config.conductor_servername)
yield self.conductor.signal__parameters_updated(
self.config.conductor_update_id)
yield self.conductor.addListener(listener=self.receive_parameters,
source=None,
ID=self.config.conductor_update_id)
@inlineCallbacks
def get_electrode_presets(self):
s = yield self.electrode.get_presets()
s = json.loads(s)
presets = {}
for x in s:
idn = x.pop('id')
presets[idn] = x
self.presets = presets
def _update_presets(self, c, x):
self.update_presets()
@inlineCallbacks
def update_presets(self):
self.loading = True
yield self.get_electrode_presets()
for c in self.ramp_table.cols:
c.updatePresets(self.presets)
self.loading = False
yield self.set_columns()
@inlineCallbacks
def get_sequence_parameters(self):
sp = yield self.conductor.set_sequence_parameters()
self.sequence_parameters = json.loads(sp)
@inlineCallbacks
def receive_parameters(self, c, signal):
yield self.replot()
@inlineCallbacks
def set_columns(self):
self.loading = True
for s, c in zip(self.electrode_sequence, self.ramp_table.cols):
ramp_type = s['type']
c.ramp_select.setCurrentIndex(c.ramp_select.findText(ramp_type))
for k in c.parameter_widgets[ramp_type].pboxes.keys():
c.parameter_widgets[ramp_type].pboxes[k].display(s[k])
self.loading = False
yield self.replot()
def zero_column(self, i):
# QAbstractButton.clicked() sends a bool (for whether the button is checked or not)
# This will cause an error as zc is then called with an extra argument
# Just put *args and ignore them to catch this
@inlineCallbacks
def zc(*args):
self.electrode_sequence = self.getElectrodeSequence()
dt = self.electrode_sequence[i]['dt']
self.electrode_sequence[i] = zero_sequence(dt)
yield self.set_columns()
return zc
def prev_column(self, i):
# See comment on zc()
@inlineCallbacks
def pc(*args):
self.electrode_sequence = self.getElectrodeSequence()
if i > 0:
dt = self.electrode_sequence[i]['dt']
self.electrode_sequence[i] = deepcopy(
self.electrode_sequence[i - 1])
self.electrode_sequence[i]['dt'] = dt
yield self.set_columns()
return pc
def next_column(self, i):
# See comment on zc()
@inlineCallbacks
def nc(*args):
self.electrode_sequence = self.getElectrodeSequence()
if i < len(self.electrode_sequence) - 1:
dt = self.electrode_sequence[i]['dt']
self.electrode_sequence[i] = deepcopy(
self.electrode_sequence[i + 1])
self.electrode_sequence[i]['dt'] = dt
yield self.set_columns()
return nc
def parseElectrodesSequence(self, electrode_sequence):
sequence = {}
for x in self.config.electrode_channel_map:
s = []
for step in electrode_sequence:
seq = deepcopy(step)
vf = self.presets[int(step['vf'])]['values'][x]
seq['vf'] = vf
if step.has_key('vi'):
vi = self.presets[int(step['vi'])]['values'][x]
seq['vi'] = vi
s.append(seq)
sequence[x] = s
return sequence
@inlineCallbacks
def get_plottable_sequence(self):
sequence = self.ramp_table.get_sequence()
parameters_json = json.dumps(
{'sequencer': get_sequence_parameters(sequence)})
pv_json = yield self.conductor.get_parameter_values(
parameters_json, True)
parameter_values = json.loads(pv_json)['sequencer']
sequence = substitute_sequence_parameters(sequence, parameter_values)
fixed_sequence = self.parseElectrodesSequence(sequence)
returnValue({
key: self.ramp_maker(val).get_plottable()
for key, val in fixed_sequence.items()
})
def get_sequence(self):
electrode_sequence = self.ramp_table.get_sequence()
fixed_sequence = self.parseElectrodesSequence(electrode_sequence)
for k, v in fixed_sequence.items():
self.sequence.update({self.lookup[k]: v})
return self.sequence
@inlineCallbacks
def replot(self, c=None):
if not self.loading:
self.canvas.clear()
# Update the electrode sequence
self.electrode_sequence = self.getElectrodeSequence()
seq = yield self.get_plottable_sequence()
self.canvas.make_figure(seq)
# for key, val in seq.items():
# (T, V) = val
# self.canvas.make_figure(T, V, key)
self.canvas.draw()
self.canvas.legend()
def getEditedSequence(self):
return self.get_sequence()
def getElectrodeSequence(self):
return self.ramp_table.get_sequence()
def keyPressEvent(self, c):
if QtGui.QApplication.keyboardModifiers() == QtCore.Qt.ControlModifier:
if c.key() == QtCore.Qt.Key_Return:
self.buttons.accepted.emit()
if c.key() == QtCore.Qt.Key_Q:
self.buttons.rejected.emit()
else:
QtGui.QWidget().keyPressEvent(c)
class AnalogVoltageEditor(QtGui.QDialog):
sequence_parameters = {}
def __init__(self, channel, sequence, cxn, reactor, parent=None):
super(AnalogVoltageEditor, self).__init__(parent)
self.channel = str(channel)
self.sequence = sequence
self.ramp_maker = RampMaker
self.parent = parent
self.cxn = cxn
self.reactor = reactor
self.conductor_update_id = np.random.randint(0, 2**31 - 1)
self.loading = False
self.connect()
@inlineCallbacks
def connect(self):
# self.cxn = connection()
# yield self.cxn.connect()
yield self.get_sequence_parameters()
self.populate()
yield self.connect_signals()
def populate(self):
self.setWindowTitle(self.channel)
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
self.ramp_table = RampTable(self.ramp_maker)
self.ramp_scroll = QtGui.QScrollArea()
self.buttons = QtGui.QDialogButtonBox(
QtGui.QDialogButtonBox.Ok
| QtGui.QDialogButtonBox.Cancel, QtCore.Qt.Horizontal, self)
self.ramp_scroll.setWidget(self.ramp_table)
self.ramp_scroll.setFixedHeight(
self.ramp_table.height() +
self.ramp_scroll.horizontalScrollBar().height() - 10)
self.ramp_scroll.setWidgetResizable(True)
self.buttons.button(QtGui.QDialogButtonBox.Ok).setDefault(False)
self.layout = QtGui.QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.layout.addWidget(self.ramp_scroll)
self.layout.addWidget(self.buttons)
self.setLayout(self.layout)
width = self.canvas.width()
height = self.nav.height() + self.canvas.height(
) + self.ramp_scroll.height() + 20
self.setFixedSize(width, height)
self.set_columns()
self.replot()
@inlineCallbacks
def connect_signals(self):
# pyqt signals
for c in self.ramp_table.cols:
c.ramp_select.currentIndexChanged.connect(self.replot)
for pw in c.parameter_widgets.values():
for pb in pw.pboxes.values():
pb.returnPressed.connect(self.replot)
for i, c in enumerate(self.ramp_table.cols):
c.add.clicked.connect(self.add_column(i))
c.dlt.clicked.connect(self.dlt_column(i))
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
# labrad signals
conductor = yield self.cxn.get_server(self.parent.conductor_servername)
yield conductor.signal__update(self.conductor_update_id)
yield conductor.addListener(listener=self.receive_conductor_update,
source=None,
ID=self.conductor_update_id)
@inlineCallbacks
def get_sequence_parameters(self):
conductor = yield self.cxn.get_server(self.parent.conductor_servername)
parameter_names = get_sequence_parameters(self.sequence)
request = {
parameter_name.replace('*', 'sequencer.'): None
for parameter_name in parameter_names
}
parameter_values_json = yield conductor.get_parameter_values(
json.dumps(request))
parameter_values = json.loads(parameter_values_json)
self.sequence_parameters = {
name.replace('sequencer.', '*'): value
for name, value in parameter_values.items()
}
def receive_conductor_update(self, c, signal_json):
signal = json.loads(signal_json)
for message_type, message in signal.items():
if message_type in [
'set_parameter_values', 'get_parameter_values'
]:
update = {
name.replace('sequencer.', '*'): value
for name, value in message.items()
}
self.sequence_parameters.update(update)
self.replot()
def set_columns(self):
self.loading = True
for c in self.ramp_table.cols:
c.hide()
for s, c in zip(self.sequence[self.channel], self.ramp_table.cols):
ramp_type = s['type']
c.show()
c.ramp_select.setCurrentIndex(c.ramp_select.findText(ramp_type))
for k in c.parameter_widgets[ramp_type].pboxes.keys():
c.parameter_widgets[ramp_type].pboxes[k].display(s[k])
self.loading = False
self.replot()
def add_column(self, i):
def ac():
sequence = self.get_sequence()
for c in sequence.keys():
sequence[c].insert(i, sequence[c][i])
self.set_sequence(sequence)
return ac
def dlt_column(self, i):
def dc():
sequence = self.get_sequence()
for c in sequence.keys():
sequence[c].pop(i)
self.set_sequence(sequence)
return dc
def set_sequence(self, sequence):
self.sequence = sequence
self.set_columns()
def get_plottable_sequence(self):
sequence = self.ramp_table.get_channel_sequence()
plottable_sequence = substitute_sequence_parameters(
sequence, self.sequence_parameters)
return self.ramp_maker(plottable_sequence).get_plottable()
def get_sequence(self):
channel_sequence = self.ramp_table.get_channel_sequence()
self.sequence.update({self.channel: channel_sequence})
return self.sequence
def replot(self, c=None):
if not self.loading:
T, V = self.get_plottable_sequence()
self.canvas.make_figure(T, V)
self.canvas.draw()
def getEditedSequence(self):
return self.get_sequence()
def keyPressEvent(self, c):
if QtGui.QApplication.keyboardModifiers() == QtCore.Qt.ControlModifier:
if c.key() == QtCore.Qt.Key_Return:
self.buttons.accepted.emit()
if c.key() == QtCore.Qt.Key_Q:
self.buttons.rejected.emit()
else:
QtGui.QWidget().keyPressEvent(c)
class PMTViewerNumeric(PMTViewer):
""" Class is modified to also display numeric readout of ground, excited,
background and total counts. These values update every time the plot is updated.
"""
def populate(self):
self.setWindowTitle(self.pmt_name)
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
self.lcdGND = QtGui.QLCDNumber(self)
self.lcdGND.display('0.001')
self.lcdEXC = QtGui.QLCDNumber(self)
self.lcdEXC.display('0.001')
self.lcdBAC = QtGui.QLCDNumber(self)
self.lcdBAC.display('0.000')
self.lcdFRAC = QtGui.QLCDNumber(self)
self.lcdFRAC.display('0.000')
self.lcdTOTAL = QtGui.QLCDNumber(self)
self.lcdTOTAL.display('0.000')
self.labelGND = QtGui.QLabel('GROUND')
self.labelGND.setAlignment(QtCore.Qt.AlignCenter)
self.labelGND.setFont(QtGui.QFont("Arial", 48, QtGui.QFont.Bold))
self.labelEXC = QtGui.QLabel('EXCITED')
self.labelEXC.setAlignment(QtCore.Qt.AlignCenter)
self.labelEXC.setFont(QtGui.QFont("Arial", 48, QtGui.QFont.Bold))
self.labelBAC = QtGui.QLabel('BACKGROUND')
self.labelBAC.setAlignment(QtCore.Qt.AlignCenter)
self.labelBAC.setFont(QtGui.QFont("Arial", 48, QtGui.QFont.Bold))
self.labelFRAC = QtGui.QLabel('EXC. FRACTION')
self.labelFRAC.setAlignment(QtCore.Qt.AlignCenter)
self.labelFRAC.setFont(QtGui.QFont("Arial", 48, QtGui.QFont.Bold))
self.labelTOTAL = QtGui.QLabel('TOTAL')
self.labelTOTAL.setAlignment(QtCore.Qt.AlignCenter)
self.labelTOTAL.setFont(QtGui.QFont("Arial", 48, QtGui.QFont.Bold))
self.layout = QtGui.QGridLayout()
self.layout.setSpacing(1)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.hboxFRAC = QtGui.QHBoxLayout()
self.hboxFRAC.addWidget(self.labelFRAC)
self.hboxFRAC.addWidget(self.lcdFRAC)
self.hboxGND = QtGui.QHBoxLayout()
self.hboxGND.addWidget(self.labelGND)
self.hboxGND.addWidget(self.lcdGND)
self.hboxEXC = QtGui.QHBoxLayout()
self.hboxEXC.addWidget(self.labelEXC)
self.hboxEXC.addWidget(self.lcdEXC)
self.hboxBAC = QtGui.QHBoxLayout()
self.hboxBAC.addWidget(self.labelBAC)
self.hboxBAC.addWidget(self.lcdBAC)
self.hboxTOTAL = QtGui.QHBoxLayout()
self.hboxTOTAL.addWidget(self.labelTOTAL)
self.hboxTOTAL.addWidget(self.lcdTOTAL)
self.layout.addItem(self.hboxFRAC)
self.layout.addItem(self.hboxGND)
self.layout.addItem(self.hboxEXC)
self.layout.addItem(self.hboxBAC)
self.layout.addItem(self.hboxTOTAL)
self.setLayout(self.layout)
width = self.canvas.width() + 500
height = self.nav.height() + self.canvas.height() + 8*self.lcdGND.height() + 200
self.setFixedSize(width, height)
self.setWindowTitle('PMT_trace_viewer')
def replot(self, rel_data_path):
abs_data_path = os.path.join(self.data_dir, rel_data_path) + '.hdf5'
with h5py.File(abs_data_path) as h5f:
gnd = h5f['gnd']
exc = h5f['exc']
bac = h5f['bac']
self.canvas.ax.clear()
self.canvas.ax.plot(gnd, label='gnd')
self.canvas.ax.plot(exc, label='exc')
self.canvas.ax.plot(bac, label='bac')
self.canvas.ax.legend()
gnd = np.mean(h5f['gnd'][3000:23000])
exc = np.mean(h5f['exc'][3000:23000])
bac = np.mean(h5f['bac'][3000:23000])
tot = (gnd+exc-2*bac)
if tot==0:
frac = 0
else:
frac = (exc-bac)/tot
self.lcdGND.display(str(np.round(gnd,3)))
self.lcdEXC.display(str(np.round(exc,3)))
self.lcdBAC.display(str(np.round(bac,3)))
self.lcdFRAC.display(str(np.round(frac,3)))
self.lcdTOTAL.display(str(np.round(tot,3)))
self.canvas.draw()
class PicoViewer(QtGui.QDialog):
name = None
data_dir = None
data_fxn = None
def __init__(self, reactor, cxn=None, ylim = 2e-9):
super(PicoViewer, self).__init__(None)
self.reactor = reactor
self.cxn = cxn
print 'Directory:'
print self.data_dir
self.update_id = np.random.randint(0, 2**31 - 1)
self.loading = False
self.connect()
self.Plotter = PicoPlotter(self)
@inlineCallbacks
def connect(self):
if self.cxn is None:
self.cxn = connection()
cname = 'pico - {} - client'.format(self.name)
yield self.cxn.connect(name=cname)
self.populate()
yield self.connect_signals()
def show_fft(self):
self.mouse_listener = self.canvas.mpl_connect('button_press_event', self.process_click)
def process_click(self, event):
t_click = event.xdata
self.canvas.mpl_disconnect(self.mouse_listener)
self.FFTPlot = FFTPlotter(self.data, self.ts, t_click)
self.FFTPlot.show()
def launch_plotter(self):
self.Plotter.show()
def populate(self):
self.setWindowTitle(self.name)
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
self.nav.addAction('Select analysis method')
self.nav.addAction('Launch live plotter', self.launch_plotter)
self.nav.addAction('Show fft on click', self.show_fft)
self.layout = QtGui.QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
self.canvas.ax.set_ylim(self.ylim)
self.canvas.ax.set_xlim((-.005, .045))
width = self.canvas.width()
height = self.nav.height() + self.canvas.height() + 20
self.setFixedSize(width, height)
self.setWindowTitle('pico_viewer')
@inlineCallbacks
def connect_signals(self):
pico_server = yield self.cxn.get_server('cavity_probe_pico')
yield pico_server.signal__update(self.update_id)
yield pico_server.addListener(listener=self.receive_update, source=None, ID=self.update_id)
def receive_update(self, c, signal_json):
signal = json.loads(signal_json)
for message_type, message in signal.items():
print message_type, message
device_message = message.get(self.name)
if (message_type == 'record') and (device_message is not None):
#Will only look at file specified by device message
self.get_data(device_message)
self.replot()
self.Plotter.show_window()
def get_data(self, abs_data_path):
with h5py.File(abs_data_path) as h5f:
self.data = np.array(h5f['gnd'])
#self.test = np.array(h5f['test_new_trig'])
#print(self.test)
self.ts = np.array(h5f['time'])
def replot(self):
#Apply function as specified in child class
print('called')
x, y = (self.data_fxn)(self.data, self.ts)#, self.ts)
#keep zoomed in view on repaint
xlim = self.canvas.ax.get_xlim()
ylim = self.canvas.ax.get_ylim()
self.canvas.ax.clear()
self.canvas.ax.plot(x, y, label='Time domain')
self.canvas.ax.set_xlim(xlim)
self.canvas.ax.set_ylim(ylim)
self.canvas.ax.legend()
self.canvas.draw()
print('redrawn')
def closeEvent(self, x):
self.reactor.stop()
class PMTViewer(QtGui.QDialog):
if sys.platform == "win32":
data_dir = 'J:\\data\\'
else:
data_dir = '/home/srgang/J/data/'
def __init__(self, pmt_name, reactor, cxn=None):
super(PMTViewer, self).__init__(None)
self.pmt_name = pmt_name
self.reactor = reactor
self.cxn = cxn
self.update_id = np.random.randint(0, 2**31 - 1)
# self.update_id = 6100034
self.loading = False
self.connect()
@inlineCallbacks
def connect(self):
if self.cxn is None:
self.cxn = connection()
cname = 'pmt - {} - client'.format(self.pmt_name)
yield self.cxn.connect(name=cname)
# self.context = yield self.cxn.context()
self.populate()
yield self.connect_signals()
#self.replot()
def populate(self):
self.setWindowTitle(self.pmt_name)
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
self.lcdGND = QtGui.QLCDNumber(self)
self.lcdGND.display('0.001')
self.lcdEXC = QtGui.QLCDNumber(self)
self.lcdEXC.display('0.001')
self.lcdBAC = QtGui.QLCDNumber(self)
self.lcdBAC.display('0.000')
self.lcdFRAC = QtGui.QLCDNumber(self)
self.lcdFRAC.display('0.000')
self.lcdTOTAL = QtGui.QLCDNumber(self)
self.lcdTOTAL.display('0.000')
self.labelGND = QtGui.QLabel('GROUND')
self.labelGND.setAlignment(QtCore.Qt.AlignCenter)
self.labelGND.setFont(QtGui.QFont("Arial", 48, QtGui.QFont.Bold))
self.labelEXC = QtGui.QLabel('EXCITED')
self.labelEXC.setAlignment(QtCore.Qt.AlignCenter)
self.labelEXC.setFont(QtGui.QFont("Arial", 48, QtGui.QFont.Bold))
self.labelBAC = QtGui.QLabel('BACKGROUND')
self.labelBAC.setAlignment(QtCore.Qt.AlignCenter)
self.labelBAC.setFont(QtGui.QFont("Arial", 48, QtGui.QFont.Bold))
self.labelFRAC = QtGui.QLabel('EXC. FRACTION')
self.labelFRAC.setAlignment(QtCore.Qt.AlignCenter)
self.labelFRAC.setFont(QtGui.QFont("Arial", 48, QtGui.QFont.Bold))
self.labelTOTAL = QtGui.QLabel('TOTAL')
self.labelTOTAL.setAlignment(QtCore.Qt.AlignCenter)
self.labelTOTAL.setFont(QtGui.QFont("Arial", 48, QtGui.QFont.Bold))
self.layout = QtGui.QGridLayout()
self.layout.setSpacing(1)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.hboxFRAC = QtGui.QHBoxLayout()
self.hboxFRAC.addWidget(self.labelFRAC)
self.hboxFRAC.addWidget(self.lcdFRAC)
self.hboxGND = QtGui.QHBoxLayout()
self.hboxGND.addWidget(self.labelGND)
self.hboxGND.addWidget(self.lcdGND)
self.hboxEXC = QtGui.QHBoxLayout()
self.hboxEXC.addWidget(self.labelEXC)
self.hboxEXC.addWidget(self.lcdEXC)
self.hboxBAC = QtGui.QHBoxLayout()
self.hboxBAC.addWidget(self.labelBAC)
self.hboxBAC.addWidget(self.lcdBAC)
self.hboxTOTAL = QtGui.QHBoxLayout()
self.hboxTOTAL.addWidget(self.labelTOTAL)
self.hboxTOTAL.addWidget(self.lcdTOTAL)
self.layout.addItem(self.hboxFRAC)
self.layout.addItem(self.hboxGND)
self.layout.addItem(self.hboxEXC)
self.layout.addItem(self.hboxBAC)
self.layout.addItem(self.hboxTOTAL)
self.setLayout(self.layout)
width = self.canvas.width() + 500
height = self.nav.height() + self.canvas.height(
) + 8 * self.lcdGND.height() + 200
self.setFixedSize(width, height)
self.setWindowTitle('PMT_trace_viewer')
# yield self.replot()
@inlineCallbacks
def connect_signals(self):
# pyqt signals
# labrad signals
pmt_server = yield self.cxn.get_server('pmt')
yield pmt_server.select_device(self.pmt_name)
yield pmt_server.signal__update(self.update_id)
yield pmt_server.addListener(listener=self.receive_update,
source=None,
ID=self.update_id)
@inlineCallbacks
def receive_update(self, c, signal):
if signal == self.pmt_name:
pmt_server = yield self.cxn.get_server('pmt')
data_json = yield pmt_server.retrive(-1)
data = json.loads(data_json)
record_name = data['record_name'].split('/')[5:]
raw_data_path = self.data_dir + os.path.join(
*record_name) + '.hdf5'
self.replot(raw_data_path)
self.update_numbers(raw_data_path)
def replot(self, data_path):
with h5py.File(data_path) as h5f:
gnd = h5f['gnd'][500:]
exc = h5f['exc'][500:]
bac = h5f['bac'][500:]
self.canvas.ax.clear()
self.canvas.ax.plot(gnd, label='GND')
self.canvas.ax.plot(exc, label='EXC')
self.canvas.ax.plot(bac, label='BAC')
self.canvas.ax.text(100, 100, 'FRAC')
self.canvas.ax.legend()
self.canvas.draw()
def update_numbers(self, data_path):
with h5py.File(data_path) as h5f:
gnd = np.mean(h5f['gnd'][3000:23000])
exc = np.mean(h5f['exc'][3000:23000])
bac = np.mean(h5f['bac'][3000:23000])
tot = (gnd + exc - 2 * bac)
if tot == 0:
frac = 0
else:
frac = (exc - bac) / tot
self.lcdGND.display(str(np.round(gnd, 3)))
self.lcdEXC.display(str(np.round(exc, 3)))
self.lcdBAC.display(str(np.round(bac, 3)))
self.lcdFRAC.display(str(np.round(frac, 3)))
self.lcdTOTAL.display(str(np.round(tot, 3)))
def closeEvent(self, x):
self.reactor.stop()
class PMTViewer(QtGui.QDialog):
if sys.platform == "win32":
data_dir = 'J:\\data\\'
else:
data_dir = '/home/srgang/J/data/'
def __init__(self, pmt_name, reactor, cxn=None):
super(PMTViewer, self).__init__(None)
self.pmt_name = pmt_name
self.reactor = reactor
self.cxn = cxn
self.update_id = np.random.randint(0, 2**31 - 1)
# self.update_id = 6100034
self.loading = False
self.connect()
@inlineCallbacks
def connect(self):
if self.cxn is None:
self.cxn = connection()
cname = 'pmt - {} - client'.format(self.pmt_name)
yield self.cxn.connect(name=cname)
# self.context = yield self.cxn.context()
self.populate()
yield self.connect_signals()
#self.replot()
def populate(self):
self.setWindowTitle(self.pmt_name)
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
self.layout = QtGui.QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
width = self.canvas.width()
height = self.nav.height() + self.canvas.height() + 20
self.setFixedSize(width, height)
self.setWindowTitle('pmt_viewer')
# yield self.replot()
@inlineCallbacks
def connect_signals(self):
# pyqt signals
# labrad signals
pmt_server = yield self.cxn.get_server('pmt')
yield pmt_server.select_device(self.pmt_name)
yield pmt_server.signal__update(self.update_id)
yield pmt_server.addListener(listener=self.receive_update,
source=None,
ID=self.update_id)
@inlineCallbacks
def receive_update(self, c, signal):
if signal == self.pmt_name:
pmt_server = yield self.cxn.get_server('pmt')
data_json = yield pmt_server.retrive(-1)
data = json.loads(data_json)
record_name = data['record_name'].split('/')[5:]
raw_data_path = self.data_dir + os.path.join(
*record_name) + '.hdf5'
self.replot(raw_data_path)
def replot(self, data_path):
with h5py.File(data_path) as h5f:
gnd = h5f['gnd'][500:]
exc = h5f['exc'][500:]
bac = h5f['bac'][500:]
self.canvas.ax.clear()
self.canvas.ax.plot(gnd, label='gnd')
self.canvas.ax.plot(exc, label='exc')
self.canvas.ax.plot(bac, label='bac')
self.canvas.ax.legend()
self.canvas.draw()
def closeEvent(self, x):
self.reactor.stop()
