def __init__(self):
super().__init__()
self.s = Q_(1, 's')
self.us = Q_(1, 'us')
self.mock = True
self.temperature_setpoint = -10
self.cooler_on_state = False
self.acq_mode = 'Run till abort'
self.status_state = 'Camera is idle, waiting for instructions.'
self.image_size = self.detector_shape
self.preamp_st = 1
self.EM_gain_st = 1
self.ftm_state = False
self.horiz_shift_speed_state = 1
self.n_preamps = 1
self.PreAmps = np.around([self.true_preamp(n)
for n in np.arange(self.n_preamps)],
decimals=1)[::-1]
self.HRRates = [self.true_horiz_shift_speed(n)
for n in np.arange(self.n_horiz_shift_speeds())]
self.vertSpeeds = [np.round(self.true_vert_shift_speed(n), 1)
for n in np.arange(self.n_vert_shift_speeds)]
self.vertAmps = ['+' + str(self.true_vert_amp(n))
for n in np.arange(self.n_vert_clock_amps)]
self.vertAmps[0] = 'Normal'
with tiff.TiffFile(os.path.join(os.getcwd(), 'tormenta', 'control',
'beads.tif')) as ff:
self.image = ff.asarray()
self.expTime = 0.1 * self.s
def check_limits(self):
red_background = "QLineEdit { background: rgb(255, 20, 20); selection-background-color: rgb(233, 99, 0); }"
white_background = "QLineEdit { background: rgb(255, 255, 255); selection-background-color: rgb(233, 99, 0); }"
dev = self.devices[self.dropdown.currentText()]
if dev == 'time':
self.min_line.setStyleSheet(white_background)
self.max_line.setStyleSheet(white_background)
return
dev_min = Q_(dev.properties['limits']['min'])
dev_max = Q_(dev.properties['limits']['max'])
min_text = self.min_line.text()
max_text = self.max_line.text()
if min_text != "":
min_value = Q_(min_text)
if dev_min <= min_value <= dev_max:
self.min_line.setStyleSheet(white_background)
else:
self.min_line.setStyleSheet(red_background)
else:
self.min_line.setStyleSheet(white_background)
if max_text != "":
max_value = Q_(max_text)
if dev_min <= max_value <= dev_max:
self.max_line.setStyleSheet(white_background)
else:
self.max_line.setStyleSheet(red_background)
else:
self.max_line.setStyleSheet(white_background)
def initialize(self, piezo_scan_range=Q_(30,'V'), maxevals=50, initial_current=Q_(220,'mA'), initial_feedforward=Q_(-0.2, 'mA/V'), max_retries =2):
#Switch the relay position
if self.relay.state[1] != self.CONSTS['ch1_state'] or self.relay.state[4] != self.CONSTS['ch4_state']:
self.relay.state[1] = self.CONSTS['ch1_state']
self.relay.state[4] = self.CONSTS['ch4_state']
time.sleep(0.5)
# Setup the laser scan
piezo_scan_range = piezo_scan_range.to('V').m #Since the scan amplitude is 1V
self.dlc.piezo_external_input_factor = piezo_scan_range/2
self.dlc.scan_amplitude = 2
self.dlc.piezo_voltage = 70 - piezo_scan_range/2
self.dlc.scan_offset = 1
self.dlc.scan_channel = 'A'
self.dlc.piezo_external_input_signal = 'Fine In 1'
self.dlc.scan_frequency = Q_(100, 'Hz')
#Setup the fabry perot
self.fp.selectivity = 0.1
self.fp.points = 5000
#Others
self.num_peak_threshold = int(0.5*piezo_scan_range)
self.start_time = time.time()
self.error_metric = self.CONSTS['error_metric']
def ReflectionDistribution(self):
self.F = open(self.filename, 'w')
self.pw = []
for zpoint in range(len(self.zpositions)):
self.attocube.absolute_move(self.axis_index_z,
self.zpositions[zpoint])
time.sleep(0.1)
self.attocube.cl_move(self.axis_index_z, self.zpositions[zpoint])
self.attocube.frequency[self.axis_index_x] = Q_(self.movef, 'Hz')
self.attocube.amplitude[self.axis_index_x] = Q_(self.movev, 'V')
self.attocube.absolute_move(self.axis_index_x, self.x_start)
time.sleep(0.1)
self.attocube.cl_move(self.axis_index_x, self.x_start)
self.attocube.frequency[self.axis_index_x] = Q_(self.jogf, 'Hz')
self.attocube.amplitude[self.axis_index_x] = Q_(self.movef, 'Hz')
self.attocube.jog(self.axis_index_x, 1)
t0 = time.time()
while time.time() - t0 < self.x_time:
data.append(self.powermeter.power.magnitude * 1000)
time.sleep(1e-3)
self.attocube.stop()
time.sleep(0.5)
print("%d/%d:%f" %
(zpoint, len(self.zpositions),
self.attocube.position[self.axis_index_x].magnitude))
for item in data:
self.F.write("%f," % item)
F.write('\n')
self.pw.append(data)
values = {'power': self.pw}
self.ReflectionDistribution.acquire(values)
F.close()
return
def test_action(self):
obj = aDriver()
self.assertEqual(obj.run(), 42)
self.assertEqual(obj.run2(2), 42 * 2)
self.assertEqual(obj.run3(3), 42 * 3)
self.assertEqual(obj.run4(Q_(3, 'ms')), 3)
self.assertEqual(obj.run4(Q_(3, 's')), 3000)
def __init__(self):
super().__init__()
self.degC = Q_(1, 'degC')
self.s = Q_(1, 's')
self.us = Q_(1, 'us')
self.temperature_setpoint = Q_(-10, 'degC')
self.cooler_on_state = False
self.acq_mode = 'Run till abort'
self.status_state = 'Camera is idle, waiting for instructions.'
self.image_size = self.detector_shape
self.preamp_st = 1
self.EM_gain_st = 1
self.ftm_state = False
self.horiz_shift_speed_state = 1
self.n_preamps = 1
self.PreAmps = np.around(
[self.true_preamp(n) for n in np.arange(self.n_preamps)],
decimals=1)[::-1]
self.HRRates = [
self.true_horiz_shift_speed(n)
for n in np.arange(self.n_horiz_shift_speeds())
]
self.vertSpeeds = [
np.round(self.true_vert_shift_speed(n), 1)
for n in np.arange(self.n_vert_shift_speeds)
]
self.vertAmps = [
'+' + str(self.true_vert_amp(n))
for n in np.arange(self.n_vert_clock_amps)
]
self.vertAmps[0] = 'Normal'
def do_line_scan(self):
""" Does the wavelength scan.
After a line scan, the different devices should be increased by 1, etc."""
scan = self.scan
laser = self.devices[scan['laser']['name']]
shutter = self.scan['shutter']
ni_daq = self.devices['NI-DAQ']
daq = self.daqs['NI-DAQ']
ni_daq.driver.digital_output(shutter['port'], False)
if not isinstance(shutter['delay'], Q_):
delay = Q_(shutter['delay'])
else:
delay = shutter['delay']
delay = delay.m_as('s')
if delay > 0:
time.sleep(delay)
ni_daq.driver.digital_output(shutter['port'], True)
if ni_daq.driver.is_task_complete(daq['monitor_task']):
ni_daq.driver.stop_task(daq['monitor_task'])
ni_daq.driver.trigger_analog(daq['monitor_task'])
laser.driver.execute_sweep()
approx_time_to_scan = (
laser.params['stop_wavelength'] -
laser.params['start_wavelength']) / laser.params[
'wavelength_speed'] * laser.params['wavelength_sweeps']
while laser.driver.sweep_condition != 'Stop':
sleep(approx_time_to_scan.m / config.monitor_read_scan)
ni_daq.driver.digital_output(shutter['port'], False)
laser.driver.wavelength = scan['laser']['params']['start_wavelength']
return True
def main(self, piezo_scan_range=Q_(30,'V'), maxevals=50, initial_current=Q_(220,'mA'), initial_feedforward=Q_(-0.2, 'mA/V'), max_retries =2):
#Set the optimization parametters
sigma0 = 1
x0 = [
(initial_current.to('mA')/self.CONSTS['current_scaling'].to('mA')).m,
initial_feedforward.to('mA / V').m,
]
bounds = [[self.CONSTS['current_bounds'][0] / self.CONSTS['current_scaling'].to('mA').m, self.CONSTS['feedfoward_bounds'][0]],
[self.CONSTS['current_bounds'][1] / self.CONSTS['current_scaling'].to('mA').m, self.CONSTS['feedfoward_bounds'][1]]]
cmaopts = {
'tolfun':self.CONSTS['error_threshold'],
'tolx': 1e-2,
'maxfevals': maxevals,
'bounds': bounds,
'verb_disp':self.CONSTS['verbose'],# No printing of the optimization results on the console
}
for retry_idx in self.progress(range(max_retries)):
#Set to passive mode
self.fp.active_mode = False
self.dlc.scan_enabled = True
self.dlc.piezo_external_input_enabled = True
#Run the optimization
self.inner_progress = iter(self.progress(range(maxevals)))
if self.CONSTS['optimizer'] == 'cma':
result = cma.fmin(self.cost_func, x0, sigma0, options=cmaopts)
xopt = result[0]
elif self.CONSTS['optimizer'] == 'dlib':
_f = lambda current, ff: self.cost_func([current, ff])
result = dlib.find_min_global(_f, bounds[0], bounds[1], maxevals)
xopt = result[0]
#Set the optimal parameters
err = self.cost_func(xopt)
#Verify the results
self.fp.refresh()
peak_mags = self.fp.peak_magnitudes()
restart = False
# If there is too many peak => Restart
if len(peak_mags) > self.num_peak_threshold:
restart = True
if self.CONSTS['verbose']: print('CTROptimize Retry #{}: Too many peaks...'.format(retry_idx))
# If the sum of square error metric is to high => Restart
if err > self.CONSTS['error_threshold']:
restart = True
if self.CONSTS['verbose']: print('CTROptimize Retry #{}: err is too high ({})...'.format(retry_idx,err))
# Break the loop if we are done
if not restart:
break
if self.CONSTS['verbose']: print('CTROptimize terminated with values {} and err of {}'.format(xopt, err))
def setup_values(self):
self.inst.start_wavelength = Q_('1492 nm')
self.inst.stop_wavelength = Q_('1512 nm')
self.inst.step_time = Q_('0.1 s')
self.inst.step_wavelength = Q_('0.1 nm')
self.inst.sweep_mode = 'StepOne'
self.inst.wavelength = Q_('1510 nm')
self.inst.wavelength_sweeps = 2
self.inst.wavelength_sweeps = 2
def do_scan(self):
""" Does the scan considering that everything else was already set up.
"""
scan = self.scan
laser = self.devices[scan['laser']['name']]
dev_to_scan = scan['axis']['device']['name']
output = scan['axis']['device']['property']
approx_time_to_scan = (laser.params['stop_wavelength'] -
laser.params['start_wavelength']
) / laser.params['wavelength_speed']
# Scan the laser and the values of the given device
if output != 'time':
dev_range = scan['axis']['device']['range']
start = Q_(dev_range[0])
units = start.u
stop = Q_(dev_range[1])
step = Q_(dev_range[2])
num_points_dev = ((stop - start) / step).to('')
else:
dev_range = scan['axis']['device']['range']
start = 1
stop = dev_range[1]
num_points_dev = stop
num_points_dev += 1 # So the last bit of information is true.
self.scan_data = []
for value in np.linspace(start, stop, num_points_dev, endpoint=True):
if not self.keep_scanning:
print('Stopping the scan')
break
if output != 'time':
self.set_value_to_device(dev_to_scan, {output: value * units})
dev = self.devices[dev_to_scan]
time.sleep(0.1)
while not dev.driver.finished_moving:
time.sleep(0.2)
self.do_line_scan()
if self.wait_for_line:
data = self.read_scans(points=scan['line_points'], timeout=-1)
for d in data:
if len(data[d]) != scan['line_points']:
dd = np.zeros((scan['line_points'], ))
# Discard if there are more points than points available in the line.
if len(data[d]) > scan['line_points']:
data[d] = data[d][:scan['line_points']]
dd[:len(data[d])] = data[d]
data[d] = dd
self.line_scan_finished.emit(data)
self.scan_data.append(data)
ni_daq = self.devices['NI-DAQ']
daq = self.daqs['NI-DAQ']
if ni_daq.driver.is_task_complete(daq['monitor_task']):
ni_daq.driver.stop_task(daq['monitor_task'])
return True
def cl_move(self, axis, pos, delta_z=Q_(0.1,'um'), iter_n=4, delay=Q_(0.05, 's'), debug=False, max_iter=1000):
i = 0
while(not self.at_pos(axis=axis,pos=Q_(pos, 'um'), delta_z=Q_(delta_z, 'um'), iter_n=iter_n, delay=Q_(delay,'s'))):
self.position[axis] = Q_(pos, 'um')
time.sleep(0.2)
i += 1
#if i>=max_iter:
# raise Exception("Reached max_iter")
if debug: print("It took {} iterations to move to position".format(i))
return
def update_laser(self):
wavelength = Q_(self.wavelength.text())
power = Q_(self.power.text())
values = {
'wavelength': wavelength,
'powermW': power,
}
self.wavelength_slider.setValue(
(wavelength.m_as(Q_('nm')) - 1480) / 0.0001)
print(values)
def at_pos(self,
axis,
pos,
delta_z=Q_(0.2, 'um'),
iter_n=2,
delay=Q_(0.1, 's')):
for i in range(iter_n):
time.sleep(delay)
if abs(self.position[axis].to('um').magnitude - pos) > delta_z:
return False
return True
def update_laser(self):
"""
Gets the values from the laser_widget and sends them to the laser. It only deals with the wavelength and the
power. The rest of the values are passed to the scan and are therefore not for modifying the laser in-vivo.
"""
wavelength = Q_(self.laser_widget.wavelength.text())
power = Q_(self.laser_widget.power.text())
values = {
'wavelength': wavelength,
'powermW': power,
}
self.laser.driver.update(values)
def loadPreset(main, filename=None):
tree = main.tree.p
timings = tree.param('Timings')
if filename is None:
preset = main.presetsMenu.currentText()
config = configparser.ConfigParser()
config.read(os.path.join(main.presetDir, preset))
configCam = config['Camera']
shape = configCam['Shape']
main.shape = literal_eval(shape)
main.frameStart = literal_eval(configCam['Frame Start'])
# Frame size handling
shapeName = configCam['Shape Name']
if shapeName == 'Custom':
main.customFrameLoaded = True
tree.param('Image frame').param('Shape').setValue(shapeName)
main.frameStart = literal_eval(configCam['Frame Start'])
main.adjustFrame()
main.customFrameLoaded = False
else:
tree.param('Image frame').param('Shape').setValue(shapeName)
vps = timings.param('Vertical pixel shift')
vps.param('Speed').setValue(Q_(configCam['Vertical shift speed']))
cva = 'Clock voltage amplitude'
vps.param(cva).setValue(configCam[cva])
ftm = 'Frame Transfer Mode'
timings.param(ftm).setValue(configCam.getboolean(ftm))
csm = 'Cropped sensor mode'
if literal_eval(configCam[csm]) is not (None):
main.cropLoaded = True
timings.param(csm).param('Enable').setValue(configCam.getboolean(csm))
main.cropLoaded = False
hrr = 'Horizontal readout rate'
timings.param(hrr).setValue(Q_(configCam[hrr]))
expt = 'Set exposure time'
timings.param(expt).setValue(float(configCam[expt]))
pag = 'Pre-amp gain'
tree.param('Gain').param(pag).setValue(float(configCam[pag]))
tree.param('Gain').param('EM gain').setValue(int(configCam['EM gain']))
def cl_move_2(self, axis, pos, delta_z=Q_(0.4, 'um'), max_iter=1000):
current_pos = Q_(self.position[axis].magnitude, 'um')
upperbound = Q_(pos, 'um') + delta_z
lowerbound = Q_(pos, 'um') - delta_z
i = 0
if pos < 0:
pos = 0
while (not ((current_pos < upperbound) and
(current_pos > lowerbound))) and (i < max_iter):
self.absolute_move(axis, pos)
current_pos = self.position[axis]
i += 1
return
def __init__(self, port):
"""initialization of the class"""
super().__init__(port)
super().initialize() # Automatically open the port
print(self.idn())
self.TIMEOUT = 20
V = Q_(1, 'V')
Hz = Q_(1, 'Hz')
self.func = 'SIN' #Options are SIN,SQUare,RAMP,PULS,DC
self.freq = 550e3 * Hz
self.ampl = 5 * V #Amplitude peak2peak in volt min=10mVpp, max=10Vpp
self.offset = 2.5 * V #Offset of the signal |offset| <= 10 - Vpp/2
self.apply(self.func, self.freq, self.ampl, self.offset)
def initialize(self):
super().initialize()
self.intensity_max = 3.1 # maximum power setting for the Katana
self.power_setting = 1 # To change power with python (1) or knob (0)
self.mode = 0 # Constant current (1) or constant power (0) mode
self.triggerMode = 0 # Trigger: internal (0)
self.enabled_state = 0 # Laser initially off (0)
self.W = Q_(1, 'W')
self.mW = Q_(1, 'mW')
self.power_setpoint = 0 # Current laser power setpoint
self.setPowerSetting(self.power_setting)
self.setTriggerSource(self.triggerMode)
self.setMode(self.mode)
def do_scans_with_ref(self, nr_runs):
""" Does the scan considering that everything else was already set up.
with a reference scan after every scan
repeats scan for a set number of times
"""
print()
print('do_scan')
print()
scan = self.scan
laser = self.devices[scan['laser']['name']]
dev_to_scan = scan['axis']['device']['name']
output = scan['axis']['device']['property']
approx_time_to_scan = (laser.params['stop_wavelength'] -
laser.params['start_wavelength']
) / laser.params['wavelength_speed']
# Scan the laser and the values of the given device
if output != 'time':
dev_range = scan['axis']['device']['range']
start = Q_(dev_range[0])
units = start.u
stop = Q_(dev_range[1])
step = Q_(dev_range[2])
num_points_dev = ((stop - start) / step).to('')
else:
dev_range = scan['axis']['device']['range']
start = 1
stop = dev_range[1]
num_points_dev = stop
num_points_dev += 1 # So the last bit of information is true.
self.scan_data = []
self.read_scans(-1)
for value in np.linspace(start, stop, num_points_dev, endpoint=True):
if output != 'time':
self.set_value_to_device(dev_to_scan, {output: value * units})
dev = self.devices[dev_to_scan]
time.sleep(0.1)
while not dev.driver.finished_moving:
time.sleep(0.2)
for i in range(nr_runs):
print('run number = ', i)
self.do_line_scan_shutter_closed()
self.scan_data.append(
self.read_scans(-1)) #self.scan['line_points']*2
for d in self.scan_data[-1]:
print('Acquired {} from {}'.format(
len(self.scan_data[-1][d]), d))
return True
def get_values(self):
min_value = Q_(self.min_line.text())
max_value = Q_(self.max_line.text())
step_value = Q_(self.step_line.text())
values = {
'index': self.index,
'radio': self.radio.isChecked(),
'range': [
min_value,
max_value,
step_value,
]
}
return values
def absolute_move(self, axis, target, eps=0.1, max_move=MAX_ABSOLUTE_MOVE):
if not max_move is None:
if abs(self.position[axis] - Q_(target, 'um')) > max_move:
raise Exception(
"Relative move %f-%f um is greater then the %f um" %
(self.position[axis].magnitude, Q_(
target, 'm').magnitude, max_move.magnitude))
target = target * 1e-6
eps = eps * 1e-6
self.check_error(self.lib.setTargetRange(self.device, axis, eps))
self.check_error(self.lib.setTargetPosition(self.device, axis, target))
enable = 0x01
relative = 0x00
self.check_error(
self.lib.startAutoMove(self.device, axis, enable, relative))
return
def test_Self_exceptions(self):
class X(Driver):
@Feat(units=Self.units)
def value(self):
return 1
@value.setter
def value(self, value):
pass
@Feat()
def units(self):
return self._units
@units.setter
def units(self, value):
self._units = value
x = X()
self.assertRaises(Exception, getattr, x, 'value')
self.assertRaises(Exception, setattr, x, 'value', 1)
x.units = 'ms'
self.assertEqual(x.feats.value.units, 'ms')
self.assertEqual(x.value, Q_(1, 'ms'))
def __init__(self):
super().__init__()
self.mW = Q_(1, 'mW')
self.enabled = False
self.power_sp = 0 * self.mW
def test_start_moving(self):
self.inst.position = Q_('0deg')
t0 = time.time()
while not self.inst.finished_moving:
sleep(1)
if time.time - t0 > 60:
self.fail('Timeout moving to 0 degrees')
self.assertAlmostEqual(self.inst.position.m_as('deg'), 0,
'Position not 0 degrees')
self.inst.position = Q_('10deg')
while not self.inst.finished_moving:
sleep(1)
if time.time - t0 > 20:
self.fail('Timeout moving to 10 degrees')
self.assertAlmostEqual(self.inst.position.m_as('deg'), 10,
'Position not 10 degrees')
def get_feat_widget(feat):
if feat['values'] is not None:
w = ComboBoxFeatWidget(feat['values'])
elif isinstance(feat['value'], (int, float, Q_)) or not feat['units'] is None:
opts = dict()
if feat['units'] is not None:
opts['unit'] = feat['units']
if feat['limits'] is not None:
opts['bounds'] = feat['limits']
opts['dec'] = True
opts['minStep'] = 1e-3
opts['decimals'] = 10
if isinstance(feat['value'], int):
opts['int'] = True
opts['minStep'] = 1
opts['decimals'] = 10
w = SpinBoxFeatWidget(opts)
elif feat['value'] is None:
w = LineEditFeatWidget(text = 'Unknown type')
w.set_readonly(True)
return w
else:
w = LineEditFeatWidget(text = feat['value'])
w.set_readonly(feat['readonly'])
if (not feat['value'] is None) and (not feat['units'] is None):
w.setter(Q_(feat['value'], feat['units']))
else:
w.setter(feat['value'])
return w
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
super().initialize(*args, **kwargs)
self.s = Q_(1, 's')
self.mock = False
# Default imaging parameters
self.readout_mode = 'Image'
self.trigger_mode = 'Internal'
self.EM_advanced_enabled = False
self.EM_gain_mode = 'RealGain'
self.amp_typ = 0
self.set_accum_time(0 * self.s) # Minimum accumulation and
self.set_kinetic_cycle_time(0 * self.s) # kinetic times
# Lists needed for the ParameterTree
self.PreAmps = np.around([self.true_preamp(n)
for n in np.arange(self.n_preamps)],
decimals=1)[::-1]
self.HRRates = [self.true_horiz_shift_speed(n)
for n in np.arange(self.n_horiz_shift_speeds())][::-1]
self.vertSpeeds = [np.round(self.true_vert_shift_speed(n), 1)
for n in np.arange(self.n_vert_shift_speeds)]
self.vertAmps = ['+' + str(self.true_vert_amp(n))
for n in np.arange(self.n_vert_clock_amps)]
self.vertAmps[0] = 'Normal'
def __init__(self, focusWidget, *args, **kwargs):
super().__init__(*args, **kwargs)
self.z = focusWidget.z
self.focusWidget = focusWidget # mainwidget será FocusLockWidget
self.um = Q_(1, 'micrometer')
def assertQuantityEqual(self, q1, q2, msg=None, delta=None):
"""
Make sure q1 and q2 are the same quantities to within the given
precision.
"""
delta = 1e-5 if delta is None else delta
msg = '' if msg is None else ' (%s)' % msg
q1 = Q_(q1)
q2 = Q_(q2)
d1 = getattr(q1, '_dimensionality', None)
d2 = getattr(q2, '_dimensionality', None)
if (d1 or d2) and not (d1 == d2):
raise self.failureException(
"Dimensionalities are not equal (%s vs %s)%s" % (d1, d2, msg))
def __init__(self):
super(SimLaser).__init__()
self.mW = Q_(1, 'mW')
self.enabled = False
self.power_sp = 0 * self.mW
print("Simulated laser initialized")
def test_instance_specific(self):
x = aDriver()
y = aDriver()
val = Q_(3, 's')
self.assertEqual(x.run4(val), y.run4(val))
x.actions.run4.units = 's'
self.assertNotEqual(x.run4(val), y.run4(val))
self.assertEqual(x.run4(val), 3)
# Measure autocorrelation with slow-scan autocorrelator
#
# Instruct the positioner to move step by step and take measurements with the
# oscilloscope.
# Configuration
axis = 3
lvdt_channel = 1
pmt_channel = 2
oscilloscope_resource = 'GPIB0::14::INSTR'
positioner_resource = 'GPIB0::3::INSTR'
output_directory = 'C:\\ignacio\\mediciones\\slowscan'
output_prefix = 'scan'
output_suffix = '.txt'
progress_indications = 10
measurement_delay = Q_(100,'ms')
measurement_delay.ito('s')
max_scale_changes = 4
# Before running this script, set the home position to where the two path
# lengths coincide
sweep_start = Q_(-300,'um')
sweep_end = Q_(-70,'um')
sweep_points = 30
# Find the number of the last run
try:
file_regex = output_prefix+r'(\d\d\d\d)'+output_suffix
matches = (re.match(file_regex, filename)
for filename in os.listdir(output_directory))
run_index = 1 + max(int(match.group(1))
for match in matches if match is not None)
