def _iter(self, i, vm):
if vm is None:
self.debug('No valve manager')
return
if not i % self.state_freq:
vm.load_valve_states()
if not i % self.lock_freq:
vm.load_valve_lock_states()
if not i % self.owner_freq:
vm.load_valve_owners()
if not i % self.checksum_freq:
if not vm.state_checksum:
self.debug('State checksum failed')
# vm.load_valve_states()
# vm.load_valve_lock_states()
# vm.load_valve_owners()
if i > 100:
i = 0
if not self._stop_evt.isSet():
do_after(self.update_period * 1000, self._iter, i + 1, vm)
def _get_component_hook(self, model=None):
if model is None:
model = self.figure_model
ss = []
for p in model.panels:
g = p.figures[0].graph
if g:
if self.plotter_options.show_statistics_as_table:
g.on_trait_change(self._handle_reg, 'regression_results')
for plot in reversed(g.plots):
for k, v in plot.plots.items():
if k.startswith('fit') and hasattr(
v[0], 'regressor'):
label = plot.y_axis.title
for tag in ('sub', 'sup'):
label = label.replace(
'<{}>'.format(tag), '')
label = label.replace(
'</{}>'.format(tag), '')
ss.append(
SeriesStatistics(label, v[0].regressor))
else:
g.on_trait_change(self._handle_reg,
'regression_results',
remove=True)
do_after(1, self.trait_set, statistics=ss)
def _iter(self):
if not self._alive:
return
now = datetime.now()
print('now={} run_time={}. hourmatch={}, minutematch={} ran={}'.format(now, self.run_time,
now.hour >= self.run_time.hour,
now.minute >= self.run_time.minute,
self._ran))
if now.hour >= self.run_time.hour:
if now.minute >= self.run_time.minute:
if not self._ran:
self._ran = True
unks, updated = self._load_analyses()
if not self._alive:
return
print('updated={} loaded unks={}'.format(updated, unks))
if unks:
self.engine.rerun_with(unks, post_run=False)
else:
self._ran = False
period = 60 * 10
do_after(1000 * period, self._iter)
def _iter(self, i, vm):
if vm is None:
self.debug('No valve manager')
return
if not i % self.state_freq:
vm.load_valve_states()
if not i % self.lock_freq:
vm.load_valve_lock_states()
if not i % self.owner_freq:
vm.load_valve_owners()
if not i % self.checksum_freq:
if not vm.state_checksum:
self.debug('State checksum failed')
# vm.load_valve_states()
# vm.load_valve_lock_states()
# vm.load_valve_owners()
if i > 100:
i = 0
if not self._stop_evt.isSet():
do_after(self.update_period * 1000, self._iter, i + 1, vm)
# ============= EOF =============================================
def _flash_iter(self, cnt):
if not self._alive:
return
self.visited = bool(cnt % 2)
self.engine.update_needed = True
if cnt > 100:
cnt = 0
do_after(1000, self._flash_iter, cnt + 1)
def _activate_hook(self):
self.monitor = SystemMonitor(manager=self, name='system_monitor')
self.monitor.monitor()
if self.gauge_manager:
self.info('start gauge scans')
self.gauge_manager.start_scans()
if self.use_hardware_update and self.switch_manager:
do_after(self.hardware_update_period * 1000, self._update_states)
def _activate_hook(self):
self.monitor = SystemMonitor(manager=self, name='system_monitor')
self.monitor.monitor()
if self.gauge_manager:
self.info('start gauge scans')
self.gauge_manager.start_scans()
if self.use_hardware_update and self.switch_manager:
do_after(self.hardware_update_period * 1000, self._update_states)
def _flash_iter(self, cnt):
if not self._alive:
return
self.visited = bool(cnt % 2)
self.engine.update_needed = True
if cnt > 100:
cnt = 0
do_after(1000, self._flash_iter, cnt + 1)
def normal_left_down(self, event):
"""
"""
x = event.x
y = event.y
if self.valid_position(x, y):
x, y = self.map_data((x, y))
self.set_desired_position(x, y)
self.feeder.set_position(x, units='mm')
do_after(50, self._update_position)
event.handled = True
def normal_left_down(self, event):
"""
"""
x = event.x
y = event.y
if self.valid_position(x, y):
x, y = self.map_data((x, y))
self.set_desired_position(x, y)
self.feeder.set_position(x, units='mm')
do_after(50, self._update_position)
event.handled = True
def _extraction_state_iter(self, i, iperiod, threshold, label, color):
# print '{} {} {} {}'.format(i, iperiod, i % iperiod, threshold)
if i % iperiod > threshold:
self.trait_set(extraction_state_label='')
else:
self.trait_set(extraction_state_label=label,
extraction_state_color=color)
end_flag = self._end_flag
if not end_flag.isSet():
if i > 1000:
i = 0
do_after(1000 / float(iperiod), self._extraction_state_iter, i + 1, iperiod,
threshold, label, color)
else:
self.trait_set(extraction_state_label='')
def _iter(self, i):
vm = self.valve_manager
if not i % self.state_freq:
vm.load_valve_states()
if not i % self.lock_freq:
vm.load_valve_lock_states()
if not i % self.owner_freq:
vm.load_valve_owners()
if i > 100:
i = 0
if not self._stop_evt.isSet():
do_after(self.period * 1000, self._iter, i + 1)
def _iter(self, i):
vm = self.valve_manager
if not i % self.state_freq:
vm.load_valve_states()
if not i % self.lock_freq:
vm.load_valve_lock_states()
if not i % self.owner_freq:
vm.load_valve_owners()
if i > 100:
i = 0
if not self._stop_evt.isSet():
do_after(self.period * 1000, self._iter, i + 1)
def _iter(self):
if self._alive:
unks = self._load_unknowns()
if unks:
self.unknowns = unks
self.engine.rerun_with(unks, post_run=False)
self.engine.refresh_figure_editors()
# self.exclude_uuids = [u.uuid for u in unks]
# self.engine.refresh_unknowns(unks)
# # self.engine.
# self.engine.selected.unknowns = unks
# self.engine.run(state=self.engine.state)
do_after(self.period * 1000, self._iter)
def _iter(self):
if self._alive:
unks = self._load_unknowns()
if unks:
self.unknowns = unks
self.engine.rerun_with(unks, post_run=False)
self.engine.refresh_figure_editors()
# self.exclude_uuids = [u.uuid for u in unks]
# self.engine.refresh_unknowns(unks)
# # self.engine.
# self.engine.selected.unknowns = unks
# self.engine.run(state=self.engine.state)
do_after(self.period * 1000, self._iter)
def _extraction_state_iter(self, i, iperiod, threshold, label, color):
# print '{} {} {} {}'.format(i, iperiod, i % iperiod, threshold)
if i % iperiod > threshold:
self.trait_set(extraction_state_label='')
else:
self.trait_set(extraction_state_label=label,
extraction_state_color=color)
end_flag = self._end_flag
if not end_flag.isSet():
if i > 1000:
i = 0
do_after(1000 / float(iperiod), self._extraction_state_iter, i + 1,
iperiod, threshold, label, color)
else:
self.trait_set(extraction_state_label='')
def _open_file(self, path, **kw):
if not isinstance(path, (tuple, list)):
path = (path, )
manager = self.manager
if manager.verify_database_connection(inform=True):
if manager.load():
manager.experiment_factory.activate(load_persistence=False)
for p in path:
self.manager.info('Opening experiment {}'.format(p))
self._open_experiment(p)
manager.path = path
# manager.update_info()
do_after(1000, manager.update_info)
return True
def _open_file(self, path, **kw):
if not isinstance(path, (tuple, list)):
path = (path, )
manager = self.manager
if manager.verify_database_connection(inform=True):
if manager.load():
manager.experiment_factory.activate(load_persistence=False)
for p in path:
self.manager.info('Opening experiment {}'.format(p))
self._open_experiment(p)
manager.path = path
# manager.update_info()
do_after(1000, manager.update_info)
return True
def _load_names(self):
if self.username and self.password and self.host:
if self.host:
def func():
self._progress_state = True
do_after(50, func)
self._names = show_databases(self.host, self.username, self.password, self._schema_identifier)
def func():
self._progress_state = True
do_after(50, func)
else:
warning(None, 'Invalid IP address format. "{}" e.g 129.255.12.255'.format(self.host))
def _load_names(self):
if self.username and self.password and self.host:
if self.host:
def func():
self.progress_state = True
do_after(50, func)
self._names = show_databases(self.host, self.username, self.password)
def func():
self.progress_state = True
do_after(50, func)
else:
warning(None, 'Invalid IP address format. "{}" e.g 129.255.12.255'.format(self.host))
def _iter_dac(self, di, gen, evt, intensities):
# self.debug('iter dac {}'.format(di))
mag = self.spectrometer.magnet
mag.set_dac(di, verbose=self.verbose)
d = self._magnet_step_hook()
self._graph_hook(di, d)
intensities.append(d)
try:
di = gen.next()
except StopIteration:
di = None
if di is not None and self.isAlive():
p=int(self.integration_time*1000*0.9)
do_after(p, self._iter_dac, di, gen, evt, intensities)
else:
evt.set()
def _iter_dac(self, mag, di, gen, evt, intensities):
mag.set_dac(di, verbose=self.verbose)
d = self._magnet_step_hook()
self._graph_hook(di, d)
intensities.append(d)
try:
di = gen.next()
except StopIteration:
di = None
if di is not None and self.isAlive():
p = int(self.integration_time * 1000 * 0.9)
do_after(p, self._iter_dac, mag, di, gen, evt, intensities)
else:
evt.set()
def _iter_dac(self, mag, di, gen, evt, intensities):
mag.set_dac(di, verbose=self.verbose)
d = self._magnet_step_hook()
self._graph_hook(di, d)
intensities.append(d)
try:
di = gen.next()
except StopIteration:
di = None
if di is not None and self.isAlive():
p=int(self.integration_time*1000*0.9)
do_after(p, self._iter_dac, mag, di, gen, evt, intensities)
else:
evt.set()
def _iter(self, last_update=None):
if not self._alive:
return
unks, updated = self._load_analyses()
if not self._alive:
return
st = None
if updated:
self.state.unknowns = unks
self.unknowns = unks
self.engine.run(post_run=False,
pipeline=self.pipeline,
state=self.state,
configure=False)
self.engine.post_run_refresh(state=self.state)
self.engine.refresh_figure_editors()
self.engine.selected = self.pipeline.nodes[-1]
if not self._alive:
return
st = time.time()
if last_update:
if self._between_updates:
self._between_updates = (
(st - last_update) + self._between_updates) / 2.
else:
self._between_updates = st - last_update
period = self._between_updates * 0.75
else:
period = 60 * self.post_analysis_delay
else:
period = self.period
do_after(int(period * 1000), self._iter, st)
def init_log():
global log
global log_lock
log=nx.Graph()
log_lock=Lock()
# http://stackoverflow.com/questions/11990556/python-how-to-make-global-imports-from-a-function
global plt
global np
global mlab
global do_after
# import matplotlib.pyplot as plt
import numpy as np
from mayavi import mlab
from pyface.timer.do_later import do_after
mlab.figure(1)
mlab.clf()
do_after(DRAW_LOG_DELAY,draw_log)
log_service_broadcast()
do_after(LOG_SERVICE_BROADCAST_DELAY,log_service_broadcast)
mlab.show()
def _iter_dac(self, di, gen, evt, intensities):
# self.debug('iter dac {}'.format(di))
mag = self.spectrometer.magnet
mag.set_dac(di,
verbose=self.verbose,
settling_time=self.integration_time * 2)
d = self._magnet_step_hook()
self._graph_hook(di, d)
intensities.append(d)
try:
di = gen.next()
except StopIteration:
di = None
if di is not None and self.isAlive():
p = int(self.integration_time * 1000 * 0.9)
do_after(p, self._iter_dac, di, gen, evt, intensities)
else:
evt.set()
def _iter(self, last_update=None):
if not self._alive:
return
unks, updated = self._load_analyses()
if not self._alive:
return
st = None
if updated:
self.state.unknowns = unks
self.unknowns = unks
self.engine.run(post_run=False, pipeline=self.pipeline, state=self.state, configure=False)
self.engine.post_run_refresh(state=self.state)
self.engine.refresh_figure_editors()
self.engine.selected = self.pipeline.nodes[-1]
if not self._alive:
return
st = time.time()
if last_update:
if self._between_updates:
self._between_updates = ((st - last_update) + self._between_updates) / 2.
else:
self._between_updates = st - last_update
period = self._between_updates * 0.75
else:
period = 60 * self.post_analysis_delay
else:
period = self.period
do_after(int(period * 1000), self._iter, st)
def _play(self, play_flag, step_flag, rewind):
vid = self.video
fps = vid.get_fps()
try:
step = 1
end = self.nframes
if rewind:
step = -1
end = 0
for i, fi in enumerate(range(self._current_frame_id, end, step)):
self._current_frame_id = fi
if play_flag.isSet():
break
if rewind:
vid.set_frame_index(fi)
f = vid.get_frame()
do_after(1, self.video_image.load, f)
time.sleep(1 / fps)
if step_flag.isSet():
if i >= self.step_len:
break
self.frame += step
else:
self.frame = fi + 1
self._current_frame_id = self.frame
else:
self._playing = False
play_flag.clear()
self._current_frame_id = 0
self.frame = 1
except Exception, e:
print e
def _play(self, play_flag, step_flag, rewind):
vid = self.video
fps = vid.get_fps()
try:
step = 1
end = self.nframes
if rewind:
step = -1
end = 0
for i, fi in enumerate(range(self._current_frame_id, end, step)):
self._current_frame_id = fi
if play_flag.isSet():
break
if rewind:
vid.set_frame_index(fi)
f = vid.get_frame()
do_after(1, self.video_image.load, f)
time.sleep(1 / fps)
if step_flag.isSet():
if i >= self.step_len:
break
self.frame += step
else:
self.frame = fi + 1
self._current_frame_id = self.frame
else:
self._playing = False
play_flag.clear()
self._current_frame_id = 0
self.frame = 1
except Exception, e:
print e
def _iter(self):
if not self._alive:
return
now = datetime.now()
print('now={} run_time={}. hourmatch={}, minutematch={} ran={}'.format(
now, self.run_time, now.hour >= self.run_time.hour,
now.minute >= self.run_time.minute, self._ran))
if now.hour >= self.run_time.hour:
if now.minute >= self.run_time.minute:
if not self._ran:
self._ran = True
unks, updated = self._load_analyses()
if not self._alive:
return
print('updated={} loaded unks={}'.format(updated, unks))
if unks:
self.engine.rerun_with(unks, post_run=False)
else:
self._ran = False
period = 60 * 10
do_after(1000 * period, self._iter)
def _stop_button_fired(self):
self.execute_sql('stop slave')
do_after(1000, self._check_status)
def _start_slave(self):
self.execute_sql('start slave')
do_after(1000, self._check_status)
def start_server(self):
do_after(5000, self.dashboard_server.activate)
def show(self):
do_after(1, self.edit_traits)
def _update_use_hardware_update(self):
if self.use_hardware_update:
do_after(1000, self._update)
def _status_loop(self):
self.active = not self.active
self.visited = not self.active
self.engine.refresh_all_needed = True
do_after(1000, self._status_loop)
def feeder_slew(self, scalar):
do_after(self.slew_period * 1000, self._slew_inprogress)
self.feeder.slew(scalar)
def feeder_slew(self, scalar):
do_after(self.slew_period * 1000, self._slew_inprogress)
self.feeder.slew(scalar)
def _window_opened(self):
self.debug('window opened')
man = self._get_el_manager()
if man:
do_after(1000, man.activate)
def start_server(self):
do_after(5000, self.dashboard_server.activate)
def open_view(self, obj, **kw):
def _open_():
ui = obj.edit_traits(**kw)
self.add_window(ui)
do_after(1, _open_)
def _refresh_canvas(self):
self.refresh_canvas()
if self._active:
do_after(200, self._refresh_canvas)
def _update_states(self):
self.switch_manager.load_hardware_states()
do_after(self.hardware_update_period * 1000, self._update_states)
def _slew_inprogress(self):
self._update_axes()
if self.feeder.is_slewing() and not self.feeder.is_stalled():
do_after(self.slew_period * 1000, self._slew_inprogress)
def _normal_scan(self, beam_diam, rpwr, steps, step_len, padding):
manager = self.manager
stage_manager = manager.stage_manager
analog_power_meter = manager.analog_power_meter
canvas = self.canvas
canvas.set_parameters(steps, steps)
if hasattr(manager, 'set_beam_diameter'):
'''
synrad co2 does not have auto beam setting
'''
manager.set_beam_diameter(beam_diam)
manager.set_laser_power(rpwr)
xsteps = steps
ysteps = steps
cx = self.center_x
cy = self.center_y
gaussian_power_generator = power_generator(len(xsteps))
stage_manager.stage_controller._set_single_axis_motion_parameters(pdict=dict(key='x', acceleration=2,
deceleration=2,
velocity=1
))
stage_manager.stage_controller._set_single_axis_motion_parameters(pdict=dict(key='y', acceleration=2,
deceleration=2,
velocity=1
))
manager.set_laser_monitor_duration(self.selected.duration)
for j, yi in enumerate(ysteps):
if not self.isAlive():
break
ny = (yi * step_len) + cy
for i, xi in enumerate(xsteps):
if not self.isAlive():
break
nx = (xi * step_len) + cx
stage_manager.stage_controller.linear_move(nx, ny, verbose=False, block=True, grouped_move=False)
if not self.isAlive():
break
if manager.simulation:
mag = gaussian_power_generator.next()
else:
if i == 0:
# sleep for 1.5 nsecs to let the detector cool off.
# usually gets blasted as the laser moves into position
time.sleep(1.5)
mag = 0
for c in range(self.integration):
mag += analog_power_meter.read_power_meter(verbose=False)
time.sleep(0.01)
mag /= self.integration
datum = (i, j, mag)
do_after(1, canvas.set_cell_value, *datum)
self.data_manager.write_to_frame(datum)
if manager.simulation:
time.sleep(0.1)
canvas.request_redraw()
def _discrete_scan(self):
lm = self.parent.laser_manager
sm = lm.stage_manager
canvas = self.canvas
padding = self.padding
step_len = self.step_length
nsteps = int(padding / step_len)
steps = xrange(-nsteps, nsteps + 1)
canvas.set_parameters(steps, steps)
canvas.request_redraw()
xsteps = steps
ysteps = steps
cx = self.center_x
cy = self.center_y
gaussian_power_generator = power_generator(len(xsteps))
dm = self._load_data_manager()
tab = dm.get_table('power_map', '/')
for j, yi in enumerate(ysteps):
if not self.isAlive():
break
ny = (yi * step_len) + cy
for i, xi in enumerate(xsteps):
if not self.isAlive():
break
nx = (xi * step_len) + cx
if not lm.simulation:
sm.linear_move(nx, ny, verbose=False, block=True, grouped_move=False)
if i == 0:
# sleep for 1.5 nsecs to let the detector cool off.
# usually gets blasted as the laser moves into position
time.sleep(1.5)
mag = 0
for _ in range(self.integration):
# mag += analog_power_meter.read_power_meter(verbose=False)
time.sleep(0.01)
mag /= self.integration
else:
mag = gaussian_power_generator.next()
datum = (i, j, mag)
do_after(10, canvas.set_cell_value, *datum)
# self.data_manager.write_to_frame(datum)
#
# write to the table
nr = tab.row
nr['row'] = i
nr['col'] = j
nr['x'] = nx
nr['y'] = ny
nr['power'] = mag
nr.append()
tab.flush()
if lm.simulation:
time.sleep(0.01)
if self.isAlive():
self.parent._save_to_db(dm.get_current_path())
dm.close()
self._alive = False
canvas.request_redraw()
def _refresh_loop(self):
self._refresh()
if self._alive:
do_after(self.ms_period, self._refresh_loop)
def _slew_inprogress(self):
self._update_axes()
if self.feeder.is_slewing() and not self.feeder.is_stalled():
do_after(self.slew_period * 1000, self._slew_inprogress)
def _refresh_canvas(self):
self.refresh_canvas()
if self._active:
do_after(200, self._refresh_canvas)
def _update_position(self):
self._update_stage_position()
if self.feeder.moving():
do_after(250, self._update_position)
def _update_position(self):
self._update_stage_position()
if self.feeder.moving():
do_after(250, self._update_position)
def _update_readback(self):
v = self.read_setpoint(update=True)
self.graph.record(v, track_y=False)
if self._alive:
do_after(self.update_period * 1000, self._update_readback)
def _window_opened(self):
self.debug("window opened")
man = self._get_el_manager()
if man:
do_after(1000, man.activate)
def _fast_scan(self, beam_diam, rpwr, steps, step_len, padding):
from src.graph.graph3D import Graph3D
stage_manager = self.manager.stage_manager
analog_power_meter = self.manager.analog_power_meter
stage_controller = stage_manager.stage_controller
graph = Graph3D()
s = graph.scene
do_after(1, graph.edit_traits)
offset = 1
# nrows should be calculates so result is a square
nrows = int(padding * 2 / offset) + 1
cx = self.center_x
cy = self.center_y
xx = []
yy = []
zz = []
# turn off velocity calculation
for a in stage_controller.axes.itervalues():
a.calculate_parameters = False
stage_controller._set_single_axis_motion_parameters(pdict=dict(key='x', acceleration=2,
deceleration=2,
velocity=1.25
))
stage_controller._set_single_axis_motion_parameters(pdict=dict(key='y', acceleration=2,
deceleration=2,
velocity=1.25
))
for i in range(nrows):
y = cy - padding + i * offset
if i % 2 == 0:
p1 = cx - padding, y
p2 = cx + padding, y
else:
p2 = cx - padding, y
p1 = cx + padding, y
stage_controller.linear_move(p1[0], p1[1], block=True, grouped_move=False)
# wait at the start for a bit to let the detector settle
# time.sleep(0.5)
stage_controller.linear_move(p2[0], p2[1],
block=False, grouped_move=False)
# sleep time required to reach cvt zone
max_len = 50
event = Event()
axkey = 'x'
t = Thread(target=stage_controller.at_velocity, args=(axkey, event))
t.start()
# nvalues = random.randint(0, 0) + max_len
# j = 0
# while j <= nvalues:
xs = []
ys = []
zs = []
while not event.isSet():
# collect power data
x, y = stage_controller.get_xy()
mag = analog_power_meter.read_power_meter() # verbose = False)
# d = j / float(max_len) * 3.3
# d = d if i % 2 == 0 else -d
# x = p1[0] + d
# y = p1[1]
mag = 10 - 0.125 * (x - cx) * (x - cx)
# j += 1
xs.append(x)
ys.append(y)
zs.append(mag)
# sort the lists
data = sorted(zip(xs, ys, zs), key=lambda d:d[0])
xs = [d[0] for d in data]
ys = [d[1] for d in data]
zs = [d[2] for d in data]
# truncate the lists
xs = xs[:max_len]
ys = ys[:max_len]
zs = zs[:max_len]
xx.append(xs)
yy.append(ys)
zz.append(zs)
# do_after(1, s.mlab.plot3d, np.asarray(xs), np.asarray(ys), np.asarray(zs), np.asarray(zs))#, asarray(zz)[0])
# do_after(1, s.mlab.mesh, np.asarray(xx), np.asarray(yy), np.asarray(zz))
# s.mlab.plot3d(np.asarray(xs), np.asarray(ys), np.asarray(zs), np.asarray(zs))#, asarray(zz)[0])
do_after(1, s.mlab.mesh, np.asarray(xx), np.asarray(yy), np.asarray(zz))
def _start_slave(self):
self.execute_sql('start slave')
do_after(1000, self._check_status)
def _refresh_loop(self):
self._refresh()
if self._alive:
do_after(self.ms_period, self._refresh_loop)
def _stop_button_fired(self):
self.execute_sql('stop slave')
do_after(1000, self._check_status)
def _window_opened(self):
man = self._get_el_manager()
if man:
do_after(1000, man.activate)
def _update_states(self):
self.switch_manager.load_hardware_states()
do_after(self.hardware_update_period * 1000, self._update_states)
