def __init__(self, **params):
for p in self.INPUT_PARAM_NAMES:
setattr(self, p, params[p])
self.x_array = np.arange(self.x0, self.x1, self.dx, dtype=float)
self.y_array = np.arange(self.y0, self.y1, self.dy, dtype=float)
self.z_array = np.arange(self.z0, self.z1, self.dz, dtype=float)
self.Nx = len(self.x_array)
self.Ny = len(self.y_array)
self.Nz = len(self.z_array)
self.mcl_axis_translation = xyz_tuple(*self.mcl_axis_translation)
self.HARDWARE_DEBUG = False
#HARDWARE
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
self.freq_counter = NI_FreqCounter(debug=self.HARDWARE_DEBUG)
#DATA ARRAYS
self.count_freq_map = np.zeros((
self.Nz,
self.Ny,
self.Nx,
),
dtype=np.float64)
def connect(self):
if self.debug: print "connecting to mcl_xyz_stage"
# Open connection to hardware
self.nanodrive = MCLNanoDrive(debug=self.debug)
# connect logged quantities
self.x_target.hardware_set_func = \
lambda x: self.nanodrive.set_pos_ax_slow(x, self.MCL_AXIS_ID["X"])
self.y_target.hardware_set_func = \
lambda y: self.nanodrive.set_pos_ax_slow(y, self.MCL_AXIS_ID["Y"])
self.z_target.hardware_set_func = \
lambda z: self.nanodrive.set_pos_ax_slow(z, self.MCL_AXIS_ID["Z"])
self.x_position.hardware_read_func = \
lambda: self.nanodrive.get_pos_ax(self.MCL_AXIS_ID["X"])
self.y_position.hardware_read_func = \
lambda: self.nanodrive.get_pos_ax(self.MCL_AXIS_ID["Y"])
self.z_position.hardware_read_func = \
lambda: self.nanodrive.get_pos_ax(self.MCL_AXIS_ID["Z"])
self.x_max.hardware_read_func = lambda: self.nanodrive.cal[
self.MCL_AXIS_ID["X"]]
self.y_max.hardware_read_func = lambda: self.nanodrive.cal[
self.MCL_AXIS_ID["Y"]]
self.z_max.hardware_read_func = lambda: self.nanodrive.cal[
self.MCL_AXIS_ID["Z"]]
self.move_speed.hardware_read_func = self.nanodrive.get_max_speed
self.move_speed.hardware_set_func = self.nanodrive.set_max_speed
def OnInit(self):
self.HARDWARE_DEBUG = HARDWARE_DEBUG
self.frame = MCLStage3DFrame(None)
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
try:
self.frame.m_staticText_maxdim.SetLabel(
"[ %g x %g x %g ]" %
(self.nanodrive.cal_X, self.nanodrive.cal_Y,
self.nanodrive.cal_Z))
except Exception as e:
print e
self.frame.m_staticText_maxdim.SetLabel("[ ? ? ? ]")
y, x, z = self.nanodrive.get_pos()
self.frame.m_scrollBar_x.SetScrollbar(100 * x / self.nanodrive.cal_Y,
1,
100,
1,
refresh=True)
self.frame.m_scrollBar_y.SetScrollbar(100 * y / self.nanodrive.cal_X,
1,
100,
1,
refresh=True)
self.frame.m_scrollBar_z.SetScrollbar(100 * z / self.nanodrive.cal_Z,
1,
100,
1,
refresh=True)
self.frame.m_textCtrl_x.SetValue("%02.3f" % x)
self.frame.m_textCtrl_y.SetValue("%02.3f" % y)
self.frame.m_textCtrl_z.SetValue("%02.3f" % z)
self.frame.m_scrollBar_x.Bind(wx.EVT_SCROLL, self.on_scroll)
self.frame.m_scrollBar_y.Bind(wx.EVT_SCROLL, self.on_scroll)
self.frame.m_scrollBar_z.Bind(wx.EVT_SCROLL, self.on_scroll)
self.frame.m_textCtrl_x.Bind(wx.EVT_TEXT_ENTER, self.on_change_text)
self.frame.m_textCtrl_y.Bind(wx.EVT_TEXT_ENTER, self.on_change_text)
self.frame.m_textCtrl_z.Bind(wx.EVT_TEXT_ENTER, self.on_change_text)
# Figure
self.wxfig = MPLFigureWithToolbarWX(self.frame.m_panel_plot)
self.fig = self.wxfig.fig
self.ax = self.fig.add_subplot(111)
self.ax.set_xlim(0, self.nanodrive.cal_Y)
self.ax.set_ylim(self.nanodrive.cal_X, 0)
self.xypos_line, = self.ax.plot([x], [y], 'ro')
self.frame.Show()
return True
def __init__(self, **params):
for p in self.INPUT_PARAM_NAMES:
setattr(self, p, params[p])
self.x_array = np.arange(self.x0, self.x1, self.dx, dtype=float)
self.y_array = np.arange(self.y0, self.y1, self.dy, dtype=float)
self.z_array = np.arange(self.z0, self.z1, self.dz, dtype=float)
self.Nx = len(self.x_array)
self.Ny = len(self.y_array)
self.Nz = len(self.z_array)
self.mcl_axis_translation = xyz_tuple(*self.mcl_axis_translation)
self.HARDWARE_DEBUG = False
#HARDWARE
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
#try:
# self.frame.m_staticText_maxdim.SetLabel("max: %g x %g um" % (self.nanodrive.cal_Y, self.nanodrive.cal_X) )
self.picoharp = PicoHarp300(devnum=0, debug=self.HARDWARE_DEBUG)
#DATA ARRAYS
self.integrated_count_map = np.zeros((
self.Nz,
self.Ny,
self.Nx,
),
dtype=int)
print "size of time_trace_map %e" % (self.Nx * self.Ny * self.Nz *
self.stored_histogram_chan)
self.time_trace_map = np.zeros(
(self.Nz, self.Ny, self.Nx, self.stored_histogram_chan),
dtype=np.uint16)
class MicroscopeGUI(object):
def __del__(self):
self.ui = None
def show(self):
#self.ui.exec_()
self.ui.show()
def __init__(self):
self.HARDWARE_DEBUG = HARDWARE_DEBUG
self.scanning = False
self.MCL_AXIS_ID = MCL_AXIS_ID
self.HAXIS = HAXIS
self.VAXIS = VAXIS
self.HAXIS_ID = HAXIS_ID
self.VAXIS_ID = VAXIS_ID
self.logged_quantities = collections.OrderedDict()
self.hardware_components = collections.OrderedDict()
self.measurement_components = collections.OrderedDict()
self.figs = collections.OrderedDict()
# Load Qt UI from .ui file
ui_loader = QtUiTools.QUiLoader()
ui_file = QtCore.QFile("microscope_gui.ui")
ui_file.open(QtCore.QFile.ReadOnly)
self.ui = ui_loader.load(ui_file)
ui_file.close()
# Add hardware components
print "Adding Hardware Components"
self.picoharp_hc = self.add_hardware_component(
PicoHarpHardwareComponent(self))
self.apd_counter_hc = self.add_hardware_component(
APDCounterHardwareComponent(self))
self.andor_ccd_hc = self.add_hardware_component(
AndorCCDHardwareComponent(self))
self.acton_spec_hc = self.add_hardware_component(
ActonSpectrometerHardwareComponent(self))
self.flip_mirror_hc = self.add_hardware_component(
FlipMirrorHardwareComponent(self))
self.setup_hardware()
# Create the measurement objects
print "Create Measurement objects"
self.apd_optimizer_measure = self.add_measurement_component(
APDOptimizerMeasurement(self))
self.apd_scan_measure = self.add_measurement_component(
APDConfocalScanMeasurement(self))
self.ple_point_measure = self.add_measurement_component(
PLEPointMeasurement(self))
self.ple2d_measure = self.add_measurement_component(
PLE2DScanMeasurement(self))
self.picoharp_measure = self.add_measurement_component(
PicoHarpMeasurement(self))
self.trpl_scan_measure = self.add_measurement_component(
TRPLScanMeasurement(self))
self.andor_ro_measure = self.add_measurement_component(
AndorCCDReadout(self))
self.andor_bg_measure = self.add_measurement_component(
AndorCCDReadBackground(self))
self.spec_map_measure = self.add_measurement_component(
SpectrumScan2DMeasurement(self))
self.power_scan_measure = self.add_measurement_component(
PowerScanContinuous(self))
# Setup the figures
for name, measure in self.measurement_components.items():
print "setting up figures for", name, "measurement", measure.name
measure.setup_figure()
self.setup_figures()
print "figures:"
for fig in self.figs:
print "\t", fig
print "measurement_components:"
for m in self.measurement_components:
print "\t", m
# events
self.ui.slow_display_timer_checkBox.stateChanged.connect(
self.on_slow_display_timer_checkbox)
self.ui.power_meter_acquire_cont_checkBox.stateChanged.connect(
self.on_power_meter_acquire_cont_checkbox)
self.ui.oo_spec_acquire_cont_checkBox.stateChanged.connect(
self.on_oo_spec_acq_cont_checkbox)
### timers
self.slow_display_timer = QtCore.QTimer(self.ui)
self.slow_display_timer.timeout.connect(self.on_slow_display_timer)
self.ui.slow_display_timer_checkBox.setChecked(True)
self.power_meter_acq_cont_timer = QtCore.QTimer(self.ui)
self.power_meter_acq_cont_timer.timeout.connect(
self.on_power_meter_acq_cont_timer)
self.oo_spec_acq_cont_timer = QtCore.QTimer(self.ui)
self.oo_spec_acq_cont_timer.timeout.connect(
self.on_oo_spec_acq_cont_timer)
def start_display_timers(self):
print "start_display_timers"
@QtCore.Slot()
def stop_display_timers(self):
print "stop_display_timers"
self.ui.slow_display_timer_checkBox.setChecked(False)
self.ui.power_meter_acquire_cont_checkBox.setChecked(False)
self.ui.oo_spec_acquire_cont_checkBox.setChecked(False)
QtGui.QApplication.processEvents()
def add_figure(self, name, widget):
"""creates a matplotlib figure attaches it to the qwidget specified
(widget needs to have a layout set (preferably verticalLayout)
adds a figure to self.figs"""
print "---adding figure", name, widget
if name in self.figs:
return self.figs[name]
else:
fig = Figure()
fig.patch.set_facecolor('w')
canvas = FigureCanvas(fig)
nav = NavigationToolbar2(canvas, self.ui)
widget.layout().addWidget(canvas)
widget.layout().addWidget(nav)
canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
canvas.setFocus()
self.figs[name] = fig
return fig
def add_logged_quantity(self, name, **kwargs):
lq = LoggedQuantity(name=name, **kwargs)
self.logged_quantities[name] = lq
return lq
def add_hardware_component(self, hc):
self.hardware_components[hc.name] = hc
return hc
def add_measurement_component(self, measure):
assert not measure.name in self.measurement_components.keys()
self.measurement_components[measure.name] = measure
return measure
def setup_figures(self):
## OO Spec Figure ###
F = self.fig_oo_spec = self.add_figure('oo_spec',
self.ui.oo_spec_plot_widget)
ax = self.oo_spec_ax = F.add_subplot(111)
self.oo_spec_plotline, = ax.plot(self.oo_spectrometer.wavelengths,
self.oo_spectrometer.spectrum)
ax.set_xlabel("wavelengths (nm)")
ax.set_ylabel("Laser Spectrum (counts)")
def setup_hardware(self):
######## MCL NanoDrive Stage ###########################################
print "Initializing MCL stage functionality"
self.nanodrive = MCLNanoDrive(debug=True)
self.hmax = self.nanodrive.cal[HAXIS_ID]
self.vmax = self.nanodrive.cal[VAXIS_ID]
self.ui.maxdim_label.setText("%s - %s scan. Max: %g x %g um" %
(HAXIS, VAXIS, self.hmax, self.vmax))
# Logged Quantities
self.x_position = self.add_logged_quantity(name='x_position',
dtype=np.float)
self.y_position = self.add_logged_quantity(name='y_position',
dtype=np.float)
self.z_position = self.add_logged_quantity(name='z_position',
dtype=np.float)
self.x_position.hardware_set_func = lambda x: self.nanodrive.set_pos_ax_slow(
x, MCL_AXIS_ID["X"])
self.y_position.hardware_set_func = lambda y: self.nanodrive.set_pos_ax_slow(
y, MCL_AXIS_ID["Y"])
self.z_position.hardware_set_func = lambda z: self.nanodrive.set_pos_ax_slow(
z, MCL_AXIS_ID["Z"])
self.x_position.updated_value.connect(
self.ui.cx_doubleSpinBox.setValue)
self.ui.x_set_lineEdit.returnPressed.connect(
self.x_position.update_value)
self.y_position.updated_value.connect(
self.ui.cy_doubleSpinBox.setValue)
self.ui.y_set_lineEdit.returnPressed.connect(
self.y_position.update_value)
self.z_position.updated_value.connect(
self.ui.cz_doubleSpinBox.setValue)
self.ui.z_set_lineEdit.returnPressed.connect(
self.z_position.update_value)
self.nanodrive_move_speed = self.add_logged_quantity(
name='nanodrive_move_speed',
dtype=np.float,
hardware_read_func=self.nanodrive.get_max_speed,
hardware_set_func=self.nanodrive.set_max_speed)
self.nanodrive_move_speed.updated_value[float].connect(
self.ui.nanodrive_move_slow_doubleSpinBox.setValue)
self.ui.nanodrive_move_slow_doubleSpinBox.valueChanged[float].connect(
self.nanodrive_move_speed.update_value)
self.nanodrive_move_speed.read_from_hardware()
# read and initialize hardware control values
self.read_stage_position()
### Power Meter ##########################
print "Initializing power meter functionality"
self.power_meter = ThorlabsPM100D(debug=self.HARDWARE_DEBUG)
self.power_meter_wavelength = self.add_logged_quantity(
'power_meter_wavelength',
dtype=int,
hardware_read_func=self.power_meter.get_wavelength,
hardware_set_func=self.power_meter.set_wavelength)
self.power_meter_wavelength.updated_value[float].connect(
self.ui.power_meter_wl_doubleSpinBox.setValue)
self.ui.power_meter_wl_doubleSpinBox.valueChanged[float].connect(
self.power_meter_wavelength.update_value)
print "Reading initial wavelength"
self.power_meter_wavelength.read_from_hardware()
self.laser_power = self.add_logged_quantity(
name='laser_in_power',
fmt='%2.2e W',
dtype=np.float,
hardware_read_func=self.power_meter.measure_power)
self.laser_power.updated_text_value.connect(
self.ui.power_meter_power_label.setText)
self.laser_power.read_from_hardware()
### AOTF #####################################
print "Initializing AOTF functionality"
# self.dds = CrystalTechDDS(comm="serial", port="COM1", debug=self.HARDWARE_DEBUG)
# Modulation property
# self.aotf_modulation = self.add_logged_quantity(name="aotf_modulation", dtype=bool, hardware_set_func=self.dds.set_modulation)
# self.aotf_modulation.updated_value[bool].connect(self.ui.aotf_mod_enable_checkBox.setChecked)
# self.ui.aotf_mod_enable_checkBox.stateChanged.connect(self.aotf_modulation.update_value)
# self.aotf_modulation.update_value(True)
# Frequency property
# TODO: only works on channel 0!
# self.aotf_freq = self.add_logged_quantity(name="aotf_freq",
# dtype=np.float,
# hardware_read_func=self.dds.get_frequency,
# hardware_set_func=self.dds.set_frequency,
# fmt = '%f')
# self.aotf_freq.updated_value[float].connect(self.ui.atof_freq_doubleSpinBox.setValue)
# self.ui.atof_freq_doubleSpinBox.valueChanged[float].connect(self.aotf_freq.update_value)
# self.ui.aotf_freq_set_lineEdit.returnPressed.connect(self.aotf_freq.update_value)
# self.aotf_freq.read_from_hardware()
# Power property
# TODO: only works on channel 0!
# self.aotf_power = self.add_logged_quantity(name="aotf_power",
# dtype=np.int,
# hardware_read_func=self.dds.get_amplitude,
# hardware_set_func=self.dds.set_amplitude)
# self.aotf_power.updated_value[float].connect(self.ui.aotf_power_doubleSpinBox.setValue)
# self.ui.aotf_power_doubleSpinBox.valueChanged.connect(self.aotf_power.update_value)
# self.aotf_power.read_from_hardware()
### OO Spec ####################################
print "Initializing OceanOptics spectrometer functionality"
self.oo_spectrometer = OceanOpticsSpectrometer(
debug=self.HARDWARE_DEBUG)
self.oo_spec_int_time = self.add_logged_quantity(
name="oo_spec_int_time",
dtype=float,
hardware_set_func=self.oo_spectrometer.set_integration_time_sec)
self.ui.oo_spec_int_time_doubleSpinBox.valueChanged[float].connect(
self.oo_spec_int_time.update_value)
self.oo_spec_int_time.updated_value[float].connect(
self.ui.oo_spec_int_time_doubleSpinBox.setValue)
self.oo_spec_int_time.update_value(0.1)
self.oo_spectrometer.start_threaded_acquisition()
# Hardware Read functions
def read_stage_position(self):
self.stage_pos = self.nanodrive.get_pos()
self.x_position.update_value(self.stage_pos[MCL_AXIS_ID["X"] - 1],
update_hardware=False)
self.y_position.update_value(self.stage_pos[MCL_AXIS_ID["Y"] - 1],
update_hardware=False)
self.z_position.update_value(self.stage_pos[MCL_AXIS_ID["Z"] - 1],
update_hardware=False)
return self.stage_pos
# GUI Functions
@QtCore.Slot()
def on_clearfig(self):
self.fig2d.clf()
self.ax2d = self.fig2d.add_subplot(111)
self.ax2d.plot([0, 1])
# update figure
self.ax2d.set_xlim(0, self.hmax)
self.ax2d.set_ylim(0, self.vmax)
self.fig2d.canvas.draw()
@QtCore.Slot()
def on_slow_display_timer_checkbox(self, enable):
if enable:
self.slow_display_timer.start(TIMER_MS)
else:
self.slow_display_timer.stop()
# Timer callbacks
@QtCore.Slot()
def on_slow_display_timer(self):
self.read_stage_position()
#self.read_ni_countrate(int_time = 0.01)
#Update the temperature reading for the CCD
if self.andor_ccd_hc.is_connected:
ccd = self.andor_ccd_hc
if (ccd.status.read_from_hardware() == 'IDLE'):
ccd.temperature.read_from_hardware()
@QtCore.Slot()
def on_oo_spec_acq_cont_checkbox(self, enable):
if enable:
# limit update period to 50ms (in ms) or as slow as 1sec
#timer_period = np.min(1.0,np.max(0.05*self.oo_spec_int_time.val,0.05)) * 1000.
self.oo_spec_acq_cont_timer.start(0.050)
else:
self.oo_spec_acq_cont_timer.stop()
@QtCore.Slot()
def on_oo_spec_acq_cont_timer(self):
# Check to see if a spectrum is available from the Ocean Optics spec
if self.oo_spectrometer.is_threaded_acquisition_complete():
self.oospec_update_figure()
self.oo_spectrometer.start_threaded_acquisition()
def oospec_update_figure(self):
F = self.fig_oo_spec
ax = self.oo_spec_ax
self.oo_spectrometer.spectrum[:10] = np.nan
self.oo_spectrometer.spectrum[-10:] = np.nan
self.oo_spec_plotline.set_ydata(self.oo_spectrometer.spectrum)
ax.relim()
ax.autoscale_view(scalex=False, scaley=True)
F.canvas.draw()
@QtCore.Slot(bool)
def on_power_meter_acquire_cont_checkbox(self, enable):
if enable:
self.power_meter_acq_cont_timer.start(100)
else:
self.power_meter_acq_cont_timer.stop()
@QtCore.Slot()
def on_power_meter_acq_cont_timer(self):
#read power
self.laser_power.read_from_hardware()
def setup_hardware(self):
######## MCL NanoDrive Stage ###########################################
print "Initializing MCL stage functionality"
self.nanodrive = MCLNanoDrive(debug=True)
self.hmax = self.nanodrive.cal[HAXIS_ID]
self.vmax = self.nanodrive.cal[VAXIS_ID]
self.ui.maxdim_label.setText("%s - %s scan. Max: %g x %g um" %
(HAXIS, VAXIS, self.hmax, self.vmax))
# Logged Quantities
self.x_position = self.add_logged_quantity(name='x_position',
dtype=np.float)
self.y_position = self.add_logged_quantity(name='y_position',
dtype=np.float)
self.z_position = self.add_logged_quantity(name='z_position',
dtype=np.float)
self.x_position.hardware_set_func = lambda x: self.nanodrive.set_pos_ax_slow(
x, MCL_AXIS_ID["X"])
self.y_position.hardware_set_func = lambda y: self.nanodrive.set_pos_ax_slow(
y, MCL_AXIS_ID["Y"])
self.z_position.hardware_set_func = lambda z: self.nanodrive.set_pos_ax_slow(
z, MCL_AXIS_ID["Z"])
self.x_position.updated_value.connect(
self.ui.cx_doubleSpinBox.setValue)
self.ui.x_set_lineEdit.returnPressed.connect(
self.x_position.update_value)
self.y_position.updated_value.connect(
self.ui.cy_doubleSpinBox.setValue)
self.ui.y_set_lineEdit.returnPressed.connect(
self.y_position.update_value)
self.z_position.updated_value.connect(
self.ui.cz_doubleSpinBox.setValue)
self.ui.z_set_lineEdit.returnPressed.connect(
self.z_position.update_value)
self.nanodrive_move_speed = self.add_logged_quantity(
name='nanodrive_move_speed',
dtype=np.float,
hardware_read_func=self.nanodrive.get_max_speed,
hardware_set_func=self.nanodrive.set_max_speed)
self.nanodrive_move_speed.updated_value[float].connect(
self.ui.nanodrive_move_slow_doubleSpinBox.setValue)
self.ui.nanodrive_move_slow_doubleSpinBox.valueChanged[float].connect(
self.nanodrive_move_speed.update_value)
self.nanodrive_move_speed.read_from_hardware()
# read and initialize hardware control values
self.read_stage_position()
### Power Meter ##########################
print "Initializing power meter functionality"
self.power_meter = ThorlabsPM100D(debug=self.HARDWARE_DEBUG)
self.power_meter_wavelength = self.add_logged_quantity(
'power_meter_wavelength',
dtype=int,
hardware_read_func=self.power_meter.get_wavelength,
hardware_set_func=self.power_meter.set_wavelength)
self.power_meter_wavelength.updated_value[float].connect(
self.ui.power_meter_wl_doubleSpinBox.setValue)
self.ui.power_meter_wl_doubleSpinBox.valueChanged[float].connect(
self.power_meter_wavelength.update_value)
print "Reading initial wavelength"
self.power_meter_wavelength.read_from_hardware()
self.laser_power = self.add_logged_quantity(
name='laser_in_power',
fmt='%2.2e W',
dtype=np.float,
hardware_read_func=self.power_meter.measure_power)
self.laser_power.updated_text_value.connect(
self.ui.power_meter_power_label.setText)
self.laser_power.read_from_hardware()
### AOTF #####################################
print "Initializing AOTF functionality"
# self.dds = CrystalTechDDS(comm="serial", port="COM1", debug=self.HARDWARE_DEBUG)
# Modulation property
# self.aotf_modulation = self.add_logged_quantity(name="aotf_modulation", dtype=bool, hardware_set_func=self.dds.set_modulation)
# self.aotf_modulation.updated_value[bool].connect(self.ui.aotf_mod_enable_checkBox.setChecked)
# self.ui.aotf_mod_enable_checkBox.stateChanged.connect(self.aotf_modulation.update_value)
# self.aotf_modulation.update_value(True)
# Frequency property
# TODO: only works on channel 0!
# self.aotf_freq = self.add_logged_quantity(name="aotf_freq",
# dtype=np.float,
# hardware_read_func=self.dds.get_frequency,
# hardware_set_func=self.dds.set_frequency,
# fmt = '%f')
# self.aotf_freq.updated_value[float].connect(self.ui.atof_freq_doubleSpinBox.setValue)
# self.ui.atof_freq_doubleSpinBox.valueChanged[float].connect(self.aotf_freq.update_value)
# self.ui.aotf_freq_set_lineEdit.returnPressed.connect(self.aotf_freq.update_value)
# self.aotf_freq.read_from_hardware()
# Power property
# TODO: only works on channel 0!
# self.aotf_power = self.add_logged_quantity(name="aotf_power",
# dtype=np.int,
# hardware_read_func=self.dds.get_amplitude,
# hardware_set_func=self.dds.set_amplitude)
# self.aotf_power.updated_value[float].connect(self.ui.aotf_power_doubleSpinBox.setValue)
# self.ui.aotf_power_doubleSpinBox.valueChanged.connect(self.aotf_power.update_value)
# self.aotf_power.read_from_hardware()
### OO Spec ####################################
print "Initializing OceanOptics spectrometer functionality"
self.oo_spectrometer = OceanOpticsSpectrometer(
debug=self.HARDWARE_DEBUG)
self.oo_spec_int_time = self.add_logged_quantity(
name="oo_spec_int_time",
dtype=float,
hardware_set_func=self.oo_spectrometer.set_integration_time_sec)
self.ui.oo_spec_int_time_doubleSpinBox.valueChanged[float].connect(
self.oo_spec_int_time.update_value)
self.oo_spec_int_time.updated_value[float].connect(
self.ui.oo_spec_int_time_doubleSpinBox.setValue)
self.oo_spec_int_time.update_value(0.1)
self.oo_spectrometer.start_threaded_acquisition()
def __init__(self):
ui_loader = QtUiTools.QUiLoader()
print os.path.join(__file__, "scanning_confocal_mcl_ni.ui")
ui_file = QtCore.QFile("scanning_confocal_mcl_ni.ui")
ui_file.open(QtCore.QFile.ReadOnly)
self.ui = ui_loader.load(ui_file)
ui_file.close()
self.HARDWARE_DEBUG = HARDWARE_DEBUG
self.fig2d = Figure()
self.ax2d = self.fig2d.add_subplot(111)
self.ax2d.plot([0, 1])
self.canvas2d = FigureCanvas(self.fig2d)
self.ui.plot2D_verticalLayout.addWidget(self.canvas2d)
self.navtoolbar_plot2d = NavigationToolbar2(self.canvas2d, self.ui)
self.ui.plot2D_verticalLayout.addWidget(self.navtoolbar_plot2d)
self.fig_opt = Figure()
self.ax_opt = self.fig_opt.add_subplot(111)
self.canvas_opt = FigureCanvas(self.fig_opt)
self.ui.plot_optimize_verticalLayout.addWidget(self.canvas_opt)
self.navtoolbar_plot_opt = NavigationToolbar2(self.canvas_opt, self.ui)
self.ui.plot_optimize_verticalLayout.addWidget(
self.navtoolbar_plot_opt)
self.optimize_history = np.zeros(OPTIMIZE_HISTORY_LEN, dtype=np.float)
self.optimize_ii = 0
self.optimize_line, = self.ax_opt.plot(self.optimize_history)
self.optimize_current_pos = self.ax_opt.axvline(self.optimize_ii,
color='r')
##################### hardware #########################################
self.scanning = False
######## MCL NanoDrive Stage ###########################################
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
try:
self.hmax = self.nanodrive.cal[HAXIS_ID]
self.vmax = self.nanodrive.cal[VAXIS_ID]
self.ui.maxdim_label.setText("%s - %s scan. Max: %g x %g um" %
(HAXIS, VAXIS, self.hmax, self.vmax))
except Exception as e:
print e
self.ui.maxdim_label.setText("max: ? x ? um")
# Logged Quantities
self.x_position = LoggedQuantity(name='x_position', dtype=np.float)
self.y_position = LoggedQuantity(name='y_position', dtype=np.float)
self.z_position = LoggedQuantity(name='z_position', dtype=np.float)
#self.x_position.updated_value.connect(self.ui.cx_lcdNumber.display)
self.x_position.updated_value.connect(
self.ui.cx_doubleSpinBox.setValue)
self.ui.x_set_lineEdit.returnPressed.connect(
self.x_position.update_value)
#self.y_position.updated_value.connect(self.ui.cy_lcdNumber.display)
self.y_position.updated_value.connect(
self.ui.cy_doubleSpinBox.setValue)
self.ui.y_set_lineEdit.returnPressed.connect(
self.y_position.update_value)
#self.z_position.updated_value.connect(self.ui.cz_lcdNumber.display)
self.z_position.updated_value.connect(
self.ui.cz_doubleSpinBox.setValue)
self.ui.z_set_lineEdit.returnPressed.connect(
self.z_position.update_value)
self.x_position.hardware_set_func = lambda x: self.nanodrive.set_pos_ax(
x, MCL_AXIS_ID["X"])
self.y_position.hardware_set_func = lambda y: self.nanodrive.set_pos_ax(
y, MCL_AXIS_ID["Y"])
self.z_position.hardware_set_func = lambda z: self.nanodrive.set_pos_ax(
z, MCL_AXIS_ID["Z"])
####### NI (apd) counter readout ##################################
self.ni_counter = NI_FreqCounter(debug=self.HARDWARE_DEBUG)
self.apd_count_rate = LoggedQuantity(name='apd_count_rate',
dtype=np.float,
fmt="%e")
self.apd_count_rate.updated_text_value.connect(
self.ui.apd_counter_output_lineEdit.setText)
########################################################################
self.read_stage_position()
self.read_ni_countrate()
self.update_display()
# update figure
self.ax2d.set_xlim(0, self.hmax)
self.ax2d.set_ylim(0, self.vmax)
# events
self.ui.scan_start_pushButton.clicked.connect(self.on_scan_start)
self.ui.scan_stop_pushButton.clicked.connect(self.on_scan_stop)
self.ui.fast_update_checkBox.stateChanged.connect(
self.on_fast_timer_checkbox)
self.ui.clearfig_pushButton.clicked.connect(self.on_clearfig)
### timers
self.slow_display_timer = QtCore.QTimer(self.ui)
self.slow_display_timer.timeout.connect(self.on_slow_display_timer)
self.slow_display_timer.start(TIMER_MS)
self.fast_timer = QtCore.QTimer(self.ui)
self.fast_timer.timeout.connect(self.on_fast_timer)
self.display_update_when_scanning_timer = QtCore.QTimer(self.ui)
self.display_update_when_scanning_timer.timeout.connect(
self.on_display_update_when_scanning_timer)
class ScanningConfocalUI:
def __del__(self):
self.ui = None
def show(self):
#self.ui.exec_()
self.ui.show()
def __init__(self):
ui_loader = QtUiTools.QUiLoader()
print os.path.join(__file__, "scanning_confocal_mcl_ni.ui")
ui_file = QtCore.QFile("scanning_confocal_mcl_ni.ui")
ui_file.open(QtCore.QFile.ReadOnly)
self.ui = ui_loader.load(ui_file)
ui_file.close()
self.HARDWARE_DEBUG = HARDWARE_DEBUG
self.fig2d = Figure()
self.ax2d = self.fig2d.add_subplot(111)
self.ax2d.plot([0, 1])
self.canvas2d = FigureCanvas(self.fig2d)
self.ui.plot2D_verticalLayout.addWidget(self.canvas2d)
self.navtoolbar_plot2d = NavigationToolbar2(self.canvas2d, self.ui)
self.ui.plot2D_verticalLayout.addWidget(self.navtoolbar_plot2d)
self.fig_opt = Figure()
self.ax_opt = self.fig_opt.add_subplot(111)
self.canvas_opt = FigureCanvas(self.fig_opt)
self.ui.plot_optimize_verticalLayout.addWidget(self.canvas_opt)
self.navtoolbar_plot_opt = NavigationToolbar2(self.canvas_opt, self.ui)
self.ui.plot_optimize_verticalLayout.addWidget(
self.navtoolbar_plot_opt)
self.optimize_history = np.zeros(OPTIMIZE_HISTORY_LEN, dtype=np.float)
self.optimize_ii = 0
self.optimize_line, = self.ax_opt.plot(self.optimize_history)
self.optimize_current_pos = self.ax_opt.axvline(self.optimize_ii,
color='r')
##################### hardware #########################################
self.scanning = False
######## MCL NanoDrive Stage ###########################################
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
try:
self.hmax = self.nanodrive.cal[HAXIS_ID]
self.vmax = self.nanodrive.cal[VAXIS_ID]
self.ui.maxdim_label.setText("%s - %s scan. Max: %g x %g um" %
(HAXIS, VAXIS, self.hmax, self.vmax))
except Exception as e:
print e
self.ui.maxdim_label.setText("max: ? x ? um")
# Logged Quantities
self.x_position = LoggedQuantity(name='x_position', dtype=np.float)
self.y_position = LoggedQuantity(name='y_position', dtype=np.float)
self.z_position = LoggedQuantity(name='z_position', dtype=np.float)
#self.x_position.updated_value.connect(self.ui.cx_lcdNumber.display)
self.x_position.updated_value.connect(
self.ui.cx_doubleSpinBox.setValue)
self.ui.x_set_lineEdit.returnPressed.connect(
self.x_position.update_value)
#self.y_position.updated_value.connect(self.ui.cy_lcdNumber.display)
self.y_position.updated_value.connect(
self.ui.cy_doubleSpinBox.setValue)
self.ui.y_set_lineEdit.returnPressed.connect(
self.y_position.update_value)
#self.z_position.updated_value.connect(self.ui.cz_lcdNumber.display)
self.z_position.updated_value.connect(
self.ui.cz_doubleSpinBox.setValue)
self.ui.z_set_lineEdit.returnPressed.connect(
self.z_position.update_value)
self.x_position.hardware_set_func = lambda x: self.nanodrive.set_pos_ax(
x, MCL_AXIS_ID["X"])
self.y_position.hardware_set_func = lambda y: self.nanodrive.set_pos_ax(
y, MCL_AXIS_ID["Y"])
self.z_position.hardware_set_func = lambda z: self.nanodrive.set_pos_ax(
z, MCL_AXIS_ID["Z"])
####### NI (apd) counter readout ##################################
self.ni_counter = NI_FreqCounter(debug=self.HARDWARE_DEBUG)
self.apd_count_rate = LoggedQuantity(name='apd_count_rate',
dtype=np.float,
fmt="%e")
self.apd_count_rate.updated_text_value.connect(
self.ui.apd_counter_output_lineEdit.setText)
########################################################################
self.read_stage_position()
self.read_ni_countrate()
self.update_display()
# update figure
self.ax2d.set_xlim(0, self.hmax)
self.ax2d.set_ylim(0, self.vmax)
# events
self.ui.scan_start_pushButton.clicked.connect(self.on_scan_start)
self.ui.scan_stop_pushButton.clicked.connect(self.on_scan_stop)
self.ui.fast_update_checkBox.stateChanged.connect(
self.on_fast_timer_checkbox)
self.ui.clearfig_pushButton.clicked.connect(self.on_clearfig)
### timers
self.slow_display_timer = QtCore.QTimer(self.ui)
self.slow_display_timer.timeout.connect(self.on_slow_display_timer)
self.slow_display_timer.start(TIMER_MS)
self.fast_timer = QtCore.QTimer(self.ui)
self.fast_timer.timeout.connect(self.on_fast_timer)
self.display_update_when_scanning_timer = QtCore.QTimer(self.ui)
self.display_update_when_scanning_timer.timeout.connect(
self.on_display_update_when_scanning_timer)
@QtCore.Slot()
def on_clearfig(self):
self.fig2d.clf()
self.ax2d = self.fig2d.add_subplot(111)
self.ax2d.plot([0, 1])
# update figure
self.ax2d.set_xlim(0, self.hmax)
self.ax2d.set_ylim(0, self.vmax)
self.fig2d.canvas.draw()
def read_stage_position(self):
self.stage_pos = self.nanodrive.get_pos()
return self.stage_pos
def read_ni_countrate(self, int_time=0.01):
try:
self.ni_counter.start()
time.sleep(int_time)
self.c0_rate = self.ni_counter.read_average_freq_in_buffer()
except Exception as E:
print E
#self.ni_counter.reset()
finally:
self.ni_counter.stop()
def update_display(self):
self.x_position.update_value(self.stage_pos[MCL_AXIS_ID["X"] - 1],
update_hardware=False)
self.y_position.update_value(self.stage_pos[MCL_AXIS_ID["Y"] - 1],
update_hardware=False)
self.z_position.update_value(self.stage_pos[MCL_AXIS_ID["Z"] - 1],
update_hardware=False)
self.apd_count_rate.update_value(self.c0_rate)
@QtCore.Slot()
def on_slow_display_timer(self):
self.read_stage_position()
self.read_ni_countrate(int_time=0.01)
self.update_display()
@QtCore.Slot()
def on_fast_timer(self):
try:
self.c0_rate = self.ni_counter.read_average_freq_in_buffer()
except Exception as E:
self.c0_rate = -1
self.apd_count_rate.update_value(self.c0_rate)
#print self.c0_rate
self.optimize_ii += 1
self.optimize_ii %= OPTIMIZE_HISTORY_LEN
ii = self.optimize_ii
self.optimize_history[ii] = self.c0_rate
self.optimize_line.set_ydata(self.optimize_history)
self.optimize_current_pos.set_xdata((ii, ii))
if (ii % 10) == 0:
self.ax_opt.relim()
self.ax_opt.autoscale_view(scalex=False, scaley=True)
#print "redraw"
self.fig_opt.canvas.draw()
@QtCore.Slot(bool)
def on_fast_timer_checkbox(self, fast_timer_enable):
if fast_timer_enable:
self.fast_timer.start(100)
print "fast timer start"
else:
self.fast_timer.stop()
print "fast timer stop"
@QtCore.Slot()
def on_scan_start(self):
print "start scan"
self.scanning = True
QtGui.QApplication.processEvents()
#get scan parameters:
self.h0 = self.ui.h0_doubleSpinBox.value()
self.h1 = self.ui.h1_doubleSpinBox.value()
self.v0 = self.ui.v0_doubleSpinBox.value()
self.v1 = self.ui.v1_doubleSpinBox.value()
self.dh = 1e-3 * self.ui.dh_spinBox.value()
self.dv = 1e-3 * self.ui.dv_spinBox.value()
self.h_array = np.arange(self.h0, self.h1, self.dh, dtype=float)
self.v_array = np.arange(self.v0, self.v1, self.dv, dtype=float)
self.Nh = len(self.h_array)
self.Nv = len(self.v_array)
self.pixel_time = self.ui.pixel_time_doubleSpinBox.value()
self.extent = [self.h0, self.h1, self.v0, self.v1]
### create data arrays
self.count_rate_map = np.zeros((self.Nv, self.Nh), dtype=np.float)
print "shape:", self.count_rate_map.shape
print "Nh, Nv", self.Nh, self.Nv
### update figure
self.ax_2d_img = self.ax2d.imshow(self.count_rate_map,
origin='lower',
vmin=1e4,
vmax=1e5,
interpolation='nearest',
extent=self.extent)
self.fig2d.canvas.draw()
self.slow_display_timer.stop() #stop the slow delay timer
#display_timer_update = 0.5*self.pixel_time*1e3
#if display_timer_update < 200
self.display_update_when_scanning_timer.start(100)
self.ni_counter.stop()
self.ni_counter.start()
# Scan!
line_time0 = time.time()
for i_v in range(self.Nv):
if not self.scanning:
break
self.v_pos = self.v_array[i_v]
self.nanodrive.set_pos_ax(self.v_pos, VAXIS_ID)
self.read_stage_position()
print "line time:", time.time() - line_time0
print "pixel time:", float(time.time() - line_time0) / self.Nh
line_time0 = time.time()
if i_v % 2: #odd lines
h_line_indicies = range(self.Nh)
else: #even lines -- traverse in oposite direction
h_line_indicies = range(self.Nh)[::-1]
for i_h in h_line_indicies:
if not self.scanning:
break
self.h_pos = self.h_array[i_h]
self.nanodrive.set_pos_ax(self.h_pos, HAXIS_ID)
time0 = time.time()
while time.time() - time0 < self.pixel_time:
QtGui.QApplication.processEvents() #release
self.c0_rate = self.ni_counter.read_average_freq_in_buffer()
if np.isnan(self.c0_rate):
self.c0_rate = 0
#self.count_rate_map[i_v,i_h] = counts[-1] # grab integration time for now
self.count_rate_map[i_v,
i_h] = self.c0_rate # grab count0 rate
"""self.ccd.start_acquisition()
stat = "ACQUIRING"
while stat!= "IDLE":
wx_yielded_sleep(self.ccd.exposure_time * 0.25)
stati, stat = self.ccd.get_status()
self.ccd.get_acquired_data()
spectrum = np.sum(self.ccd.buffer[ROW0:ROW1], axis=0)
self.spectrum_map[jj,ii,:] = spectrum
self.integrated_count_map[jj,ii] = sum(spectrum)
"""
self.on_scan_stop()
@QtCore.Slot()
def on_scan_stop(self):
print "on_scan_stop"
self.scanning = False
self.ni_counter.stop()
self.update_display()
self.slow_display_timer.start() #restart the normal timer
self.display_update_when_scanning_timer.stop()
# clean up after scan
self.ax_2d_img.set_data(self.count_rate_map)
self.fig2d.canvas.draw()
self.update_display()
self.scanning = False
print "scanning done"
print "saving data..."
t0 = time.time()
np.savetxt("%i_confocal_scan.csv" % t0,
self.count_rate_map,
delimiter=',')
save_params = [
"h0", "h1", "v0", "v1", "Nh", "Nv", "h_array", "v_array", "dh",
"dv", "count_rate_map", "pixel_time"
]
save_dict = dict()
for key in save_params:
save_dict[key] = getattr(self, key)
for key in [
"HAXIS",
"VAXIS",
"HARDWARE_DEBUG",
]:
save_dict[key] = globals()[key]
# for key in ["wl", "gratings", "grating"]:
# save_dict["spec_"+key] = getattr(self.spec, key)
# for key in ["exposure_time", "em_gain", "temperature", "ad_chan", "ro_mode", "Nx", "Ny"]:
# save_dict["andor_"+key] = getattr(self.ccd, key)
save_dict["time_saved"] = t0
np.savez_compressed("%i_confocal_scan.npz" % t0, **save_dict)
print "data saved"
@QtCore.Slot()
def on_display_update_when_scanning_timer(self):
# update display
try:
self.update_display()
except Exception, err:
print "Failed to update_display", err
try:
#self.spec_plotline.set_ydata(spectrum)
#self.ax_speclive.relim()
#self.ax_speclive.autoscale_view(tight=None, scalex=False, scaley=True)
#self.fig2.canvas.draw()
pass
except Exception as err:
print "Failed to update spectrum plot", err
try:
#print "updating figure"
#self.read_from_hardware()
self.ax_2d_img.set_data(self.count_rate_map)
try:
count_min = np.min(self.count_rate_map[np.nonzero(
self.count_rate_map)])
except Exception as err:
count_min = 0
count_max = np.max(self.count_rate_map)
self.ax_2d_img.set_clim(count_min, count_max + 1)
self.fig2d.canvas.draw()
except Exception, err:
print "Failed to update figure:", err
class MCLStage3DApp(wx.App):
def OnInit(self):
self.HARDWARE_DEBUG = HARDWARE_DEBUG
self.frame = MCLStage3DFrame(None)
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
try:
self.frame.m_staticText_maxdim.SetLabel(
"[ %g x %g x %g ]" %
(self.nanodrive.cal_X, self.nanodrive.cal_Y,
self.nanodrive.cal_Z))
except Exception as e:
print e
self.frame.m_staticText_maxdim.SetLabel("[ ? ? ? ]")
y, x, z = self.nanodrive.get_pos()
self.frame.m_scrollBar_x.SetScrollbar(100 * x / self.nanodrive.cal_Y,
1,
100,
1,
refresh=True)
self.frame.m_scrollBar_y.SetScrollbar(100 * y / self.nanodrive.cal_X,
1,
100,
1,
refresh=True)
self.frame.m_scrollBar_z.SetScrollbar(100 * z / self.nanodrive.cal_Z,
1,
100,
1,
refresh=True)
self.frame.m_textCtrl_x.SetValue("%02.3f" % x)
self.frame.m_textCtrl_y.SetValue("%02.3f" % y)
self.frame.m_textCtrl_z.SetValue("%02.3f" % z)
self.frame.m_scrollBar_x.Bind(wx.EVT_SCROLL, self.on_scroll)
self.frame.m_scrollBar_y.Bind(wx.EVT_SCROLL, self.on_scroll)
self.frame.m_scrollBar_z.Bind(wx.EVT_SCROLL, self.on_scroll)
self.frame.m_textCtrl_x.Bind(wx.EVT_TEXT_ENTER, self.on_change_text)
self.frame.m_textCtrl_y.Bind(wx.EVT_TEXT_ENTER, self.on_change_text)
self.frame.m_textCtrl_z.Bind(wx.EVT_TEXT_ENTER, self.on_change_text)
# Figure
self.wxfig = MPLFigureWithToolbarWX(self.frame.m_panel_plot)
self.fig = self.wxfig.fig
self.ax = self.fig.add_subplot(111)
self.ax.set_xlim(0, self.nanodrive.cal_Y)
self.ax.set_ylim(self.nanodrive.cal_X, 0)
self.xypos_line, = self.ax.plot([x], [y], 'ro')
self.frame.Show()
return True
def on_scroll(self, evt):
self.frame.m_scrollBar_x.Refresh()
self.frame.m_scrollBar_y.Refresh()
self.frame.m_scrollBar_z.Refresh()
new_x = self.frame.m_scrollBar_x.GetThumbPosition(
) * 0.01 * self.nanodrive.cal_Y
new_y = self.frame.m_scrollBar_y.GetThumbPosition(
) * 0.01 * self.nanodrive.cal_X
new_z = self.frame.m_scrollBar_z.GetThumbPosition(
) * 0.01 * self.nanodrive.cal_Z
self.nanodrive.set_pos(new_y, new_x, new_z)
y, x, z = self.nanodrive.get_pos()
#self.frame.m_scrollBar_x.SetScrollbar(100*x/self.nanodrive.cal_X, 1, 100, 1, refresh=True)
#self.frame.m_scrollBar_y.SetScrollbar(100*y/self.nanodrive.cal_Y, 1, 100, 1, refresh=True)
#self.frame.m_scrollBar_z.SetScrollbar(100*z/self.nanodrive.cal_Z, 1, 100, 1, refresh=True)
self.frame.m_textCtrl_x.SetValue("%02.3f" % x)
self.frame.m_textCtrl_y.SetValue("%02.3f" % y)
self.frame.m_textCtrl_z.SetValue("%02.3f" % z)
self.xypos_line.set_xdata([x])
self.xypos_line.set_ydata([y])
self.wxfig.redraw()
#self.frame.m_scrollBar_x.Refresh()
#self.frame.m_scrollBar_y.Refresh()
#self.frame.m_scrollBar_z.Refresh()
def on_change_text(self, evt):
new_x = float(self.frame.m_textCtrl_x.GetValue())
new_y = float(self.frame.m_textCtrl_y.GetValue())
new_z = float(self.frame.m_textCtrl_z.GetValue())
self.nanodrive.set_pos(new_y, new_x, new_z)
y, x, z = self.nanodrive.get_pos()
self.frame.m_textCtrl_x.SetValue("%02.3f" % x)
self.frame.m_textCtrl_y.SetValue("%02.3f" % y)
self.frame.m_textCtrl_z.SetValue("%02.3f" % z)
self.frame.m_scrollBar_x.SetScrollbar(100 * x / self.nanodrive.cal_Y,
1,
100,
1,
refresh=True)
self.frame.m_scrollBar_y.SetScrollbar(100 * y / self.nanodrive.cal_X,
1,
100,
1,
refresh=True)
self.frame.m_scrollBar_z.SetScrollbar(100 * z / self.nanodrive.cal_Z,
1,
100,
1,
refresh=True)
self.wxfig.redraw()
def OnInit(self):
print "OnInit"
self.HARDWARE_DEBUG = HARDWARE_DEBUG
self.STORED_HISTCHAN = 4000 #65535
self.frame = ScanningTRPLControlFrame(None)
# Logged Quantities
self.x_position = LoggedQuantity(
name='x_position',
dtype=np.float,
display_textctrl=self.frame.m_textCtrl_current_x,
input_textctrl=self.frame.m_textCtrl_set_current_x)
self.y_position = LoggedQuantity(
name='y_position',
dtype=np.float,
display_textctrl=self.frame.m_textCtrl_current_y,
input_textctrl=self.frame.m_textCtrl_set_current_y)
# Figure
self.wxfig = MPLFigureWithToolbarWX(self.frame.m_panel_plot)
self.fig = self.wxfig.fig
self.ax = self.fig.add_subplot(111)
# Optimization Fig
self.fig2 = pl.figure(2)
self.ax2 = self.fig2.add_subplot(111)
self.c0_hist_line, = self.ax2.plot(np.zeros(HIST_LEN, dtype=float))
self.c1_hist_line, = self.ax2.plot(np.zeros(HIST_LEN, dtype=float))
self.hist_vline = self.ax2.axvline(0)
self.c0_hist = np.zeros(HIST_LEN, dtype=float)
self.c1_hist = np.zeros(HIST_LEN, dtype=float)
self.fig2.show()
self.hist_i = 0
# hardware
self.scanning = False
# FOR DEPTH SCAN: MCL axis Y = plot X, MCL axis Z = plot Y
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
try:
self.frame.m_staticText_maxdim.SetLabel(
"max: x %g x z %g um" %
(self.nanodrive.cal_Y, self.nanodrive.cal_Z))
except Exception as e:
print e
self.frame.m_staticText_maxdim.SetLabel("max: ? x ? um")
#self.frame.m_staticText_maxdim.SetLabel("max: 75 x 75 um")
#self.srslockin = SRSlockin(port="COM5", gpibaddr=8)
#self.lockinstage = LockinStage(srs=self.srslockin,
# POSMIN=0, POSMAX=75, channels={'x':1, 'y':2, 'z':3})
self.picoharp = PicoHarp300(devnum=0, debug=self.HARDWARE_DEBUG)
self.read_from_hardware()
#self.x_position.hardware_set_func = lambda x: self.lockinstage.setx(x)
#self.y_position.hardware_set_func = lambda y: self.lockinstage.sety(y)
self.x_position.hardware_set_func = lambda x: self.nanodrive.set_pos_ax(
x, YAXIS)
self.y_position.hardware_set_func = lambda y: self.nanodrive.set_pos_ax(
y, ZAXIS)
# update figure
self.ax.set_xlim(0, self.nanodrive.cal_Y)
self.ax.set_ylim(0, self.nanodrive.cal_Z)
#self.ax.set_xlim(0, 75)
#self.ax.set_ylim(0, 75)
# events
self.frame.Bind(wx.EVT_BUTTON, self.on_start_scan,
self.frame.m_button_start)
self.frame.Bind(wx.EVT_BUTTON, self.on_stop_scan,
self.frame.m_button_stop)
self.timer = wx.Timer(id=2001)
self.timer.Bind(wx.EVT_TIMER, self.on_timer)
self.timer.Start(2000)
self.fast_timer = wx.Timer(id=2002)
self.fast_timer.Bind(wx.EVT_TIMER, self.on_fast_timer)
self.frame.m_checkBox_picoharp_fastreadout.Bind(
wx.EVT_CHECKBOX, self.on_fast_timer_checkbox)
self.update_display()
self.frame.Show()
return True
class ScanningTRPLHistMapApp(wx.App):
def OnInit(self):
print "OnInit"
self.HARDWARE_DEBUG = HARDWARE_DEBUG
self.STORED_HISTCHAN = 4000 #65535
self.frame = ScanningTRPLControlFrame(None)
# Logged Quantities
self.x_position = LoggedQuantity(
name='x_position',
dtype=np.float,
display_textctrl=self.frame.m_textCtrl_current_x,
input_textctrl=self.frame.m_textCtrl_set_current_x)
self.y_position = LoggedQuantity(
name='y_position',
dtype=np.float,
display_textctrl=self.frame.m_textCtrl_current_y,
input_textctrl=self.frame.m_textCtrl_set_current_y)
# Figure
self.wxfig = MPLFigureWithToolbarWX(self.frame.m_panel_plot)
self.fig = self.wxfig.fig
self.ax = self.fig.add_subplot(111)
# Optimization Fig
self.fig2 = pl.figure(2)
self.ax2 = self.fig2.add_subplot(111)
self.c0_hist_line, = self.ax2.plot(np.zeros(HIST_LEN, dtype=float))
self.c1_hist_line, = self.ax2.plot(np.zeros(HIST_LEN, dtype=float))
self.hist_vline = self.ax2.axvline(0)
self.c0_hist = np.zeros(HIST_LEN, dtype=float)
self.c1_hist = np.zeros(HIST_LEN, dtype=float)
self.fig2.show()
self.hist_i = 0
# hardware
self.scanning = False
# FOR DEPTH SCAN: MCL axis Y = plot X, MCL axis Z = plot Y
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
try:
self.frame.m_staticText_maxdim.SetLabel(
"max: x %g x z %g um" %
(self.nanodrive.cal_Y, self.nanodrive.cal_Z))
except Exception as e:
print e
self.frame.m_staticText_maxdim.SetLabel("max: ? x ? um")
#self.frame.m_staticText_maxdim.SetLabel("max: 75 x 75 um")
#self.srslockin = SRSlockin(port="COM5", gpibaddr=8)
#self.lockinstage = LockinStage(srs=self.srslockin,
# POSMIN=0, POSMAX=75, channels={'x':1, 'y':2, 'z':3})
self.picoharp = PicoHarp300(devnum=0, debug=self.HARDWARE_DEBUG)
self.read_from_hardware()
#self.x_position.hardware_set_func = lambda x: self.lockinstage.setx(x)
#self.y_position.hardware_set_func = lambda y: self.lockinstage.sety(y)
self.x_position.hardware_set_func = lambda x: self.nanodrive.set_pos_ax(
x, YAXIS)
self.y_position.hardware_set_func = lambda y: self.nanodrive.set_pos_ax(
y, ZAXIS)
# update figure
self.ax.set_xlim(0, self.nanodrive.cal_Y)
self.ax.set_ylim(0, self.nanodrive.cal_Z)
#self.ax.set_xlim(0, 75)
#self.ax.set_ylim(0, 75)
# events
self.frame.Bind(wx.EVT_BUTTON, self.on_start_scan,
self.frame.m_button_start)
self.frame.Bind(wx.EVT_BUTTON, self.on_stop_scan,
self.frame.m_button_stop)
self.timer = wx.Timer(id=2001)
self.timer.Bind(wx.EVT_TIMER, self.on_timer)
self.timer.Start(2000)
self.fast_timer = wx.Timer(id=2002)
self.fast_timer.Bind(wx.EVT_TIMER, self.on_fast_timer)
self.frame.m_checkBox_picoharp_fastreadout.Bind(
wx.EVT_CHECKBOX, self.on_fast_timer_checkbox)
self.update_display()
self.frame.Show()
return True
def on_timer(self, e):
self.read_from_hardware()
self.update_display()
def on_fast_timer(self, e):
self.picoharp.read_count_rates()
self.frame.m_textCtrl_count0.SetValue(str(self.picoharp.Countrate0))
self.frame.m_textCtrl_count1.SetValue(str(self.picoharp.Countrate1))
self.c0_hist[self.hist_i] = self.picoharp.Countrate0
self.c1_hist[self.hist_i] = self.picoharp.Countrate1
#self.c0_hist_line.set_ydata(self.c0_hist)
self.c1_hist_line.set_ydata(self.c1_hist)
self.hist_vline.set_xdata([self.hist_i] * 2)
self.hist_i += 1
self.hist_i %= HIST_LEN
if (self.hist_i % 10) == 0:
self.ax2.relim()
self.ax2.autoscale_view(scalex=False, scaley=True)
#self.ax2.autoscale()
self.fig2.canvas.draw()
def on_fast_timer_checkbox(self, e):
fast_timer_enable = self.frame.m_checkBox_picoharp_fastreadout.GetValue(
)
if fast_timer_enable:
self.fast_timer.Start(100)
else:
self.fast_timer.Stop()
def on_start_scan(self, e):
print "start scan"
self.scanning = True
# get scan parameters:
self.x0 = float(self.frame.m_textCtrl_x0.GetValue())
self.x1 = float(self.frame.m_textCtrl_x1.GetValue())
self.y0 = float(self.frame.m_textCtrl_y0.GetValue())
self.y1 = float(self.frame.m_textCtrl_y1.GetValue())
self.dx = float(self.frame.m_textCtrl_dx.GetValue()) / 1000.
self.dy = float(self.frame.m_textCtrl_dy.GetValue()) / 1000.
self.x_array = np.arange(self.x0, self.x1, self.dx, dtype=float)
self.y_array = np.arange(self.y0, self.y1, self.dy, dtype=float)
self.Nx = len(self.x_array)
self.Ny = len(self.y_array)
print "Nx, Ny", self.Nx, self.Ny
self.tacq = int(float(self.frame.m_textCtrl_tacq.GetValue()) * 1000)
self.phrange = int(self.frame.m_textCtrl_phrange.GetValue())
self.phoffset = int(self.frame.m_textCtrl_phoffset.GetValue())
self.syncdiv = int(
self.frame.m_choice_syncdivider.GetString(
self.frame.m_choice_syncdivider.GetSelection()))
self.zerocross0 = int(self.frame.m_spinCtrl_zerocross0.GetValue())
self.zerocross1 = int(self.frame.m_spinCtrl_zerocross0.GetValue())
self.level0 = int(self.frame.m_textCtrl_level0.GetValue())
self.level1 = int(self.frame.m_textCtrl_level1.GetValue())
# create data arrays
#self.integrated_count_map_c0 = np.zeros((self.Nx, self.Ny), dtype=int)
self.integrated_count_map_c1 = np.zeros((self.Ny, self.Nx), dtype=int)
self.time_trace_map = np.zeros(
(self.Ny, self.Nx, self.STORED_HISTCHAN), dtype=int)
print "shape:", self.integrated_count_map_c1.shape, self.time_trace_map.shape
#update figure
self.aximg = self.ax.imshow(
self.integrated_count_map_c1,
origin='lower',
vmin=1e4,
vmax=1e5,
interpolation='nearest',
extent=[self.x0, self.x1, self.y0, self.y1])
self.wxfig.redraw()
# set up experiment
self.picoharp.setup_experiment(Range=self.phrange,
Offset=self.phoffset,
Tacq=self.tacq,
SyncDivider=self.syncdiv,
CFDZeroCross0=self.zerocross0,
CFDLevel0=self.level0,
CFDZeroCross1=self.zerocross1,
CFDLevel1=self.level1)
self.resolution = self.picoharp.Resolution
line_time0 = time.time()
for jj in range(self.Ny):
#self.nanodrive.SetY(self.y_array[j])
if not self.scanning:
break
y = self.y_array[jj]
#self.lockinstage.sety(y)
#self.read_from_hardware()
self.nanodrive.set_pos_ax(y, ZAXIS)
self.read_from_hardware()
y = self.ypos
print "line time:", time.time() - line_time0
print "pixel time:", float(time.time() - line_time0) / len(
self.x_array)
line_time0 = time.time()
if jj % 2: #odd lines
x_line_indicies = range(self.Nx)
else: #even lines -- traverse in opposite direction
x_line_indicies = range(self.Nx)[::-1]
for ii in x_line_indicies:
#for ii in range(self.Nx):
if not self.scanning:
break
x = self.xpos = self.x_array[ii]
wx.Yield()
#self.nanodrive.SetX(self.x_array[i])
#self.nanodrive.set_pos(x, y)
#print "nanodrive set_pos: ", x, y
#self.lockinstage.setx(x)
self.nanodrive.set_pos_ax(x, YAXIS)
#if self.HARDWARE_DEBUG: print "lockin stage moved to ", x, y
ph = self.picoharp
ph.start_histogram(Tacq=self.tacq)
while not ph.check_done_scanning():
wx.Yield()
ph.stop_histogram()
hist_data = ph.read_histogram_data()
self.time_trace_map[jj,
ii, :] = hist_data[0:self.STORED_HISTCHAN]
self.integrated_count_map_c1[jj, ii] = sum(hist_data)
#x1, y1 = self.nanodrive.get_pos()
#print "get pos: ", x1,y1
# update display
try:
self.update_display()
except Exception, err:
print "Failed to update_display", err
if not (ii % 5):
#self.update_figure()
try:
#print "updating figure"
#self.read_from_hardware()
self.aximg.set_data(self.integrated_count_map_c1)
try:
count_min = np.min(
self.integrated_count_map_c1[np.nonzero(
self.integrated_count_map_c1)])
except Exception as err:
count_min = 0
count_max = np.max(self.integrated_count_map_c1)
self.aximg.set_clim(count_min, count_max + 1)
self.wxfig.redraw()
except Exception, err:
print "Failed to update figure:", err
def OnInit(self):
print "OnInit"
self.HARDWARE_DEBUG = HARDWARE_DEBUG
self.frame = ScanningSpectrumControlFrame(None)
# Logged Quantities
self.x_position = LoggedQuantity(
name='x_position',
dtype=np.float,
display_textctrl=self.frame.m_textCtrl_current_x,
input_textctrl=self.frame.m_textCtrl_set_current_x)
self.y_position = LoggedQuantity(
name='y_position',
dtype=np.float,
display_textctrl=self.frame.m_textCtrl_current_y,
input_textctrl=self.frame.m_textCtrl_set_current_y)
# Figure ###############################################################
self.wxfig = MPLFigureWithToolbarWX(self.frame.m_panel_plot)
self.fig = self.wxfig.fig
self.ax = self.fig.add_subplot(111)
# Spectrum Fig
self.fig2 = pl.figure(2)
self.ax_speclive = self.fig2.add_subplot(111)
#self.c0_hist_line, = self.ax2.plot(np.zeros(HIST_LEN,dtype=float))
#self.c1_hist_line, = self.ax2.plot(np.zeros(HIST_LEN,dtype=float))
#self.hist_vline = self.ax2.axvline(0)
#self.c0_hist = np.zeros(HIST_LEN,dtype=float)
#self.c1_hist = np.zeros(HIST_LEN,dtype=float)
self.fig2.show()
#self.history_i = 0
self.spec_plotline, = self.ax_speclive.plot(range(0, 512),
range(0, 512))
##################### hardware #########################################
self.scanning = False
######## MCL NanoDrive Stage ###########################################
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
try:
self.frame.m_staticText_maxdim.SetLabel(
"max: %g x %g um" %
(self.nanodrive.cal[XAXIS_ID], self.nanodrive.cal[YAXIS_ID]))
except Exception as e:
print e
self.frame.m_staticText_maxdim.SetLabel("max: ? x ? um")
self.read_from_hardware()
self.x_position.hardware_set_func = lambda x: self.nanodrive.set_pos_ax(
x, XAXIS_ID)
self.y_position.hardware_set_func = lambda y: self.nanodrive.set_pos_ax(
y, YAXIS_ID)
#Spectrometer ##########################################################
self.spec = ActonSpectrometer(port=SPEC_COMM_PORT,
debug=self.HARDWARE_DEBUG,
dummy=False)
print self.spec.read_grating_info()
self.frame.m_choice_spec_grating.Clear()
for gnum, gname in self.spec.gratings:
self.frame.m_choice_spec_grating.Append("%i %s" % (gnum, gname))
print self.spec.gratings_dict
self.spec.read_grating()
self.frame.m_choice_spec_grating.SetSelection(self.spec.grating - 1)
self.spec.read_wl()
self.frame.m_textCtrl_current_spec_wl.SetValue("%f" % self.spec.wl)
self.frame.m_textCtrl_set_spec_wl.Bind(wx.EVT_TEXT_ENTER,
self.on_change_spec_wl)
self.frame.m_choice_spec_grating.Bind(wx.EVT_CHOICE,
self.on_change_spec_grating)
#self.frame.m_button_spec_stop.Bind(wx.EVT_BUTTON, self.on_spec_stop_motion)
########################################################################
#Andor CCD##############################################################
self.ccd = AndorCCD(debug=self.HARDWARE_DEBUG)
print "Andor CCD"
print "%g x %g" % (self.ccd.Nx, self.ccd.Ny)
self.spectrum_length = self.ccd.Nx
self.ccd.set_ro_image_mode()
self.ccd.set_trigger_mode('internal')
self.ccd.set_image_flip(ANDOR_HFLIP, ANDOR_VFLIP)
print "flip", self.ccd.get_image_flip()
self.ccd.set_ad_channel(ANDOR_AD_CHAN)
self.ccd.set_exposure_time(1.0)
self.ccd.set_EMCCD_gain(1)
self.ccd.set_cooler_on()
self.ccd.get_temperature()
self.ccd.set_shutter_open()
self.spec_fig = pl.figure(3)
self.specimg_ax = self.spec_fig.add_subplot(111)
self.spec_ax = self.spec_fig.add_subplot(611)
self.spec_ax.set_xlim(0, 512)
self.spec_fig.show()
self.ccd_img = self.specimg_ax.imshow(np.zeros(
(self.ccd.Nx, self.ccd.Ny), dtype=np.int32),
origin='lower',
interpolation='nearest')
self.specimg_ax.axhline(ROW0, color='w')
self.specimg_ax.axhline(ROW1, color='w')
self.specimg_ax.axvline(256, color='w')
self.spec_line, = self.spec_ax.plot(
np.zeros(self.ccd.Nx, dtype=np.int32), 'k-')
self.spec_line2, = self.spec_ax.plot(
np.zeros(self.ccd.Nx, dtype=np.int32), 'g-')
self.video_mode = False
self.frame.m_button_video_mode_start.Bind(wx.EVT_BUTTON,
self.on_start_video_mode)
self.frame.m_button_video_mode_stop.Bind(wx.EVT_BUTTON,
self.on_stop_video_mode)
self.frame.m_textCtrl_andor_exposure.SetValue(
str(ANDOR_DEFAULT_EXPOSURE))
self.frame.m_textCtrl_andor_em.SetValue(str(ANDOR_DEFAULT_EMGAIN))
# A/D rate
choice_adc = self.frame.m_choice_andor_adc
choice_adc.Clear()
for speed in self.ccd.HSSpeeds[ANDOR_AD_CHAN]:
choice_adc.Append("%g MHz" % (speed))
choice_adc.SetSelection(0)
self.ccd.set_hs_speed(0)
choice_adc.Bind(wx.EVT_CHOICE, self.on_change_andor_adc)
########################################################################
# update figure
self.ax.set_xlim(0, self.nanodrive.cal[XAXIS_ID])
self.ax.set_ylim(0, self.nanodrive.cal[YAXIS_ID])
# events
self.frame.Bind(wx.EVT_BUTTON, self.on_start_scan,
self.frame.m_button_start)
self.frame.Bind(wx.EVT_BUTTON, self.on_stop_scan,
self.frame.m_button_stop)
self.timer = wx.Timer(id=2001)
self.timer.Bind(wx.EVT_TIMER, self.on_timer)
self.timer.Start(2000)
#self.fast_timer = wx.Timer(id=2002)
#self.fast_timer.Bind(wx.EVT_TIMER, self.on_fast_timer)
#self.frame.m_checkBox_picoharp_fastreadout.Bind(
# wx.EVT_CHECKBOX, self.on_fast_timer_checkbox)
self.update_display()
self.frame.Show()
return True
class ScanningTRPLHistMapApp(wx.App):
def OnInit(self):
print "OnInit"
self.HARDWARE_DEBUG = HARDWARE_DEBUG
self.frame = ScanningSpectrumControlFrame(None)
# Logged Quantities
self.x_position = LoggedQuantity(
name='x_position',
dtype=np.float,
display_textctrl=self.frame.m_textCtrl_current_x,
input_textctrl=self.frame.m_textCtrl_set_current_x)
self.y_position = LoggedQuantity(
name='y_position',
dtype=np.float,
display_textctrl=self.frame.m_textCtrl_current_y,
input_textctrl=self.frame.m_textCtrl_set_current_y)
# Figure ###############################################################
self.wxfig = MPLFigureWithToolbarWX(self.frame.m_panel_plot)
self.fig = self.wxfig.fig
self.ax = self.fig.add_subplot(111)
# Spectrum Fig
self.fig2 = pl.figure(2)
self.ax_speclive = self.fig2.add_subplot(111)
#self.c0_hist_line, = self.ax2.plot(np.zeros(HIST_LEN,dtype=float))
#self.c1_hist_line, = self.ax2.plot(np.zeros(HIST_LEN,dtype=float))
#self.hist_vline = self.ax2.axvline(0)
#self.c0_hist = np.zeros(HIST_LEN,dtype=float)
#self.c1_hist = np.zeros(HIST_LEN,dtype=float)
self.fig2.show()
#self.history_i = 0
self.spec_plotline, = self.ax_speclive.plot(range(0, 512),
range(0, 512))
##################### hardware #########################################
self.scanning = False
######## MCL NanoDrive Stage ###########################################
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
try:
self.frame.m_staticText_maxdim.SetLabel(
"max: %g x %g um" %
(self.nanodrive.cal[XAXIS_ID], self.nanodrive.cal[YAXIS_ID]))
except Exception as e:
print e
self.frame.m_staticText_maxdim.SetLabel("max: ? x ? um")
self.read_from_hardware()
self.x_position.hardware_set_func = lambda x: self.nanodrive.set_pos_ax(
x, XAXIS_ID)
self.y_position.hardware_set_func = lambda y: self.nanodrive.set_pos_ax(
y, YAXIS_ID)
#Spectrometer ##########################################################
self.spec = ActonSpectrometer(port=SPEC_COMM_PORT,
debug=self.HARDWARE_DEBUG,
dummy=False)
print self.spec.read_grating_info()
self.frame.m_choice_spec_grating.Clear()
for gnum, gname in self.spec.gratings:
self.frame.m_choice_spec_grating.Append("%i %s" % (gnum, gname))
print self.spec.gratings_dict
self.spec.read_grating()
self.frame.m_choice_spec_grating.SetSelection(self.spec.grating - 1)
self.spec.read_wl()
self.frame.m_textCtrl_current_spec_wl.SetValue("%f" % self.spec.wl)
self.frame.m_textCtrl_set_spec_wl.Bind(wx.EVT_TEXT_ENTER,
self.on_change_spec_wl)
self.frame.m_choice_spec_grating.Bind(wx.EVT_CHOICE,
self.on_change_spec_grating)
#self.frame.m_button_spec_stop.Bind(wx.EVT_BUTTON, self.on_spec_stop_motion)
########################################################################
#Andor CCD##############################################################
self.ccd = AndorCCD(debug=self.HARDWARE_DEBUG)
print "Andor CCD"
print "%g x %g" % (self.ccd.Nx, self.ccd.Ny)
self.spectrum_length = self.ccd.Nx
self.ccd.set_ro_image_mode()
self.ccd.set_trigger_mode('internal')
self.ccd.set_image_flip(ANDOR_HFLIP, ANDOR_VFLIP)
print "flip", self.ccd.get_image_flip()
self.ccd.set_ad_channel(ANDOR_AD_CHAN)
self.ccd.set_exposure_time(1.0)
self.ccd.set_EMCCD_gain(1)
self.ccd.set_cooler_on()
self.ccd.get_temperature()
self.ccd.set_shutter_open()
self.spec_fig = pl.figure(3)
self.specimg_ax = self.spec_fig.add_subplot(111)
self.spec_ax = self.spec_fig.add_subplot(611)
self.spec_ax.set_xlim(0, 512)
self.spec_fig.show()
self.ccd_img = self.specimg_ax.imshow(np.zeros(
(self.ccd.Nx, self.ccd.Ny), dtype=np.int32),
origin='lower',
interpolation='nearest')
self.specimg_ax.axhline(ROW0, color='w')
self.specimg_ax.axhline(ROW1, color='w')
self.specimg_ax.axvline(256, color='w')
self.spec_line, = self.spec_ax.plot(
np.zeros(self.ccd.Nx, dtype=np.int32), 'k-')
self.spec_line2, = self.spec_ax.plot(
np.zeros(self.ccd.Nx, dtype=np.int32), 'g-')
self.video_mode = False
self.frame.m_button_video_mode_start.Bind(wx.EVT_BUTTON,
self.on_start_video_mode)
self.frame.m_button_video_mode_stop.Bind(wx.EVT_BUTTON,
self.on_stop_video_mode)
self.frame.m_textCtrl_andor_exposure.SetValue(
str(ANDOR_DEFAULT_EXPOSURE))
self.frame.m_textCtrl_andor_em.SetValue(str(ANDOR_DEFAULT_EMGAIN))
# A/D rate
choice_adc = self.frame.m_choice_andor_adc
choice_adc.Clear()
for speed in self.ccd.HSSpeeds[ANDOR_AD_CHAN]:
choice_adc.Append("%g MHz" % (speed))
choice_adc.SetSelection(0)
self.ccd.set_hs_speed(0)
choice_adc.Bind(wx.EVT_CHOICE, self.on_change_andor_adc)
########################################################################
# update figure
self.ax.set_xlim(0, self.nanodrive.cal[XAXIS_ID])
self.ax.set_ylim(0, self.nanodrive.cal[YAXIS_ID])
# events
self.frame.Bind(wx.EVT_BUTTON, self.on_start_scan,
self.frame.m_button_start)
self.frame.Bind(wx.EVT_BUTTON, self.on_stop_scan,
self.frame.m_button_stop)
self.timer = wx.Timer(id=2001)
self.timer.Bind(wx.EVT_TIMER, self.on_timer)
self.timer.Start(2000)
#self.fast_timer = wx.Timer(id=2002)
#self.fast_timer.Bind(wx.EVT_TIMER, self.on_fast_timer)
#self.frame.m_checkBox_picoharp_fastreadout.Bind(
# wx.EVT_CHECKBOX, self.on_fast_timer_checkbox)
self.update_display()
self.frame.Show()
return True
def on_timer(self, e):
self.read_from_hardware()
self.update_display()
# def on_fast_timer(self,e):
# self.picoharp.read_count_rates()
# self.frame.m_textCtrl_count0.SetValue(str(self.picoharp.Countrate0))
# self.frame.m_textCtrl_count1.SetValue(str(self.picoharp.Countrate1))
# self.c0_hist[self.hist_i] = self.picoharp.Countrate0
# self.c1_hist[self.hist_i] = self.picoharp.Countrate1
#
# #self.c0_hist_line.set_ydata(self.c0_hist)
# self.c1_hist_line.set_ydata(self.c1_hist)
# self.hist_vline.set_xdata([self.hist_i]*2)
#
# self.history_i += 1
# self.history_i %= HISTORY_LEN
#
# if (self.hist_i % 10) == 0:
# self.ax2.relim()
# self.ax2.autoscale_view(scalex=False, scaley=True)
# #self.ax2.autoscale()
#
# self.fig2.canvas.draw()
def on_fast_timer_checkbox(self, e):
fast_timer_enable = self.frame.m_checkBox_picoharp_fastreadout.GetValue(
)
if fast_timer_enable:
self.fast_timer.Start(100)
else:
self.fast_timer.Stop()
def on_start_scan(self, e):
print "start scan"
self.scanning = True
# get scan parameters:
self.x0 = float(self.frame.m_textCtrl_x0.GetValue())
self.x1 = float(self.frame.m_textCtrl_x1.GetValue())
self.y0 = float(self.frame.m_textCtrl_y0.GetValue())
self.y1 = float(self.frame.m_textCtrl_y1.GetValue())
self.dx = float(self.frame.m_textCtrl_dx.GetValue()) / 1000.
self.dy = float(self.frame.m_textCtrl_dy.GetValue()) / 1000.
self.x_array = np.arange(self.x0, self.x1, self.dx, dtype=float)
self.y_array = np.arange(self.y0, self.y1, self.dy, dtype=float)
self.Nx = len(self.x_array)
self.Ny = len(self.y_array)
print "Nx, Ny", self.Nx, self.Ny
self.andor_exposure = float(
self.frame.m_textCtrl_andor_exposure.GetValue())
self.andor_em_gain = int(self.frame.m_textCtrl_andor_em.GetValue())
### create data arrays
self.integrated_count_map = np.zeros((self.Ny, self.Nx), dtype=int)
self.spectrum_map = np.zeros((self.Ny, self.Nx, self.spectrum_length),
dtype=int)
print "shape:", self.integrated_count_map.shape, self.spectrum_map.shape
### update figure
self.aximg = self.ax.imshow(
self.integrated_count_map,
origin='lower',
vmin=1e4,
vmax=1e5,
interpolation='nearest',
extent=[self.x0, self.x1, self.y0, self.y1])
self.wxfig.redraw()
# set up experiment
self.ccd.set_exposure_time(self.andor_exposure)
self.ccd.set_EMCCD_gain(self.andor_em_gain)
# Scan!
line_time0 = time.time()
for jj in range(self.Ny):
if not self.scanning:
break
y = self.y_array[jj]
self.nanodrive.set_pos_ax(y, YAXIS_ID)
self.read_from_hardware()
y = self.ypos
print "line time:", time.time() - line_time0
print "pixel time:", float(time.time() - line_time0) / len(
self.x_array)
line_time0 = time.time()
if jj % 2: #odd lines
x_line_indicies = range(self.Nx)
else: #even lines -- traverse in opposite direction
x_line_indicies = range(self.Nx)[::-1]
for ii in x_line_indicies:
if not self.scanning:
break
x = self.xpos = self.x_array[ii]
wx.Yield()
self.nanodrive.set_pos_ax(x, XAXIS_ID)
self.ccd.start_acquisition()
stat = "ACQUIRING"
while stat != "IDLE":
wx_yielded_sleep(self.ccd.exposure_time * 0.25)
stati, stat = self.ccd.get_status()
self.ccd.get_acquired_data()
spectrum = np.sum(self.ccd.buffer[ROW0:ROW1], axis=0)
self.spectrum_map[jj, ii, :] = spectrum
self.integrated_count_map[jj, ii] = sum(spectrum)
# update display
try:
self.update_display()
except Exception, err:
print "Failed to update_display", err
try:
self.spec_plotline.set_ydata(spectrum)
self.ax_speclive.relim()
self.ax_speclive.autoscale_view(tight=None,
scalex=False,
scaley=True)
self.fig2.canvas.draw()
except Exception as err:
print "Failed to update spectrum plot", err
if not (ii % 5):
#self.update_figure()
try:
#print "updating figure"
#self.read_from_hardware()
self.aximg.set_data(self.integrated_count_map)
try:
count_min = np.min(
self.integrated_count_map[np.nonzero(
self.integrated_count_map)])
except Exception as err:
count_min = 0
count_max = np.max(self.integrated_count_map)
self.aximg.set_clim(count_min, count_max + 1)
self.wxfig.redraw()
except Exception, err:
print "Failed to update figure:", err
class Confocal3DScanNI(object):
INPUT_PARAM_NAMES = """x0 x1 dx y0 y1 dy z0 z1 dz
t_exposure
axis_scan_order mcl_axis_translation""".split()
def __init__(self, **params):
for p in self.INPUT_PARAM_NAMES:
setattr(self, p, params[p])
self.x_array = np.arange(self.x0, self.x1, self.dx, dtype=float)
self.y_array = np.arange(self.y0, self.y1, self.dy, dtype=float)
self.z_array = np.arange(self.z0, self.z1, self.dz, dtype=float)
self.Nx = len(self.x_array)
self.Ny = len(self.y_array)
self.Nz = len(self.z_array)
self.mcl_axis_translation = xyz_tuple(*self.mcl_axis_translation)
self.HARDWARE_DEBUG = False
#HARDWARE
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
self.freq_counter = NI_FreqCounter(debug=self.HARDWARE_DEBUG)
#DATA ARRAYS
self.count_freq_map = np.zeros((
self.Nz,
self.Ny,
self.Nx,
),
dtype=np.float64)
def run_3d_scan(self):
self.set_ijk = (-1, -1, -1)
self.scanning = True
time0 = time.time()
self.freq_counter.read_freq_buffer() #flush buffer
for iii, ijk in enumerate(
ijk_generator((self.Nx, self.Ny, self.Nz),
self.axis_scan_order)):
#previous ijk
ip, jp, kp = self.set_ijk
# new ijk
i, j, k = ijk
# move stage
if i != ip:
x = self.x_array[i]
self.nanodrive.set_pos_ax(x, self.mcl_axis_translation.x)
if j != jp:
y = self.y_array[j]
self.nanodrive.set_pos_ax(y, self.mcl_axis_translation.y)
if k != kp:
z = self.z_array[k]
self.nanodrive.set_pos_ax(z, self.mcl_axis_translation.z)
self.set_ijk = ijk
#t1 = time.time()
self.read_from_hardware()
#print "read_from_hardware (s)", time.time() - t1
#t1 = time.time()
time.sleep(self.t_exposure)
freq = self.freq_counter.read_average_freq_in_buffer()
#print "counter acquire (s)", time.time() - t1
cts = self.count_freq_map[k, j, i] = freq
REPORT_INTERVAL = 10
if ((i + j + k) % REPORT_INTERVAL) == 0:
print ijk, cts
t_now = time.time()
pixel_time = (t_now - time0) / REPORT_INTERVAL
print "sec per pixel:", pixel_time, "| time remaining (s)", ((
(self.Nx * self.Ny * self.Nz) - iii) * pixel_time)
time0 = t_now
#Finish up after scan
print "saving data..."
save_params = self.INPUT_PARAM_NAMES + [
"count_freq_map", "Nx", "Ny", "Nz", "x_array", "y_array", "z_array"
]
save_dict = dict()
for key in save_params:
save_dict[key] = getattr(self, key)
t0 = time.time()
save_fname = "%i_confocal3d.npz" % t0
np.savez_compressed(save_fname, **save_dict)
print "data saved as %s" % save_fname
def read_from_hardware(self):
pos = self.nanodrive.get_pos()
self.xpos = pos[self.mcl_axis_translation.x - 1]
self.ypos = pos[self.mcl_axis_translation.y - 1]
self.zpos = pos[self.mcl_axis_translation.z - 1]
class MclXYZStage(HardwareComponent):
MCL_AXIS_ID = dict(X=2, Y=1, Z=3)
def setup(self):
self.name = 'mcl_xyz_stage'
self.debug = True
# Created logged quantities
lq_params = dict(dtype=float,
ro=True,
initial=-1,
vmin=-1,
vmax=100,
unit='um')
self.x_position = self.add_logged_quantity("x_position", **lq_params)
self.y_position = self.add_logged_quantity("y_position", **lq_params)
self.z_position = self.add_logged_quantity("z_position", **lq_params)
lq_params = dict(dtype=float,
ro=False,
initial=-1,
vmin=-1,
vmax=100,
unit='um')
self.x_target = self.add_logged_quantity("x_target", **lq_params)
self.y_target = self.add_logged_quantity("y_target", **lq_params)
self.z_target = self.add_logged_quantity("z_target", **lq_params)
lq_params = dict(unit="um", dtype=float, ro=True, initial=100)
self.x_max = self.add_logged_quantity("x_max", **lq_params)
self.y_max = self.add_logged_quantity("y_max", **lq_params)
self.z_max = self.add_logged_quantity("z_max", **lq_params)
lq_params = dict(dtype=str,
choices=[("X", "X"), ("Y", "Y"), ("Z", "Z")])
self.h_axis = self.add_logged_quantity("h_axis",
initial="X",
**lq_params)
self.v_axis = self.add_logged_quantity("v_axis",
initial="Y",
**lq_params)
self.move_speed = self.add_logged_quantity(name='move_speed',
initial=1.0,
unit="um/s",
vmin=1e-4,
vmax=1000,
dtype=float)
# connect GUI
self.x_position.updated_value.connect(
self.gui.ui.cx_doubleSpinBox.setValue)
self.gui.ui.x_set_lineEdit.returnPressed.connect(
self.x_position.update_value)
self.y_position.updated_value.connect(
self.gui.ui.cy_doubleSpinBox.setValue)
self.gui.ui.y_set_lineEdit.returnPressed.connect(
self.y_position.update_value)
self.z_position.updated_value.connect(
self.gui.ui.cz_doubleSpinBox.setValue)
self.gui.ui.z_set_lineEdit.returnPressed.connect(
self.z_position.update_value)
self.move_speed.connect_bidir_to_widget(
self.gui.ui.nanodrive_move_slow_doubleSpinBox)
def connect(self):
if self.debug: print "connecting to mcl_xyz_stage"
# Open connection to hardware
self.nanodrive = MCLNanoDrive(debug=self.debug)
# connect logged quantities
self.x_target.hardware_set_func = \
lambda x: self.nanodrive.set_pos_ax_slow(x, self.MCL_AXIS_ID["X"])
self.y_target.hardware_set_func = \
lambda y: self.nanodrive.set_pos_ax_slow(y, self.MCL_AXIS_ID["Y"])
self.z_target.hardware_set_func = \
lambda z: self.nanodrive.set_pos_ax_slow(z, self.MCL_AXIS_ID["Z"])
self.x_position.hardware_read_func = \
lambda: self.nanodrive.get_pos_ax(self.MCL_AXIS_ID["X"])
self.y_position.hardware_read_func = \
lambda: self.nanodrive.get_pos_ax(self.MCL_AXIS_ID["Y"])
self.z_position.hardware_read_func = \
lambda: self.nanodrive.get_pos_ax(self.MCL_AXIS_ID["Z"])
self.x_max.hardware_read_func = lambda: self.nanodrive.cal[
self.MCL_AXIS_ID["X"]]
self.y_max.hardware_read_func = lambda: self.nanodrive.cal[
self.MCL_AXIS_ID["Y"]]
self.z_max.hardware_read_func = lambda: self.nanodrive.cal[
self.MCL_AXIS_ID["Z"]]
self.move_speed.hardware_read_func = self.nanodrive.get_max_speed
self.move_speed.hardware_set_func = self.nanodrive.set_max_speed
def disconnect(self):
#disconnect logged quantities from hardware
for lq in self.logged_quantities.values():
lq.hardware_read_func = None
lq.hardware_set_func = None
#disconnect hardware
self.nanodrive.close()
# clean up hardware object
del self.nanodrive
@property
def v_axis_id(self):
return self.MCL_AXIS_ID[self.v_axis.val]
@property
def h_axis_id(self):
return self.MCL_AXIS_ID[self.h_axis.val]
@property
def x_axis_id(self):
return self.MCL_AXIS_ID["X"]
@property
def y_axis_id(self):
return self.MCL_AXIS_ID["Y"]
@property
def z_axis_id(self):
return self.MCL_AXIS_ID["Z"]
class ConfocalTRPL3DScan(object):
INPUT_PARAM_NAMES = """x0 x1 dx y0 y1 dy z0 z1 dz
tacq phrange phoffset syncdiv zerocross0 zerocross1 level0 level1
axis_scan_order mcl_axis_translation
stored_histogram_chan""".split()
def __init__(self, **params):
for p in self.INPUT_PARAM_NAMES:
setattr(self, p, params[p])
self.x_array = np.arange(self.x0, self.x1, self.dx, dtype=float)
self.y_array = np.arange(self.y0, self.y1, self.dy, dtype=float)
self.z_array = np.arange(self.z0, self.z1, self.dz, dtype=float)
self.Nx = len(self.x_array)
self.Ny = len(self.y_array)
self.Nz = len(self.z_array)
self.mcl_axis_translation = xyz_tuple(*self.mcl_axis_translation)
self.HARDWARE_DEBUG = False
#HARDWARE
self.nanodrive = MCLNanoDrive(debug=self.HARDWARE_DEBUG)
#try:
# self.frame.m_staticText_maxdim.SetLabel("max: %g x %g um" % (self.nanodrive.cal_Y, self.nanodrive.cal_X) )
self.picoharp = PicoHarp300(devnum=0, debug=self.HARDWARE_DEBUG)
#DATA ARRAYS
self.integrated_count_map = np.zeros((
self.Nz,
self.Ny,
self.Nx,
),
dtype=int)
print "size of time_trace_map %e" % (self.Nx * self.Ny * self.Nz *
self.stored_histogram_chan)
self.time_trace_map = np.zeros(
(self.Nz, self.Ny, self.Nx, self.stored_histogram_chan),
dtype=np.uint16)
def run_3d_scan(self):
self.picoharp.setup_experiment(Binning=self.phrange,
SyncOffset=self.phoffset,
Tacq=self.tacq,
SyncDivider=self.syncdiv,
CFDZeroCross0=self.zerocross0,
CFDLevel0=self.level0,
CFDZeroCross1=self.zerocross1,
CFDLevel1=self.level1)
self.set_ijk = (-1, -1, -1)
self.scanning = True
time0 = time.time()
for iii, ijk in enumerate(
ijk_generator((self.Nx, self.Ny, self.Nz),
self.axis_scan_order)):
if iii == 0:
i, j, k = ijk
print "moving to start position"
self.nanodrive.set_pos_ax_slow(self.x_array[i],
self.mcl_axis_translation.x)
self.nanodrive.set_pos_ax_slow(self.y_array[j],
self.mcl_axis_translation.y)
self.nanodrive.set_pos_ax_slow(self.z_array[k],
self.mcl_axis_translation.z)
#previous ijk
ip, jp, kp = self.set_ijk
# new ijk
i, j, k = ijk
# move stage
if i != ip:
x = self.x_array[i]
self.nanodrive.set_pos_ax(x, self.mcl_axis_translation.x)
if j != jp:
y = self.y_array[j]
self.nanodrive.set_pos_ax(y, self.mcl_axis_translation.y)
if k != kp:
z = self.z_array[k]
self.nanodrive.set_pos_ax(z, self.mcl_axis_translation.z)
self.set_ijk = ijk
self.read_from_hardware()
ph = self.picoharp
ph.start_histogram(Tacq=self.tacq)
while not ph.check_done_scanning():
time.sleep(0.01)
ph.stop_histogram()
hist_data = ph.read_histogram_data()
self.time_trace_map[k, j,
i, :] = hist_data[0:self.stored_histogram_chan]
cts = self.integrated_count_map[k, j, i] = sum(hist_data)
if ((i + j + k) % 10) == 0:
print ijk, cts
t_now = time.time()
pixel_time = (t_now - time0) * 0.1
print "sec per pixel:", pixel_time, "| time remaining (s)", ((
(self.Nx * self.Ny * self.Nz) - iii) * pixel_time)
time0 = t_now
#Finish up after scan
print "saving data..."
save_params = self.INPUT_PARAM_NAMES + [
"time_trace_map", "Nx", "Ny", "Nz", "x_array", "y_array",
"z_array", "countrate0", "integrated_count_map"
]
save_dict = dict()
for key in save_params:
save_dict[key] = getattr(self, key)
t0 = time.time()
save_fname = "%i_time_trace_map3d.npz" % t0
np.savez_compressed(save_fname, **save_dict)
print "data saved as %s" % save_fname
def read_from_hardware(self):
print self.picoharp.read_count_rates()
self.countrate0 = self.picoharp.Countrate0
pos = self.nanodrive.get_pos()
self.xpos = pos[self.mcl_axis_translation.x - 1]
self.ypos = pos[self.mcl_axis_translation.y - 1]
self.zpos = pos[self.mcl_axis_translation.z - 1]