def __init__(self, view, widget):
super().__init__()
self.view = view
self.widget = widget
# housekeeping
self.start_time = 0
self.pause_dialog = None
self.results = {}
self.form = RasterForm(
widget, fields=self.Fields, prefix='raster', persist=True, disabled=('lines', 'frames')
)
self.beamline = Registry.get_utility(IBeamline)
self.microscope = Registry.get_utility(IMicroscope)
self.sample_store = Registry.get_utility(ISampleStore)
self.collector = RasterCollector()
self.manager = RasterResultsManager(self.view, colormap=self.microscope.props.grid_cmap)
# signals
self.microscope.connect('notify::grid-params', self.on_grid_changed)
self.connect('notify::state', self.on_state_changed)
self.beamline.aperture.connect('changed', self.on_aperture)
self.beamline.goniometer.omega.connect('changed', self.on_angle)
self.collector.connect('done', self.on_done)
self.collector.connect('paused', self.on_pause)
self.collector.connect('stopped', self.on_stopped)
self.collector.connect('progress', self.on_progress)
self.collector.connect('started', self.on_started)
self.collector.connect('result', self.on_results)
self.setup()
def __init__(self, widget):
super().__init__()
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.collector = DataCollector()
self.collecting = False
self.stopping = False
self.pause_info = False
self.start_time = 0
self.frame_monitor = None
self.first_frame = True
self.monitors = {}
self.image_viewer = ImageViewer()
self.microscope = Registry.get_utility(IMicroscope)
self.run_editor = datawidget.RunEditor()
self.editor_frame = arrowframe.ArrowFrame()
self.editor_frame.add(self.run_editor.data_form)
self.widget.datasets_overlay.add_overlay(self.editor_frame)
self.run_store = Gio.ListStore(item_type=datawidget.RunItem)
self.run_store.connect('items-changed', self.on_runs_changed)
self.collector.connect('done', self.on_done)
self.collector.connect('paused', self.on_pause)
self.collector.connect('stopped', self.on_stopped)
self.collector.connect('progress', self.on_progress)
self.collector.connect('started', self.on_started)
Registry.add_utility(IDatasets, self)
self.setup()
def __init__(self, view):
super().__init__()
self.view = view
self.beamline = Registry.get_utility(IBeamline)
self.sample_store = Registry.get_utility(ISampleStore)
self.model = self.sample_store.sort_model
self.auto_queue = self.model.filter_new()
self.auto_queue.set_visible_func(self.queued_data)
self.view.set_model(self.auto_queue)
self.setup()
def __init__(self, widget):
super().__init__()
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.sample_store = Registry.get_utility(ISampleStore)
self.collector = SingleCollector()
self.form = gui.FormManager(self,
fields=self.Fields,
prefix=self.prefix,
persist=True)
self.humidifier = self.beamline.humidifier
self.labels = {}
self.limits = {}
self.formats = {}
self.entries = {}
self.diff_devices = {
'cell':
SimPositioner('Max Cell Dimension',
pos=numpy.nan,
delay=False,
noise=0),
'score':
SimPositioner('Diffraction Score',
pos=numpy.nan,
delay=False,
noise=0),
'resolution':
SimPositioner('Diffraction Resolution',
pos=numpy.nan,
delay=False,
noise=0),
}
self.plotter = ticker.ChartManager(interval=500, view=240)
self.setup()
self.humidifier.connect('active', self.activate)
self.collector.connect('done', self.on_collector_done)
self.collector.connect('result', self.on_collector_result)
self.humidity_diff_btn.connect('clicked', self.on_collect)
self.plot_options = {
'cell': self.humidity_cell_option,
'drop': self.humidity_drop_option,
'score': self.humidity_score_option,
'resolution': self.humidity_resolution_option
}
for key, option in list(self.plot_options.items()):
option.connect('toggled', self.on_plot_option)
def configure(self, method='loop'):
from mxdc.controllers.samplestore import ISampleStore
from mxdc.engines.rastering import IRasterCollector
self.sample_store = Registry.get_utility(ISampleStore)
self.collector = Registry.get_utility(IRasterCollector)
self.device = Registry.get_utility(ICenter)
if method in self.methods:
self.method = self.methods[method]
elif self.device:
self.method = self.center_external()
else:
self.method = self.center_loop
def __init__(self, widget, store):
super().__init__()
self.widget = widget
self.store = store
self.beamline = Registry.get_utility(IBeamline)
self.setup()
self.failure_dialog = None
self.messages = [(None, "")]
self.props.layout = {}
self.props.ports = {}
self.props.containers = []
self.beamline.automounter.connect('status', self.on_state_changed)
self.beamline.automounter.connect('ports', self.on_layout_changed)
self.beamline.automounter.connect('layout', self.on_layout_changed)
self.beamline.automounter.connect('containers', self.on_layout_changed)
self.beamline.automounter.connect('sample', self.on_layout_changed)
self.beamline.automounter.connect('failure', self.on_failure_changed)
self.store.connect('notify::ports', self.on_layout_changed)
self.store.connect('notify::containers', self.on_layout_changed)
self.beamline.automounter.connect('active', self.on_state_changed)
self.beamline.automounter.connect('busy', self.on_state_changed)
self.beamline.automounter.connect('health', self.on_state_changed)
self.beamline.automounter.connect('message', self.on_messages)
def __init__(self):
super().__init__()
self.pause_message = ''
self.total = 1
self.collector = Registry.get_utility(IDataCollector)
self.centering = centering.Centering()
def use_strategy(self, *args, **kwargs):
strategy = self.reports.strategy
dataset_controller = Registry.get_utility(IDatasets)
if strategy:
default_rate = self.beamline.config[
'default_delta'] / self.beamline.config['default_exposure']
exposure_rate = strategy.get('exposure_rate', default_rate)
max_delta = strategy.get('max_delta',
self.beamline.config['default_delta'])
run = {
'attenuation': strategy.get('attenuation', 0.0),
'start': strategy.get('start_angle', 0.0),
'range': strategy.get('total_angle', 180),
'resolution': strategy.get('resolution', 2.0),
'exposure': max_delta / exposure_rate,
'delta': max_delta,
'name': 'data',
}
dataset_controller.add_runs([run])
data_page = self.widget.main_stack.get_child_by_name('Data')
self.widget.main_stack.child_set(data_page, needs_attention=True)
self.widget.notifier.notify(
"Datasets added. Switch to Data page to proceed.")
def _scan_sync(self):
self.set_state(message='Scanning ...', busy=True)
with self._lock:
self._scanning = True
bl = Registry.get_utility(IBeamline)
config = self.omega.get_config()
logger.debug('Starting scan at: %s' % datetime.now().isoformat())
logger.debug('Moving to scan starting position')
bl.fast_shutter.open()
self.omega.move_to(self.settings['angle'] - 0.05, wait=True)
scan_speed = float(self.settings['range']) / self.settings['time']
self.omega.configure(speed=scan_speed)
self.trigger_index = 0
self.trigger_positions = numpy.arange(
self.settings['angle'],
self.settings['angle'] + self.settings['range'],
self.settings['range'] / self.settings.get('frames', 1))
if self.supports(GonioFeatures.TRIGGERING):
GLib.idle_add(self.send_triggers)
self.omega.move_to(self.settings['angle'] +
self.settings['range'] + 0.05,
wait=True)
bl.fast_shutter.close()
self.omega.configure(speed=config['speed'])
logger.debug('Scan done at: %s' % datetime.now().isoformat())
self.set_state(message='Scan complete!', busy=False)
self._scanning = False
def __init__(self):
super().__init__()
self.pending_results = set()
self.runs = []
self.results = {}
self.config = {}
self.total_frames = 0
self.count = 0
self.analyst = Registry.get_utility(IAnalyst)
def __init__(self, widget):
super().__init__()
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.sample_store = None
self.reports = ReportManager(self.widget.proc_reports_view)
self.analyst = Analyst(self.reports)
self.browser = WebKit2.WebView()
self.options = {}
self.setup()
def __init__(self, widget):
super().__init__()
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.cryojet = self.beamline.cryojet
self.stopped = True
self.labels = {}
self.limits = {}
self.formats = {}
self.setup()
self._animation = GdkPixbuf.PixbufAnimation.new_from_resource("/org/mxdc/data/active_stop.gif")
def __init__(self, view, widget):
super().__init__()
self.model = Gtk.ListStore(*self.Data.TYPES)
self.search_model = self.model.filter_new()
self.search_model.set_visible_func(self.search_data)
self.sort_model = Gtk.TreeModelSort(model=self.search_model)
self.group_model = Gio.ListStore(item_type=GroupItem)
self.group_registry = {}
self.prefetch_pending = False
self.initializing = True
# initialize properties
self.props.next_sample = {}
self.props.current_sample = {}
self.props.ports = set()
self.props.containers = set()
cache = load_cache('samples')
self.props.cache = set() if not cache else set(cache)
self.filter_text = ''
self.view = view
self.widget = widget
self.view.set_model(self.sort_model)
self.beamline = Registry.get_utility(IBeamline)
self.setup()
self.model.connect('row-changed', self.on_sample_row_changed)
self.widget.samples_selectall_btn.connect('clicked',
self.on_select_all)
self.widget.samples_selectnone_btn.connect('clicked',
self.on_unselect_all)
self.view.connect('key-press-event', self.on_key_press)
self.widget.samples_reload_btn.connect('clicked',
lambda x: self.import_mxlive())
self.beamline.automounter.connect('sample', self.on_sample_mounted)
self.beamline.automounter.connect('next-port', self.on_prefetched)
self.beamline.automounter.connect('ports', self.update_states)
self.widget.samples_mount_btn.connect('clicked',
lambda x: self.mount_action())
self.widget.samples_dismount_btn.connect(
'clicked', lambda x: self.dismount_action())
self.widget.samples_search_entry.connect('search-changed',
self.on_search)
self.widget.mxdc_main.connect('realize', self.import_mxlive)
self.connect('notify::cache', self.on_cache)
self.connect('notify::current-sample', self.on_cur_changed)
self.connect('notify::next-sample', self.on_next_changed)
Registry.add_utility(ISampleStore, self)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# update converters based on beamline configuration
self.beamline = Registry.get_utility(IBeamline)
self.fields['energy'].set_converter(
Validator.Float(*self.beamline.config['energy_range'], self.beamline.config['default_energy'])
)
self.fields['distance'].set_converter(
Validator.Float(*self.beamline.config['distance_limits'], self.beamline.config['default_distance'])
)
self.exposure_rate = 1.
def __init__(self):
self.setup_gui()
self.beamline = Registry.get_utility(IBeamline)
self.points = Gtk.ListStore(int, str, object)
self.form = DataForm(self, fields=self.Fields, prefix='data', persist=False, disabled=self.disabled)
self.new_run = True
self.run_index = 0
self.item = None
self.item_links = []
self.handlers = {}
self.build_gui()
self.exposure_rate = 1.0
self.dir_template_btn.connect('clicked', self.on_dir_template)
def __init__(self, widget):
super().__init__()
self.widget = widget
self.props.ports = {}
self.props.containers = {}
self.beamline = Registry.get_utility(IBeamline)
self.microscope = microscope.Microscope(self.widget)
self.cryo_tool = cryo.CryoController(self.widget)
self.sample_dewar = automounter.DewarController(self.widget, self)
self.sample_dewar.connect('selected', self.on_dewar_selected)
self.beamline.automounter.connect('sample', self.on_sample_mounted)
self.setup()
def __init__(self, widget):
super().__init__()
self.init_start = time.time()
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.microscope = microscope.Microscope(self.widget)
self.cryo_tool = cryo.CryoController(self.widget)
self.sample_store = samplestore.SampleStore(self.widget.samples_list,
self.widget)
if hasattr(self.beamline, 'humidifier'):
self.humidity_controller = humidity.HumidityController(self.widget)
self.raster_tool = rastering.RasterController(self.widget.raster_list,
self.widget)
self.beamline.automounter.connect('sample', self.on_sample_mounted)
self.setup()
def __init__(self):
super().__init__()
self.pending_results = set()
self.runs = []
self.results = {}
self.config = {}
self.total_frames = 0
self.count = 0
self.analyst = Registry.get_utility(IAnalyst)
self.analysis_link = self.beamline.detector.connect(
'progress', self.on_frame_collected)
self.unwatch_frames()
Registry.add_utility(IRasterCollector, self)
def __init__(self, widget):
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.messages = Gio.ListStore(item_type=Message)
self.configs = {}
self.add_avatars()
self.widget.chat_messages.bind_model(self.messages, self.create_message)
self.widget.chat_user_fbk.set_text(misc.get_project_name().upper())
self.widget.avatar_box.connect('child-activated', self.select_avatar)
self.widget.chat_config_btn.set_popover(self.widget.chat_avatars_pop)
self.widget.chat_msg_entry.connect('activate', self.send_message)
self.widget.chat_messages.connect('size-allocate', self.adjust_view)
self.beamline.messenger.connect('message', self.show_message)
self.beamline.messenger.connect('config', self.update_configs)
self.configs = {}
def __init__(self, widget):
super().__init__()
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.sample_store = Registry.get_utility(ISampleStore)
self.plotter = plotter.Plotter(xformat='%g', dpi=90)
min_energy, max_energy = self.beamline.config['energy_range']
self.edge_selector = periodictable.EdgeSelector(
min_energy=min_energy,
max_energy=max_energy,
xrf_offset=self.beamline.config['xrf_energy_offset'])
self.xrf_scanner = XRFScanController(XRFScan(), self.plotter, widget,
self.edge_selector)
self.xas_scanner = XASScanController(XASScan(), self.plotter, widget,
self.edge_selector)
self.mad_scanner = MADScanController(MADScan(), self.plotter, widget,
self.edge_selector)
# connect scanners
self.status_monitor = common.StatusMonitor(
self.widget,
devices=(self.mad_scanner.scanner, self.xas_scanner.scanner,
self.xrf_scanner.scanner))
self.setup()
def __init__(self):
super().__init__()
self.run_list = []
self.runs = []
self.results = []
self.config = {}
self.total = 1
self.current_wedge = None
self.analyst = Registry.get_utility(IAnalyst)
self.progress_link = self.beamline.detector.connect(
'progress', self.on_progress)
self.unwatch_frames()
#self.beamline.synchrotron.connect('ready', self.on_beam_change)
Registry.add_utility(IDataCollector, self)
def on_result_activated(self, view, path, column=None):
itr = self.manager.model.get_iter(path)
item = self.manager.get_item(itr)
if self.manager.model.iter_has_child(itr):
self.beamline.goniometer.omega.move_to(item['angle'], wait=True)
grid = self.results[item['uuid']]
self.microscope.load_grid(
grid['grid'],
{'origin': grid['config']['origin'], 'angle': grid['config']['angle']},
grid['scores']
)
self.widget.dsets_dir_fbk.set_text(grid['config']['directory'])
else:
image_viewer = Registry.get_utility(IImageViewer)
self.beamline.goniometer.stage.move_xyz(item['x_pos'], item['y_pos'], item['z_pos'])
image_viewer.open_frame(item['filename'])
def __init__(self):
super().__init__()
self.name = misc.normalize_name(self.__class__.__name__)
self.config = misc.DotDict({})
# data variables
self.data = None
self.data_units = {}
self.raw_data = []
self.data_row = []
self.data_ids = {}
self.data_type = {}
self.data_scale = []
self.extending = False
self.plotter = Registry.get_utility(IScanPlotter)
if self.plotter:
self.plotter.link_scan(self)
def __init__(self, widget):
super().__init__()
self.timeout_id = None
self.max_fps = 20
self.fps_update = 0
self.video_ready = False
self.queue_overlay()
self.overlay_surface = None
self.overlay_ctx = None
self.props.grid = None
self.props.grid_xyz = None
self.props.points = []
self.props.grid_bbox = []
self.props.grid_scores = {}
self.props.grid_params = {}
self.props.grid_state = self.GridState.PENDING
self.props.grid_cmap = colors.ColorMapper(min_val=0, max_val=100)
self.props.tool = self.ToolState.DEFAULT
self.prev_tool = self.tool
self.tool_cursors = {
self.ToolState.DEFAULT:
None,
self.ToolState.CENTERING:
Gdk.Cursor.new_from_name(Gdk.Display.get_default(), 'pointer'),
self.ToolState.GRID:
Gdk.Cursor.new_from_name(Gdk.Display.get_default(), 'cell'),
self.ToolState.MEASUREMENT:
Gdk.Cursor.new_from_name(Gdk.Display.get_default(), 'crosshair'),
}
self.ruler_box = numpy.array([[0, 0], [0, 0]])
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.camera = self.beamline.sample_video
self.centering = centering.Centering()
self.setup()
Registry.add_utility(IMicroscope, self)
self.load_from_cache()
def __init__(self, scanner, plotter, widget, edge_selector):
super().__init__()
self.widget = widget
self.plotter = plotter
self.scanner = scanner
self.form = FormManager(self.widget,
fields=self.Fields,
prefix=self.prefix,
persist=True,
disabled=self.disabled)
self.edge_selector = edge_selector
self.sample_store = Registry.get_utility(ISampleStore)
self.pause_dialog = None
self.start_time = 0
self.scan = None
self.scan_links = []
self.results = self.result_class(self.results_view)
self.setup()
def import_metafile(self, *args, **kwargs):
filters = [
('MxDC Meta-File', ["*.meta"]),
('AutoProcess Meta-File', ["*.json"]),
]
directory = os.path.join(misc.get_project_home(),
settings.get_session())
filename, filter = dialogs.select_opensave_file(
'Select Meta-File',
Gtk.FileChooserAction.OPEN,
parent=dialogs.MAIN_WINDOW,
filters=filters,
default_folder=directory)
self.sample_store = Registry.get_utility(ISampleStore)
if not filename:
return
if filter.get_name() == filters[0][0]:
data = misc.load_metadata(filename)
if data.get('type') in ['DATA', 'SCREEN', 'XRD']:
if data.get('sample_id'):
row = self.sample_store.find_by_id(data['sample_id'])
sample = {} if not row else row[
self.sample_store.Data.DATA]
else:
sample = {}
params = {
'title': '',
'state': self.reports.State.PENDING,
'data': data,
'sample_id': data['sample_id'],
'sample': sample,
'name': data['name'],
'type': data['type'],
'directory': data['directory'],
'activity': data['type'].replace('_', '-').lower()
}
self.reports.add_item(params)
else:
self.widget.notifier.notify(
'Only MX or XRD Meta-Files can be imported')
def setup(self):
self.widget.datasets_list.bind_model(self.run_store, self.create_run_config)
self.widget.datasets_viewer_box.add(self.image_viewer)
self.widget.datasets_clean_btn.connect('clicked', self.on_clean_runs)
self.widget.datasets_list.connect('row-activated', self.on_row_activated)
self.widget.dsets_dir_btn.connect('clicked', self.open_terminal)
self.run_editor.data_delete_btn.connect('clicked', self.on_delete_run)
self.run_editor.data_copy_btn.connect('clicked', self.on_copy_run)
self.run_editor.data_save_btn.connect('clicked', self.on_save_run)
self.sample_store = Registry.get_utility(ISampleStore)
self.sample_store.connect('updated', self.on_sample_updated)
self.import_from_cache()
new_item = datawidget.RunItem(state=datawidget.RunItem.StateType.ADD)
pos = self.run_store.insert_sorted(new_item, datawidget.RunItem.sorter)
self.run_editor.set_item(new_item)
first_row = self.widget.datasets_list.get_row_at_index(pos)
self.editor_frame.set_row(first_row)
labels = {
'omega': (self.beamline.goniometer.omega, self.widget.dsets_omega_fbk, '{:0.1f}°'),
'energy': (self.beamline.energy, self.widget.dsets_energy_fbk, '{:0.3f} keV'),
'attenuation': (self.beamline.attenuator, self.widget.dsets_attenuation_fbk, '{:0.0f} %'),
'maxres': (self.beamline.maxres, self.widget.dsets_maxres_fbk, '{:0.2f} Å'),
'aperture': (self.beamline.aperture, self.widget.dsets_aperture_fbk, '{:0.0f} µm'),
'two_theta': (self.beamline.two_theta, self.widget.dsets_2theta_fbk, '{:0.0f}°'),
}
self.group_selectors = []
self.monitors = {
name: common.DeviceMonitor(dev, lbl, fmt)
for name, (dev, lbl, fmt) in list(labels.items())
}
self.widget.datasets_collect_btn.connect('clicked', self.on_collect_btn)
self.microscope.connect('notify::points', self.on_points)
self.frame_monitor = self.beamline.detector.connect('new-image', self.on_new_image)
def setup(self):
# zoom
low, med, high = self.beamline.config['zoom_levels']
self.widget.microscope_zoomout_btn.connect('clicked', self.on_zoom,
low)
self.widget.microscope_zoom100_btn.connect('clicked', self.on_zoom,
med)
self.widget.microscope_zoomin_btn.connect('clicked', self.on_zoom,
high)
# rotate sample
self.widget.microscope_ccw90_btn.connect('clicked', self.on_rotate,
-90)
self.widget.microscope_cw90_btn.connect('clicked', self.on_rotate, 90)
self.widget.microscope_rot180_btn.connect('clicked', self.on_rotate,
180)
# centering
self.widget.microscope_loop_btn.connect('clicked', self.on_auto_center,
'loop')
self.widget.microscope_capillary_btn.connect('clicked',
self.on_auto_center,
'capillary')
self.widget.microscope_diff_btn.connect('clicked', self.on_auto_center,
'diffraction')
self.widget.microscope_ai_btn.connect('clicked', self.on_auto_center,
'external')
self.beamline.manager.connect('mode', self.on_gonio_mode)
self.beamline.goniometer.stage.connect('changed', self.update_grid)
self.beamline.sample_zoom.connect('changed', self.update_grid)
self.beamline.aperture.connect('changed', self.on_aperture)
# Video Area
self.video = VideoWidget(self.camera)
self.beamline.camera_scale.connect('changed', self.on_camera_scale)
self.widget.microscope_video_frame.add(self.video)
# status, save, etc
self.widget.microscope_save_btn.connect('clicked', self.on_save)
self.widget.microscope_grid_btn.connect('toggled',
self.toggle_grid_mode)
self.widget.microscope_colorize_tbtn.connect('toggled', self.colorize)
self.widget.microscope_point_btn.connect('clicked', self.on_save_point)
self.widget.microscope_clear_btn.connect('clicked', self.clear_objects)
# disable centering buttons on click
self.centering.connect('started', self.on_scripts_started)
self.centering.connect('done', self.on_scripts_done)
aicenter = Registry.get_utility(ICenter)
self.widget.microscope_ai_btn.set_sensitive(False)
if aicenter:
aicenter.connect(
'active', lambda obj, state: self.widget.microscope_ai_btn.
set_sensitive(state))
# lighting monitors
self.monitors = []
for key in ['backlight', 'frontlight', 'uvlight']:
light = getattr(self.beamline, 'sample_{}'.format(key), None)
scale = getattr(self.widget, 'microscope_{}_scale'.format(key),
None)
box = getattr(self.widget, '{}_box'.format(key), None)
if all([light, scale, box]):
scale.set_adjustment(
Gtk.Adjustment(0, 0.0, 100.0, 1.0, 1.0, 10))
self.monitors.append(common.ScaleMonitor(scale, light), )
box.set_sensitive(True)
else:
box.destroy()
if key == 'uvlight':
color = Gdk.RGBA()
color.parse("#9B59B6")
box.override_color(Gtk.StateFlags.NORMAL, color)
self.video.connect('motion-notify-event', self.on_mouse_motion)
self.video.connect('scroll-event', self.on_mouse_scroll)
self.video.connect('button-press-event', self.on_mouse_press)
self.video.connect('button-release-event', self.on_mouse_release)
self.video.set_overlay_func(self.overlay_function)
self.video.connect('configure-event', self.setup_grid)
self.scripts = get_scripts()
# Connect Grid signals
self.connect('notify::grid-xyz', self.update_grid)
self.connect('notify::tool', self.on_tool_changed)
def __init__(self, widget):
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.scripts = get_scripts()
self.hutch_viewer = None
self.setup()
def __init__(self, manager):
super().__init__()
self.manager = manager
self.beamline = Registry.get_utility(IBeamline)
Registry.add_utility(IAnalyst, self)