def read_results(self, output):
try:
data = numpy.genfromtxt(
self.esf_file, comments="#", dtype={'names': ['energy', 'fpp', 'fp'], 'formats': [float, float, float]}
)
data['energy'] *= 1e-3 # convert back to keV
self.results['esf'] = data
except IOError as e:
logger.error(e)
self.emit('error', 'CHOOH Failed.')
return
# extract MAD wavelengths from output
r = re.compile(
r'\|\s+(?P<label>[^|]+)\s+\|\s+(?P<wavelength>(?P<energy>\d+\.\d+))\s+'
r'\|\s+(?P<fpp>-?\d+\.\d+)\s+\|\s+(?P<fp>-?\d+\.\d+)\s+\|'
)
energies = [m.groupdict() for m in r.finditer(output)]
converters = {
'energy': lambda x: float(x)*1e-3,
'wavelength': lambda x: converter.energy_to_wavelength(float(x)*1e-3),
'fpp': float,
'fp': float,
'label': lambda x: x
}
choices = [
{key: converters[key](value) for key, value in list(dataset.items())}
for dataset in energies
]
if choices:
# select remote energy, maximize f" x delta-f'
infl = choices[1]
sel = self.results['esf']['energy'] < (infl['energy'] + 0.1)
sel &= self.results['esf']['energy'] > (infl['energy'] + 0.05)
fpp = self.results['esf']['fpp'][sel]
fp = self.results['esf']['fp'][sel]
energy = self.results['esf']['energy'][sel]
opt = fpp * (fp - infl['fp'])
opt_i = opt.argmax()
choices.append({
'label': 'remo', 'energy': energy[opt_i], 'fpp': fpp[opt_i], 'fp': fp[opt_i],
'wavelength': converter.energy_to_wavelength(energy[opt_i])
})
# new_output = "Selected Energies for 3-Wavelength MAD data \n"
# new_output +="and corresponding anomalous scattering factors.\n"
# new_output += "+------+------------+----------+--------+--------+\n"
# new_output += "| | wavelength | energy | f'' | f' |\n"
# for choice in choices:
# new_output += '| {label:4s} | {wavelength:10.5f} | {energy:8.5f} | {fpp:6.2f} | {fp:6.2f} |\n'.format(
# **choice
# )
# new_output += "+------+------------+----------+--------+--------+\n"
# with open(self.out_file, 'w') as handle:
# handle.write(new_output)
self.results['choices'] = choices
def acquire(self):
self.count = 0
self.prepare(self.config['params'])
self.watch_frames()
frame = self.config['frame']
# Prepare image header
detector_parameters = {
'file_prefix': frame['dataset'],
'start_frame': frame['first'],
'directory': frame['directory'],
'wavelength': energy_to_wavelength(frame['energy']),
'energy': frame['energy'],
'distance': frame['distance'],
'exposure_time': frame['exposure'],
'num_frames': 1,
'start_angle': frame['start'],
'delta_angle': frame['delta'],
'comments': 'BEAMLINE: {} {}'.format('CLS', self.beamline.name),
}
# perform scan
self.beamline.detector.configure(**detector_parameters)
self.beamline.detector.start(first=True)
self.beamline.goniometer.scan(kind='simple',
time=frame['exposure'],
delta=frame['delta'],
angle=frame['start'],
wait=True,
timeout=frame['exposure'] * 4)
self.beamline.detector.save()
file_path = os.path.join(frame['directory'], self.config['frame_name'])
GLib.timeout_add(1000, self.analyse_frame, file_path)
def run_simple(self):
is_first_frame = True
for wedge in datatools.interleave(*self.config['datasets'].values()):
self.emit('started', wedge)
self.current_wedge = wedge
if self.stopped or self.paused: break
self.prepare_for_wedge(wedge)
for i, frame in enumerate(datatools.generate_frames(wedge)):
if self.stopped or self.paused: break
# Prepare image header
energy = self.beamline.energy.get_position()
detector_parameters = {
'file_prefix':
frame['name'],
'start_frame':
frame['first'],
'directory':
frame['directory'],
'wavelength':
energy_to_wavelength(energy),
'energy':
energy,
'distance':
round(self.beamline.distance.get_position(), 1),
'exposure_time':
frame['exposure'],
'num_frames':
1,
'start_angle':
frame['start'],
'delta_angle':
frame['delta'],
'comments':
'BEAMLINE: {} {}'.format('CLS', self.beamline.name),
}
if self.stopped or self.paused:
break
# perform scan
self.beamline.detector.configure(**detector_parameters)
self.beamline.detector.start(first=is_first_frame)
self.beamline.goniometer.scan(
kind='simple',
time=frame['exposure'],
range=frame['delta'],
angle=frame['start'],
num_frames=1,
wait=True,
)
self.beamline.detector.save()
# calculate progress
wedge_progress = ((i + 1) / wedge['num_frames'])
self.on_progress(None, wedge_progress, '')
is_first_frame = False
time.sleep(0)
def run_shutterless(self):
is_first_frame = True
# Perform scan
for wedge in datatools.interleave(*self.config['datasets'].values()):
self.emit('started', wedge)
self.current_wedge = wedge
if self.stopped or self.paused:
break
self.prepare_for_wedge(wedge)
energy = self.beamline.energy.get_position()
detector_parameters = {
'file_prefix': wedge['name'],
'start_frame': wedge['first'],
'directory': wedge['directory'],
'wavelength': energy_to_wavelength(energy),
'energy': energy,
'distance': round(self.beamline.distance.get_position(), 1),
'two_theta': wedge['two_theta'],
'exposure_time': wedge['exposure'],
'num_frames': wedge['num_frames'],
'start_angle': wedge['start'],
'delta_angle': wedge['delta'],
'comments': 'BEAMLINE: {} {}'.format('CLS',
self.beamline.name),
}
if self.stopped or self.paused:
break
# Perform scan
logger.info(
"Collecting Shutterless {} frames for dataset {}...".format(
wedge['num_frames'], wedge['name']))
logger.debug('Configuring detector for acquisition ...')
self.beamline.detector.configure(**detector_parameters)
self.beamline.detector.start(first=is_first_frame)
logger.debug('Starting scan ...')
self.beamline.goniometer.scan(
kind='shutterless',
time=wedge['exposure'] * wedge['num_frames'],
range=wedge['delta'] * wedge['num_frames'],
angle=wedge['start'],
frames=wedge['num_frames'],
wait=True,
start_pos=wedge.get('p0'),
end_pos=wedge.get('p1'),
)
self.beamline.detector.save()
is_first_frame = False
time.sleep(0)
def acquire_slew(self):
self.count = 0
self.prepare(self.config['params'])
logger.debug('Setting up detector for rastering ... ')
# Prepare detector
params = self.config['params']
detector_parameters = {
'file_prefix': params['name'],
'start_frame': 1,
'directory': params['directory'],
'wavelength': energy_to_wavelength(params['energy']),
'energy': params['energy'],
'distance': params['distance'],
'exposure_time': params['exposure'],
'num_frames': self.total_frames,
'start_angle': params['angle'],
'delta_angle': params['delta'],
'comments': 'BEAMLINE: {} {}'.format('CLS', self.beamline.name),
}
self.beamline.detector.configure(**detector_parameters)
self.beamline.detector.start()
logger.debug('Starting raster scan ...')
# add frames to pending results
template = self.beamline.detector.get_template(
self.config['params']['name'])
self.pending_results = {
os.path.join(self.config['params']['directory'],
template.format(i + 1))
for i in range(params['frames'])
}
self.beamline.goniometer.scan(
kind='raster',
time=params['exposure'] * params['frames'],
range=params['delta'] * params['frames'],
angle=params['angle'],
frames=params['frames'],
lines=params['lines'],
width=params['width'],
height=params['height'],
start_pos=params['grid'][0],
wait=True,
timeout=params['exposure'] * self.total_frames * 3,
)
self.beamline.detector.save()
time.sleep(0)
def acquire_step(self):
self.count = 0
self.prepare(self.config['params'])
logger.debug('Rastering ... ')
for frame in datatools.grid_frames(self.config['params']):
if self.paused:
self.emit('paused', True, '')
while self.paused and not self.stopped:
time.sleep(0.1)
self.emit('paused', False, '')
if self.stopped: break
# Prepare image header
template = self.beamline.detector.get_template(
self.config['params']['name'])
detector_parameters = {
'file_prefix': frame['name'],
'start_frame': frame['first'],
'directory': frame['directory'],
'wavelength': energy_to_wavelength(frame['energy']),
'energy': frame['energy'],
'distance': frame['distance'],
'exposure_time': frame['exposure'],
'num_frames': 1,
'start_angle': frame['start'],
'delta_angle': frame['delta'],
'comments': 'BEAMLINE: {} {}'.format('CLS',
self.beamline.name),
}
# perform scan
if self.stopped or self.paused: break
self.beamline.detector.configure(**detector_parameters)
self.beamline.detector.start()
self.beamline.goniometer.scan(time=frame['exposure'],
range=frame['delta'],
frames=1,
angle=frame['start'],
start_pos=frame['p0'],
wait=True,
timeout=frame['exposure'] * 20)
self.beamline.detector.save()
# Add frame to pending results
file_path = os.path.join(self.config['params']['directory'],
template.format(frame['first']))
self.pending_results.add(file_path)
time.sleep(0)