def process_dataset(self, metadata, flags=(), sample=None):
numbers = datatools.frameset_to_list(metadata['frames'])
filename = os.path.join(metadata['directory'], metadata['filename'].format(numbers[0]))
suffix = 'anom' if 'anomalous' in flags else 'native'
params = {
'uuid': str(uuid.uuid4()),
'title': 'MX analysis in progress ...',
'state': self.manager.State.ACTIVE,
'data': metadata,
'sample_id': metadata['sample_id'],
'name': metadata['name'],
'file_names': [filename],
'anomalous': 'anomalous' in flags,
'activity': 'proc-{}'.format(suffix),
'type': metadata['type'],
}
params = datatools.update_for_sample(params, sample, overwrite=False)
self.manager.add_item(params, False)
try:
report = yield self.beamline.dps.process_mx(params, params['directory'], misc.get_project_name())
except Exception as e:
logger.error('MX analysis failed: {}'.format(str(e)))
self.failed(e, params['uuid'], self.ResultType.MX)
returnValue({})
else:
report['data_id'] = [_f for _f in [metadata.get('id')] if _f]
self.save_report(report)
self.succeeded(report, params['uuid'], self.ResultType.MX)
returnValue(report)
def create_message(self, item):
if item.user == misc.get_project_name():
config = ChatMessageLTR()
else:
config = ChatMessageRTL()
config.set_item(item)
return config.get_widget()
def set_config(self, status=None, avatar=None):
user = misc.get_project_name()
self.config = self.configs.copy()
status = status if status is not None else 1
avatar = avatar if avatar is not None else self.configs.get(user, {}).get('avatar', 0)
self.configs[user] = {'status': status, 'avatar': avatar}
self.set_state(config=self.configs.copy())
def url(self, path):
url_path = path[1:] if path[0] == '/' else path
return '{}/api/v2/{}/{}'.format(
self.address,
self.signer.sign(misc.get_project_name()),
url_path
)
def prepare_for_wedge(self, wedge):
logger.debug('Preparing for new dataset wedge ...')
# setup folder for wedge
self.beamline.dss.setup_folder(wedge['directory'],
misc.get_project_name())
# delete existing frames
frames = [i + wedge['first'] for i in range(wedge['num_frames'])]
self.beamline.detector.delete(wedge['directory'], wedge['name'],
frames)
# make sure shutter is closed before starting
self.beamline.fast_shutter.close()
# setup devices
if abs(self.beamline.energy.get_position() -
wedge['energy']) >= 0.0005:
self.beamline.energy.move_to(wedge['energy'], wait=True)
if abs(self.beamline.distance.get_position() -
wedge['distance']) >= 0.1:
self.beamline.distance.move_to(wedge['distance'], wait=True)
self.beamline.attenuator.set(wedge['attenuation'], wait=True)
logger.debug('Ready for acquisition.')
def set_config(self, status=None, avatar=None):
user = misc.get_project_name()
conf_key = self.conf.format(user)
stat_key = self.stat.format(user)
status = status if status is not None else 1
avatar = avatar if avatar is not None else self.configs.get(user, {}).get('avatar', 0)
# send config
self.server.set(conf_key, json.dumps({'status': status, 'avatar': avatar}))
self.server.publish(stat_key, time.time())
def analyse_frame(self, file_path):
self.pending_results.add(file_path)
logger.info("Analyzing frame: {}".format(file_path))
try:
report = yield self.beamline.dps.analyse_frame(
file_path, misc.get_project_name())
except Exception as e:
self.result_fail(e, file_path)
returnValue({})
else:
self.result_ready(report, file_path)
returnValue(report)
def analyse_frame(self, file_path, index):
frame = os.path.splitext(os.path.basename(file_path))[0]
logger.info("Analyzing frame: {}".format(frame))
try:
report = yield self.beamline.dps.analyse_frame(
file_path, misc.get_project_name())
except Exception as e:
self.result_fail(e, index, file_path)
returnValue({})
else:
self.result_ready(report, index, file_path)
returnValue(report)
def update_configs(self, client, configs):
self.configs = configs
for msg in self.messages:
msg.props.avatar = self.configs.get(msg.user, {}).get('avatar', 0)
user = misc.get_project_name()
current = self.configs.get(user, {}).get('avatar', 0)
child = self.widget.avatar_box.get_child_at_index(current)
self.widget.avatar_box.select_child(child)
# update button icon
specs = Gtk.IconSize.lookup(Gtk.IconSize.BUTTON)
size = (specs.width, specs.height)
self.widget.avatar_icon.set_from_pixbuf(gui.get_symbol(f'user-{current}.svg', 'avatars', size=size))
def configure(self, info):
self.config = copy.deepcopy(info)
self.config['edge_energy'], self.config['roi_energy'] = self.emissions[
info['edge']]
self.config['frame_template'] = '{}-{}_{}.xdi'.format(
info['name'], info['edge'], '{:0>3d}')
self.config['frame_glob'] = '{}-{}_{}.xdi'.format(
info['name'], info['edge'], '*')
self.config['targets'] = scitools.exafs_targets(
self.config['edge_energy'], kmax=info['kmax'])
self.config['user'] = misc.get_project_name()
self.results = {}
if not os.path.exists(self.config['directory']):
os.makedirs(self.config['directory'])
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, host, realm=None):
super().__init__()
self.realm = realm or 'SIM-1'
self.channel = 'CHAT:{}:MSGS:{{}}'.format(self.realm)
self.conf = 'CHAT:CONFIG:{}'
self.stat = 'CHAT:STATUS:{}'
self.key = self.channel.format(misc.get_project_name())
self.server = redis.Redis(host=host, port=6379, db=0)
self.watcher = self.server.pubsub()
self.watcher.psubscribe(**{
self.channel.format('*'): self.get_message,
self.stat.format('*'): self.get_configs,
})
self.watch_thread = self.watcher.run_in_thread(sleep_time=0.01)
self.get_configs()
def process_raster(self, params, flags=(), sample=None):
params.update({
'uuid': str(uuid.uuid4()),
'activity': 'proc-raster',
})
params = datatools.update_for_sample(params, sample, overwrite=False)
try:
report = yield self.beamline.dps.analyse_frame(params['filename'], misc.get_project_name(), rastering=True)
except Exception as e:
logger.error('Raster analysis failed: {}'.format(str(e)))
self.failed(e, params['uuid'], self.ResultType.RASTER)
returnValue({})
else:
report['data_id'] = [_f for _f in [params.get('id')] if _f]
self.succeeded(report, params['uuid'], self.ResultType.RASTER)
returnValue(report)
def prepare(self, params):
# setup folder for
self.beamline.dss.setup_folder(params['directory'],
misc.get_project_name())
logger.debug('Setting up folder: {}'.format(params['directory']))
# make sure shutter is closed before starting
self.beamline.fast_shutter.close()
if abs(self.beamline.distance.get_position() -
params['distance']) >= 0.1:
self.beamline.distance.move_to(params['distance'], wait=True)
# switch to collect mode
img = self.beamline.sample_camera.get_frame()
img.save(
os.path.join(self.config['params']['directory'],
'{}.png'.format(self.config['params']['name'])))
self.beamline.manager.collect(wait=True)
def broadcast_service(self):
self.remote_mxdc = None
self.service_type = '_mxdc._tcp.local.'
self.service_data = {
'user': misc.get_project_name(),
'started': time.asctime(time.localtime()),
'beamline': self.beamline.name
}
unique = 'SIM' not in self.beamline.name # allow multiple SIM instances
self.provider = mdns.Provider(self.beamline.name,
self.service_type,
MXDC_PORT,
self.service_data,
unique=unique)
self.provider.connect('collision', self.server_collision)
self.provider.connect('running', self.start_server)
GLib.idle_add(self.provider.start)
def take_snapshots(self):
if self.config['take_snapshots'] and self.config['datasets']:
names = [
dataset.details['name']
for dataset in self.config['datasets'].values()
]
prefix = os.path.commonprefix(names) or 'SNAPSHOT'
dataset = list(self.config['datasets'].values())[0]
# setup folder
self.beamline.dss.setup_folder(dataset.details['directory'],
misc.get_project_name())
# take snapshot
snapshot_file = os.path.join(dataset.details['directory'],
f'{prefix}.png')
if not os.path.exists(snapshot_file):
logger.info('Taking snapshot ...')
img = self.beamline.sample_camera.get_frame()
img.save(snapshot_file)
def prepare(self, params):
self.beamline.detector_cover.open(wait=True)
self.total_frames = self.config['params']['frames'] * self.config[
'params']['lines']
self.pending_results = set()
self.results = {}
# setup folder for
self.beamline.dss.setup_folder(params['directory'],
misc.get_project_name())
# make sure shutter is closed before starting
self.beamline.fast_shutter.close()
if abs(self.beamline.distance.get_position() -
params['distance']) >= 0.1:
self.beamline.distance.move_to(params['distance'], wait=True)
# switch to collect mode
self.beamline.manager.collect(wait=True)
def process_multiple(self, *metadatas, **kwargs):
sample = kwargs.get('sample', None)
flags = kwargs.get('flags', ())
file_names = []
names = []
for metadata in metadatas:
numbers = datatools.frameset_to_list(metadata['frames'])
file_names.append(os.path.join(metadata['directory'], metadata['filename'].format(numbers[0])))
names.append(metadata['name'])
metadata = metadatas[0]
suffix = 'mad' if 'mad' in flags else 'merge'
params = {
'uuid': str(uuid.uuid4()),
'title': 'MX {} analysis in progress ...'.format(suffix.upper()),
'state': self.manager.State.ACTIVE,
'data': metadata,
'sample_id': metadata['sample_id'],
'name': '-'.join(names),
'file_names': file_names,
'anomalous': 'anomalous' in flags,
'merge': 'merge' in flags,
'mad': 'mad' in flags,
'activity': 'proc-{}'.format(suffix),
'type': metadata['type'],
}
params = datatools.update_for_sample(params, sample, overwrite=False)
self.manager.add_item(params, False)
try:
report = yield self.beamline.dps.process_mx(params, params['directory'], misc.get_project_name())
except Exception as e:
logger.error('MX analysis failed: {}'.format(str(e)))
self.failed(e, params['uuid'], self.ResultType.MX)
returnValue({})
else:
report['data_id'] = [_f for _f in [metadata.get('id') for metadata in metadatas] if _f]
self.save_report(report)
self.succeeded(report, params['uuid'], self.ResultType.MX)
returnValue(report)
def configure(self, **kwargs):
super().configure(**kwargs)
self.config.update(
filename=os.path.join(self.config.directory,
"{}.xdi".format(self.config.name)),
user=misc.get_project_name(),
)
self.data_units['energy'] = 'keV'
names = ['energy', 'normfluor'] + [
'ifluor{}'.format(i + 1) for i in range(self.beamline.mca.elements)
]
self.data_type = {
'names': names,
'formats': ['f4'] * len(names),
}
self.data_scale = [(names[1], )]
self.results = {}
# create directory
if not os.path.exists(self.config['directory']):
os.makedirs(self.config['directory'])
def configure(self, **kwargs):
super().configure(**kwargs)
edge_energy, roi_energy = self.emissions[self.config.edge]
self.config.update(edge_energy=edge_energy,
roi_energy=roi_energy,
positions=scitools.xanes_targets(edge_energy),
user=misc.get_project_name(),
filename=os.path.join(
self.config.directory,
"{}.xdi".format(self.config.name)))
names = ['energy', 'normfluor'] + [
'ifluor{}'.format(i + 1) for i in range(self.beamline.mca.elements)
] + ['i0']
self.data_units['energy'] = 'keV'
self.data_type = {
'names': names,
'formats': ['f4'] * len(names),
}
self.data_scale = [tuple(names[1:-1]), (names[-1], )]
if not os.path.exists(self.config['directory']):
os.makedirs(self.config['directory'])
def __init__(self):
super().__init__()
self.configs = {
'xtalbot': {'status': 1, 'avatar': random.randint(0, 50)},
misc.get_project_name(): {'status': 1, 'avatar': random.randint(0, 50)},
}
def send(self, message):
self.set_state(message=(misc.get_project_name(), message))
GLib.timeout_add(random.randint(2000, 10000), self.bot_reply)
def process_powder(self, metadata, flags=(), sample=None):
file_names = [
os.path.join(metadata['directory'], metadata['filename'].format(number))
for number in datatools.frameset_to_list(metadata['frames'])
]
params = {
'uuid': str(uuid.uuid4()),
'title': 'XRD Analysis in progress ...',
'state': self.manager.State.ACTIVE,
'data': metadata,
'sample_id': metadata['sample_id'],
'name': metadata['name'],
'file_names': file_names,
'calib': 'calibrate' in flags,
'activity': 'proc-xrd',
'type': metadata['type'],
}
params = datatools.update_for_sample(params, sample, overwrite=False)
self.manager.add_item(params, False)
try:
report = yield self.beamline.dps.process_xrd(params, params['directory'], misc.get_project_name())
except Exception as e:
logger.error('XRD analysis failed: {}'.format(str(e)))
self.failed(e, params['uuid'], self.ResultType.XRD)
returnValue({})
else:
report['data_id'] = [_f for _f in [metadata.get('id')] if _f]
self.save_report(report)
self.succeeded(report, params['uuid'], self.ResultType.XRD)
returnValue(report)
