def start_raster(self, *args, **kwargs):
if self.props.state == self.StateType.ACTIVE:
self.widget.raster_progress_lbl.set_text("Pausing raster ...")
self.collector.pause()
elif self.props.state == self.StateType.PAUSED:
self.widget.raster_progress_lbl.set_text("Resuming raster ...")
self.collector.resume()
elif self.props.state == self.StateType.READY:
self.widget.raster_progress_lbl.set_text("Starting raster ...")
params = {
'name': datetime.now().strftime('%y%m%d-%H%M'),
'uuid': str(uuid.uuid4()),
'activity': 'raster',
'energy': self.beamline.energy.get_position(),
'delta': RASTER_DELTA,
'attenuation': self.beamline.attenuator.get(),
}
params.update(self.microscope.grid_params)
params.update(self.form.get_values())
params.update({
'distance': resol_to_dist(params['resolution'], self.beamline.detector.mm_size, params['energy']),
'origin': self.beamline.goniometer.stage.get_xyz(),
})
params = datatools.update_for_sample(params, self.sample_store.get_current())
self.collector.configure(params)
self.collector.start()
def take_snapshot(self):
params = self.form.get_values()
params['angle'] = self.beamline.goniometer.omega.get_position()
params['energy'] = self.beamline.energy.get_position()
params['distance'] = resol_to_dist(params['resolution'],
self.beamline.detector.mm_size,
params['energy'])
params['attenuation'] = self.beamline.attenuator.get()
params['delta'] = 1.0
params['uuid'] = str(uuid.uuid4())
params['name'] = datetime.now().strftime('%y%m%d-%H%M%S')
params['activity'] = 'humidity'
params = datatools.update_for_sample(params,
self.sample_store.get_current())
self.collector.configure(params)
self.collector.start()
def configure(self, info):
info['frames'] = datatools.count_frames(info)
info['distance'] = converter.resol_to_dist(info['resolution'], self.beamline.detector.mm_size, info['energy'])
min_res = converter.dist_to_resol(
self.beamline.config['distance_limits'][0], self.beamline.detector.mm_size, info['energy']
)
max_res = converter.dist_to_resol(
self.beamline.config['distance_limits'][1], self.beamline.detector.mm_size, info['energy']
)
self.form.fields['resolution'].set_converter(
Validator.Float(min_res, max_res, default=2.0)
)
defaults = self.get_default(info['strategy'])
defaults.update(info)
self.form.set_values(info)
# disable/enable inverse field
inverse = self.form.get_field('inverse')
strategy = self.form.get_value('strategy')
inverse.set_sensitive((strategy == StrategyType.FULL and 'inverse' not in self.disabled))
def move_operation(self, target):
dist_target = converter.resol_to_dist(target, self.detector_size,
self.energy.get_position())
self.distance.move_operation(dist_target)
def center_diffraction(self):
self.center_loop(3, 1)
scores = []
if self.score < 0.5:
logger.error('Loop-centering failed, aborting!')
return
scores.append(self.score)
aperture = self.beamline.aperture.get()
resolution = RASTER_RESOLUTION
energy = self.beamline.energy.get_position()
for step in ['edge', 'face']:
logger.info('Performing raster scan on {}'.format(step))
self.beamline.goniometer.wait(start=False)
if step == 'face':
self.beamline.goniometer.omega.move_by(-90, wait=True)
time.sleep(2.0)
params = {
'name':
datetime.now().strftime('%y%m%d-%H%M'),
'uuid':
str(uuid.uuid4()),
'activity':
'raster',
'energy':
energy,
'delta':
RASTER_DELTA,
'exposure':
RASTER_EXPOSURE,
'attenuation':
self.beamline.attenuator.get(),
'aperture':
aperture,
'distance':
converter.resol_to_dist(resolution,
self.beamline.detector.mm_size,
energy),
'origin':
self.beamline.goniometer.stage.get_xyz(),
'resolution':
resolution,
}
if step == 'edge':
params.update({
'angle':
self.beamline.goniometer.omega.get_position(),
'width':
min(aperture * 5, 200.0),
'height':
min(aperture * 5, 200.0),
'frames':
5,
'lines':
5,
})
else:
params.update({
'angle':
self.beamline.goniometer.omega.get_position(),
'width':
min(aperture * 4, 200.0),
'height':
min(aperture * 4, 200.0),
'frames':
4,
'lines':
4,
})
params = datatools.update_for_sample(
params, self.sample_store.get_current())
logger.info('Finding best diffraction spot in grid')
self.collector.configure(params)
self.collector.run()
grid_scores = numpy.array([
(index, misc.frame_score(report))
for index, report in sorted(self.collector.results.items())
])
best = grid_scores[:, 1].argmax()
index = int(grid_scores[best, 0])
score = grid_scores[best, 1]
logger.info(f'Best diffraction at {index}: score={score}')
grid = self.collector.get_grid()
point = grid[best]
self.beamline.goniometer.stage.move_xyz(point[0],
point[1],
point[2],
wait=True)
scores.append(score / 100.)
self.score = numpy.mean(scores)
def on_change(self, field, event, name):
super().on_change(field, event, name)
if name == 'delta':
delta = self.get_value('delta')
exposure = delta / self.exposure_rate
self.set_value('exposure', exposure)
elif name == 'exposure':
exposure = self.get_value('exposure')
delta = self.get_value('delta')
self.exposure_rate = delta / exposure
elif name == 'energy':
# calculate resolution limits based on energy
energy = self.get_value('energy')
resolution = self.get_value('resolution')
min_res = converter.dist_to_resol(
self.beamline.config['distance_limits'][0], self.beamline.detector.mm_size, energy
)
max_res = converter.dist_to_resol(
self.beamline.config['distance_limits'][1], self.beamline.detector.mm_size, energy
)
self.fields['resolution'].set_converter(
Validator.Float(min_res, max_res, default=2.0)
)
resolution = converter.dist_to_resol(self.get_value('distance'), self.beamline.detector.mm_size, energy)
self.set_value('resolution', resolution)
if name == 'resolution':
resolution = self.get_value('resolution')
energy = self.get_value('energy')
distance = converter.resol_to_dist(resolution, self.beamline.detector.mm_size, energy)
self.set_value('distance', distance)
if name == 'strategy':
strategy = self.get_value('strategy')
defaults = Strategy.get(strategy)
default_rate = self.beamline.config['default_delta'] / float(self.beamline.config['default_exposure'])
if 'delta' in defaults and 'exposure' not in defaults:
defaults['exposure'] = defaults['delta'] / default_rate
elif 'exposure' in defaults and 'delta' not in defaults:
defaults['delta'] = default_rate / defaults['exposure']
self.exposure_rate = default_rate
inverse = self.get_field('inverse')
inverse.set_sensitive((strategy == StrategyType.FULL and 'inverse' not in self.disabled))
self.set_values(defaults)
if name == 'inverse':
inverse = self.get_value('inverse')
if inverse:
self.set_value('range', min(180., self.get_value('range')))
if name in ['delta', 'strategy', 'range', 'inverse']:
range = self.get_value('range')
inverse = self.get_value('inverse')
if inverse:
range = min(180., range)
self.set_value('range', range)
strategy = self.get_value('strategy')
delta = self.get_value('delta')
first = self.get_value('first')
skip = calculate_skip(strategy, range, delta, first)
frames = datatools.calc_num_frames(strategy, delta, range, skip=skip)
self.set_value('frames', frames)