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 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): 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 _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 _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 _window_opened(self): self.debug('window opened') man = self._get_el_manager() if man: do_after(1000, man.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 _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 _window_opened(self): man = self._get_el_manager() if man: do_after(1000, man.activate)