def accept(self):
try:
self.plot_map()
super(XasDialog, self).accept()
except NeXusError as error:
report_error("Plot Single XAS", error)
super(XasDialog, self).reject()
def accept(self):
try:
home_directory = self.get_directory()
experiment_directory = os.path.join(
home_directory, self.parameters['experiment'].value)
if not os.path.exists(experiment_directory):
os.makedirs(experiment_directory)
self.mainwindow.default_directory = experiment_directory
configuration_directory = os.path.join(experiment_directory,
'configurations')
if not os.path.exists(configuration_directory):
os.makedirs(configuration_directory)
task_directory = os.path.join(experiment_directory, 'tasks')
if not os.path.exists(task_directory):
os.makedirs(task_directory)
nxdb = NXDatabase(os.path.join(task_directory, 'nxdatabase.db'))
calibration_directory = os.path.join(experiment_directory,
'calibrations')
if not os.path.exists(calibration_directory):
os.makedirs(calibration_directory)
script_directory = os.path.join(experiment_directory, 'scripts')
if not os.path.exists(script_directory):
os.makedirs(script_directory)
super().accept()
except Exception as error:
report_error("Defining New Experiment", error)
def accept(self):
try:
self.save_map()
super(MapDialog, self).accept()
except NeXusError as error:
report_error("Converting 2D map", error)
super(MapDialog, self).reject()
def plot_lattice(self):
try:
self.get_parameters()
self.plot_peaks(self.refine.xp, self.refine.yp)
polar_min, polar_max = plotview.xaxis.get_limits()
self.plot_rings(polar_max)
except NeXusError as error:
report_error('Plotting Lattice', error)
def accept(self):
try:
self.write_parameters()
self.refine.prepare_transform(self.get_output_file())
self.refine.write_settings(self.get_settings_file())
super(TransformDialog, self).accept()
except NeXusError as error:
report_error("Preparing Data Transform", error)
def plot_lattice(self):
try:
self.get_parameters()
self.plot_peaks(self.refine.xp, self.refine.yp)
polar_min, polar_max = plotview.xaxis.get_limits()
self.plot_rings(polar_max)
except NeXusError as error:
report_error('Plotting Lattice', error)
def accept(self):
try:
home_directory = self.get_directory()
self.get_parameters()
self.experiment_file.save(os.path.join(home_directory, experiment+'.nxs'))
self.treeview.tree.load(self.experiment_file.nxfilename, 'rw')
super(ExperimentDialog, self).accept()
except NeXusError as error:
report_error("Defining New Experiment", error)
def accept(self):
try:
filename = QtGui.QFileDialog.getSaveFileName(
self, "Export File", "data.xas", filter="xas (*.xas *.)")
export_data.export_xas(self.xas, filename)
super(ExpDialog, self).accept()
except NeXusError as error:
report_error("Export Averaged XAS Scans", error)
super(ExpDialog, self).reject()
def write_parameters(self):
try:
self.get_parameters()
polar_angles, azimuthal_angles = self.refine.calculate_angles(
self.refine.xp, self.refine.yp)
self.refine.write_angles(polar_angles, azimuthal_angles)
self.refine.write_parameters()
except NeXusError as error:
report_error('Calculating Angles', error)
def write_parameters(self):
try:
self.get_parameters()
polar_angles, azimuthal_angles = self.refine.calculate_angles(
self.refine.xp, self.refine.yp)
self.refine.write_angles(polar_angles, azimuthal_angles)
self.refine.write_parameters()
except NeXusError as error:
report_error("Calculating Angles", error)
def accept(self):
try:
if 'transform' in self.entry and not self.overwrite:
self.display_message(
"Preparing Transform",
f"Transform group already exists in {self.entry.nxname}")
return
if (self.mask and 'masked_transform' in self.entry
and not self.overwrite):
self.display_message(
"Preparing Transform",
"Masked transform group already exists in "
f"{self.entry.nxname}")
return
output_file = self.get_output_file()
settings_file = self.get_settings_file()
self.write_parameters(output_file, settings_file)
self.refine.prepare_transform(output_file)
if self.mask:
masked_output_file = self.get_output_file(mask=True)
self.refine.prepare_transform(masked_output_file, mask=True)
self.refine.write_settings(settings_file)
if self.copy:
root = self.entry.nxroot
for entry in [
e for e in root
if e != 'entry' and e != self.entry.nxname
]:
if 'transform' in root[entry] and not self.overwrite:
self.display_message(
"Preparing Transform",
f"Transform group already exists in {entry}")
return
if (self.mask and 'masked_transform' in root[entry]
and not self.overwrite):
self.display_message(
"Preparing Transform",
f"Masked transform group already exists in {entry}"
)
return
self.refine = NXRefine(root[entry])
output_file = self.get_output_file(entry=root[entry])
settings_file = self.get_settings_file(entry=root[entry])
self.write_parameters(output_file, settings_file)
self.refine.prepare_transform(output_file)
if self.mask:
masked_output_file = self.get_output_file(
mask=True, entry=root[entry])
self.refine.prepare_transform(masked_output_file,
mask=True)
self.refine.write_settings(settings_file)
super().accept()
except NeXusError as error:
report_error("Preparing Data Transform", error)
def accept(self):
try:
output_file = self.get_output_file()
try:
workspace = self.treeview.tree.get_name(os.path.basename(output_file))
except Exception:
workspace = self.treeview.tree.get_new_name()
self.treeview.tree[workspace] = self.user_ns[workspace] = self.get_data()
super(StackDialog, self).accept()
except NeXusError as error:
report_error("Stacking Images", error)
def accept(self):
try:
output_file = self.get_output_file()
try:
workspace = self.treeview.tree.get_name(os.path.basename(output_file))
except Exception:
workspace = self.treeview.tree.get_new_name()
self.treeview.tree[workspace] = self.user_ns[workspace] = self.get_data()
super(StackDialog, self).accept()
except NeXusError as error:
report_error("Stacking Images", error)
def accept(self):
try:
if 'transform' in self.entry and not self.overwrite:
self.display_message(
'Preparing Transform',
'Transform group already exists in %s' % self.entry.nxname)
return
if self.mask and 'masked_transform' in self.entry and not self.overwrite:
self.display_message(
'Preparing Transform',
'Masked transform group already exists in %s' %
self.entry.nxname)
return
output_file = self.get_output_file()
settings_file = self.get_settings_file()
self.write_parameters(output_file, settings_file)
self.refine.prepare_transform(output_file)
if self.mask:
masked_output_file = self.get_output_file(mask=True)
self.refine.prepare_transform(masked_output_file, mask=True)
self.refine.write_settings(settings_file)
if self.copy:
root = self.entry.nxroot
for entry in [
e for e in root
if e != 'entry' and e != self.entry.nxname
]:
if 'transform' in root[entry] and not self.overwrite:
self.display_message(
'Preparing Transform',
'Transform group already exists in %s' % entry)
return
if self.mask and 'masked_transform' in root[
entry] and not self.overwrite:
self.display_message(
'Preparing Transform',
'Masked transform group already exists in %s' %
entry)
return
self.refine = NXRefine(root[entry])
output = output_file.replace(self.entry.nxname, entry)
settings = settings_file.replace(self.entry.nxname, entry)
self.write_parameters(output, settings)
self.refine.prepare_transform(output)
if self.mask:
output = masked_output_file.replace(
self.entry.nxname, entry)
self.refine.prepare_transform(output, mask=True)
self.refine.write_settings(settings)
super(TransformDialog, self).accept()
except NeXusError as error:
report_error("Preparing Data Transform", error)
def accept(self):
try:
self.reduce.write_maximum(self.maximum)
self.reduce.record('nxmax',
maximum=self.maximum,
first_frame=self.first,
last_frame=self.last)
self.reduce.record_end('nxmax')
self.stop()
super().accept()
except Exception as error:
report_error("Finding Maximum", error)
def accept(self):
try:
for p in self.refine_parameters:
self.settings.set('nxrefine', p,
self.refine_parameters[p].value)
for p in self.reduce_parameters:
self.settings.set('nxreduce', p,
self.reduce_parameters[p].value)
self.settings.save()
super().accept()
except Exception as error:
report_error("Defining New Settings", error)
def save_mask(self):
try:
mask = self.treeview.tree[self.parameters['mask'].value]
if mask.dtype != np.bool:
raise NeXusError('Mask must be a Boolean array')
elif len(mask.shape) == 1:
raise NeXusError('Mask must be at least two-dimensional')
elif len(mask.shape) > 2:
mask = mask[0]
self.entry['instrument/detector/pixel_mask'] = mask
self.entry['instrument/detector/pixel_mask_applied'] = False
except NeXusError as error:
report_error('Applying Mask', error)
def accept(self):
try:
self.reduce.write_peaks(self.peaks)
self.reduce.record('nxfind',
threshold=self.threshold,
first_frame=self.first,
last_frame=self.last,
min_pixels=self.min_pixels,
peak_number=len(self.peaks))
self.reduce.record_end('nxfind')
super().accept()
except Exception as error:
report_error("Finding Peaks", error)
def plot_peaks(self, x, y):
try:
polar_angles, azimuthal_angles = self.refine.calculate_angles(x, y)
if polar_angles[0] > polar_angles[-1]:
polar_angles = polar_angles[::-1]
azimuthal_angles = azimuthal_angles[::-1]
azimuthal_field = NXfield(azimuthal_angles, name='azimuthal_angle')
azimuthal_field.long_name = 'Azimuthal Angle'
polar_field = NXfield(polar_angles, name='polar_angle')
polar_field.long_name = 'Polar Angle'
plotview = get_plotview()
plotview.plot(NXdata(azimuthal_field, polar_field, title='Peak Angles'))
except NeXusError as error:
report_error('Plotting Lattice', error)
def plot_peaks(self, x, y):
try:
polar_angles, azimuthal_angles = self.refine.calculate_angles(x, y)
if polar_angles[0] > polar_angles[-1]:
polar_angles = polar_angles[::-1]
azimuthal_angles = azimuthal_angles[::-1]
azimuthal_field = NXfield(azimuthal_angles, name='azimuthal_angle')
azimuthal_field.long_name = 'Azimuthal Angle'
polar_field = NXfield(polar_angles, name='polar_angle')
polar_field.long_name = 'Polar Angle'
plotview = get_plotview()
plotview.plot(
NXdata(azimuthal_field, polar_field, title='Peak Angles'))
except NeXusError as error:
report_error("Plotting Lattice", error)
def accept(self):
try:
experiment_directory = self.get_directory()
configuration_directory = os.path.join(experiment_directory,
'configurations')
self.mainwindow.default_directory = experiment_directory
self.get_parameters()
self.configuration_file.save(
os.path.join(
configuration_directory,
self.configuration['configuration'].value + '.nxs'))
self.treeview.tree.load(self.configuration_file.nxfilename, 'rw')
super().accept()
except Exception as error:
report_error("Defining New Configuration", error)
def update_data(self):
try:
for path in [
self.paths[p].value for p in self.paths
if self.paths[p].vary
]:
data = self.entry.nxroot[path]
if [axis.nxname for axis in data.nxaxes] == ['z', 'y', 'x']:
lp = self.refine.lattice_parameters
else:
lp = self.refine.reciprocal_lattice_parameters
for i, axis in enumerate(data.nxaxes):
data[axis.nxname].attrs['scaling_factor'] = lp[2 - i]
data.attrs['angles'] = lp[5:2:-1]
self.update_box.close()
except NeXusError as error:
report_error("Updating Groups", error)
def refine_hkls(self):
self.parameters.status_message.setText('Fitting...')
self.parameters.status_message.repaint()
self.mainwindow.app.app.processEvents()
self.transfer_parameters()
try:
self.refine.refine_hkls(**self.refined)
except NeXusError as error:
report_error('Refining Lattice', error)
self.parameters.status_message.setText('')
return
self.parameters.result = self.refine.result
self.parameters.fit_report = self.refine.fit_report
self.fit_report.append(self.refine.fit_report)
self.update_parameters()
self.parameters.status_message.setText(self.parameters.result.message)
self.update_table()
def accept(self):
try:
if "peaks" in self.entry.entries:
del self.entry["peaks"]
self.entry.peaks = NXdata()
shape = (len(self.peaks),)
self.entry.peaks.npixels = NXfield([peak.np for peak in self.peaks], dtype=np.float32)
self.entry.peaks.intensity = NXfield([peak.intensity for peak in self.peaks], dtype=np.float32)
self.entry.peaks.x = NXfield([peak.x for peak in self.peaks], dtype=np.float32)
self.entry.peaks.y = NXfield([peak.y for peak in self.peaks], dtype=np.float32)
self.entry.peaks.z = NXfield([peak.z for peak in self.peaks], dtype=np.float32)
self.entry.peaks.sigx = NXfield([peak.sigx for peak in self.peaks], dtype=np.float32)
self.entry.peaks.sigy = NXfield([peak.sigy for peak in self.peaks], dtype=np.float32)
self.entry.peaks.covxy = NXfield([peak.covxy for peak in self.peaks], dtype=np.float32)
super(FindDialog, self).accept()
except NeXusError as error:
report_error("Finding peaks", error)
def choose_entry(self):
try:
refine = NXRefine(self.entry)
if refine.xp is None:
raise NeXusError("No peaks in entry")
except NeXusError as error:
report_error("Refining Lattice", error)
return
self.refine = refine
if self.layout.count() == 2:
self.insert_layout(1, self.Qgrid)
self.insert_layout(
2,
self.checkboxes(('copy', 'Copy to all entries', True),
('mask', 'Create masked transforms', True),
('overwrite', 'Overwrite transforms', False)))
self.refine.initialize_grid()
self.update_grid()
def accept(self):
try:
if self.mask is None:
raise NeXusError("No mask has been created")
elif self.entry.nxfilemode == 'r':
raise NeXusError("NeXus file opened as readonly")
self.reduce.write_mask(self.mask)
self.reduce.record('nxprepare',
masked_file=self.reduce.mask_file,
threshold1=self.threshold1,
horizontal1=self.horizontal1,
threshold2=self.threshold2,
horizontal2=self.horizontal2,
process='nxprepare_mask')
self.reduce.record_end('nxprepare')
super().accept()
except Exception as error:
report_error("Preparing Mask", error)
def choose_entry(self):
try:
refine = NXRefine(self.entry)
if refine.xp is None:
raise NeXusError("No peaks in entry")
except NeXusError as error:
report_error("Refining Lattice", error)
return
self.refine = refine
self.set_title(f"Refining {self.refine.name}")
if self.layout.count() == 2:
self.insert_layout(1, self.parameters.grid_layout)
self.insert_layout(2, self.refine_buttons)
self.insert_layout(3, self.orientation_buttons)
self.insert_layout(4, self.parameters.report_layout())
self.insert_layout(5, self.lattice_buttons)
self.update_parameters()
self.update_table()
def set_groups(self):
if self.space_group:
try:
if isinstance(self.space_group, float):
sgi = sgtbx.space_group_info(int(self.space_group))
else:
sgi = sgtbx.space_group_info(self.space_group)
except RuntimeError as error:
report_error("Defining Lattice", error)
return
try:
self.refine.space_group = sgi.type().lookup_symbol()
self.refine.symmetry = sgi.group().crystal_system().lower()
self.refine.laue_group = sgi.group().laue_group_type()
self.refine.centring = self.refine.space_group[0]
self.update_parameters()
except Exception:
pass
def accept(self):
try:
if 'transform' in self.entry and not self.overwrite:
self.display_message('Preparing Transform',
'Transform group already exists in %s' % self.entry.nxname)
return
if self.mask and 'masked_transform' in self.entry and not self.overwrite:
self.display_message('Preparing Transform',
'Masked transform group already exists in %s' % self.entry.nxname)
return
output_file = self.get_output_file()
settings_file = self.get_settings_file()
self.write_parameters(output_file, settings_file)
self.refine.prepare_transform(output_file)
if self.mask:
masked_output_file = self.get_output_file(mask=True)
self.refine.prepare_transform(masked_output_file, mask=True)
self.refine.write_settings(settings_file)
if self.copy:
root = self.entry.nxroot
for entry in [e for e in root
if e != 'entry' and e != self.entry.nxname]:
if 'transform' in root[entry] and not self.overwrite:
self.display_message('Preparing Transform',
'Transform group already exists in %s' % entry)
return
if self.mask and 'masked_transform' in root[entry] and not self.overwrite:
self.display_message('Preparing Transform',
'Masked transform group already exists in %s' % entry)
return
self.refine = NXRefine(root[entry])
output_file = self.get_output_file(entry=root[entry])
settings_file = self.get_settings_file(entry=root[entry])
self.write_parameters(output_file, settings_file)
self.refine.prepare_transform(output_file)
if self.mask:
masked_output_file = self.get_output_file(mask=True,
entry=root[entry])
self.refine.prepare_transform(masked_output_file, mask=True)
self.refine.write_settings(settings_file)
super(TransformDialog, self).accept()
except NeXusError as error:
report_error("Preparing Data Transform", error)
def plot_peaks(self):
try:
x, y = (self.refine.xp[self.refine.idx],
self.refine.yp[self.refine.idx])
polar_angles, azimuthal_angles = self.refine.calculate_angles(x, y)
if polar_angles[0] > polar_angles[-1]:
polar_angles = polar_angles[::-1]
azimuthal_angles = azimuthal_angles[::-1]
azimuthal_field = NXfield(azimuthal_angles, name='azimuthal_angle')
azimuthal_field.long_name = 'Azimuthal Angle'
polar_field = NXfield(polar_angles, name='polar_angle')
polar_field.long_name = 'Polar Angle'
plotview = get_plotview()
plotview.plot(NXdata(azimuthal_field,
polar_field,
title=f'{self.refine.name} Peak Angles'),
xmax=self.get_polar_max())
except NeXusError as error:
report_error('Plotting Lattice', error)
def accept(self):
try:
home_directory = self.get_directory()
self.mainwindow.default_directory = home_directory
self.get_parameters()
configuration_directory = os.path.join(home_directory, 'configurations')
if not os.path.exists(configuration_directory):
os.makedirs(configuration_directory)
self.experiment_file.save(os.path.join(configuration_directory,
self.instrument['experiment'].value+'.nxs'))
task_directory = os.path.join(home_directory, 'tasks')
if not os.path.exists(task_directory):
os.makedirs(task_directory)
calibration_directory = os.path.join(home_directory, 'calibrations')
if not os.path.exists(calibration_directory):
os.makedirs(calibration_directory)
self.treeview.tree.load(self.experiment_file.nxfilename, 'rw')
super(ExperimentDialog, self).accept()
except Exception as error:
report_error("Defining New Experiment", error)
def read_data(self):
delimiter = self.delimiters[self.delcombo.selected]
skip_header = int(self.skipbox.text())
if self.header:
self.headers = self.text[skip_header].split(delimiter)
else:
self.headers = None
try:
input = np.genfromtxt(self.text,
delimiter=delimiter,
names=self.header,
skip_header=skip_header,
dtype=None,
autostrip=True,
encoding='utf8')
except ValueError as error:
report_error("Importing Text File", error)
self.data = None
return
self.data = {}
for i, _ in enumerate(input[0]):
if input.dtype.names is not None:
name = input.dtype.names[i]
dtype = input.dtype[i].name
else:
name = 'Col' + str(i + 1)
dtype = input.dtype.name
if dtype not in self.data_types:
dtype = 'char'
data = [c[i] for c in input]
signal = 'field'
if self.groupcombo.selected in ['NXdata', 'NXmonitor', 'NXlog']:
if i <= 2 and dtype != 'char':
signal = ['axis', 'signal', 'errors'][i]
self.data['Col' + str(i + 1)] = {
'name': name,
'dtype': dtype,
'signal': signal,
'data': data
}
def accept(self):
x, y = np.arange(self.mask.shape[1]), np.arange(self.mask.shape[0])
for shape in self.shapes:
if isinstance(shape, NXrectangle):
x0, y0 = shape.xy
x1, y1 = x0 + shape.width, y0 + shape.height
self.mask[int(y0):int(y1), int(x0):int(x1)] = 1
else:
xc, yc = shape.center
r = shape.radius
inside = (x[None, :] - int(xc))**2 + (y[:, None] -
int(yc))**2 < r**2
self.mask = self.mask | inside
self.mask[np.where(self.counts < 0)] = 1
try:
self.entry['instrument/detector/pixel_mask'] = self.mask
except NeXusError as error:
report_error("Creating Mask", error)
return
super().accept()
if 'Mask Editor' in plotviews:
plotviews['Mask Editor'].close_view()
def accept(self):
try:
home_directory = self.get_directory()
self.mainwindow.default_directory = home_directory
self.get_parameters()
configuration_directory = os.path.join(home_directory,
'configurations')
if not os.path.exists(configuration_directory):
os.makedirs(configuration_directory)
self.experiment_file.save(
os.path.join(configuration_directory,
self.instrument['experiment'].value + '.nxs'))
task_directory = os.path.join(home_directory, 'tasks')
if not os.path.exists(task_directory):
os.makedirs(task_directory)
calibration_directory = os.path.join(home_directory,
'calibrations')
if not os.path.exists(calibration_directory):
os.makedirs(calibration_directory)
self.treeview.tree.load(self.experiment_file.nxfilename, 'rw')
super(ExperimentDialog, self).accept()
except Exception as error:
report_error("Defining New Experiment", error)
def choose_peaks(self):
try:
if self.orient_box in self.mainwindow.dialogs:
self.orient_box.close()
except Exception:
pass
self.orient_box = NXDialog(self)
self.peak_parameters = GridParameters()
self.peak_parameters.add('primary',
self.primary,
'Primary',
readonly=True)
self.peak_parameters.add('secondary',
self.secondary,
'Secondary',
readonly=True)
self.peak_parameters.add('angle',
self.refine.angle_peaks(
self.primary, self.secondary),
'Angle (deg)',
readonly=True)
self.peak_parameters.add('primary_hkl',
self.ring_list[self.refine.rp[self.primary]],
'Primary HKL',
slot=self.choose_secondary_grid)
self.orient_box.set_layout(
self.peak_parameters.grid(header=False, spacing=5),
self.action_buttons(('Orient', self.orient)),
self.orient_box.close_buttons(close=True))
self.orient_box.set_title('Orient Lattice')
self.orient_box.show()
try:
self.setup_secondary_grid()
except NeXusError as error:
report_error("Refining Lattice", error)
self.orient_box.close()
def show_dialog():
try:
dialog = StackDialog()
dialog.show()
except NeXusError as error:
report_error("Stacking Images", error)
def show_dialog():
try:
dialog = ScanDialog()
dialog.show()
except NeXusError as error:
report_error("Defining New Scan", error)
def show_dialog():
try:
dialog = LoadDialog()
dialog.show()
except NeXusError as error:
report_error("Loading Calibration", error)
def show_dialog():
try:
dialog = CalculateDialog()
dialog.show()
except NeXusError as error:
report_error("Calculating Angles", error)
def show_dialog():
try:
dialog = ConvertDialog()
dialog.show()
except NeXusError as error:
report_error("Converting to (Q,E)", error)
def write_parameters(self):
try:
self.refine.write_parameters()
except NeXusError as error:
report_error('Defining Orientation', error)
def show_dialog():
try:
dialog = OrientationDialog()
dialog.show()
except NeXusError as error:
report_error("Defining Orientation", error)
def show_dialog():
try:
dialog = CopyDialog()
dialog.show()
except NeXusError as error:
report_error("Copying Parameters", error)
def show_dialog():
try:
dialog = TransformDialog()
dialog.show()
except NeXusError as error:
report_error("Preparing Data Transform", error)
def show_dialog():
try:
dialog = MaskDialog()
dialog.show()
except NeXusError as error:
report_error("Applying Mask", error)
def show_dialog():
try:
dialog = ExperimentDialog()
dialog.show()
except NeXusError as error:
report_error("Defining New Experiment", error)
def show_dialog():
try:
dialog = ConvertDialog()
dialog.show()
except NeXusError as error:
report_error("Converting to (Q,E)", error)
def show_dialog():
try:
dialog = WorkflowDialog()
dialog.show()
except NeXusError as error:
report_error("Managing Workflows", error)
def show_dialog():
try:
dialog = LatticeDialog()
dialog.show()
except NeXusError as error:
report_error("Defining Lattice", error)
def write_parameters(self):
try:
self.get_parameters()
self.refine.write_parameters()
except NeXusError as error:
report_error('Defining Lattice', error)
def plot_lattice(self):
try:
self.get_parameters()
self.plot_peaks(self.refine.xp, self.refine.yp)
except NeXusError as error:
report_error("Calculating Angles", error)
def show_dialog():
try:
dialog = Mask3DDialog()
dialog.show()
except NeXusError as error:
report_error("Calculating 3D Mask", error)
def show_dialog():
try:
dialog = WorkflowDialog()
dialog.show()
except NeXusError as error:
report_error("Managing Workflows", error)
def show_dialog():
try:
dialog = FindDialog()
dialog.show()
except NeXusError as error:
report_error("Finding Peaks", error)
def show_dialog():
try:
dialog = CalibrateDialog()
dialog.show()
except NeXusError as error:
report_error("Calibrating Powder", error)
def show_dialog():
try:
dialog = ExperimentDialog()
dialog.show()
except NeXusError as error:
report_error("Defining New Experiment", error)
def plot_lattice(self):
try:
self.get_parameters()
self.plot_peaks(self.refine.xp, self.refine.yp)
except NeXusError as error:
report_error('Calculating Angles', error)
def show_dialog():
try:
dialog = MakeDialog()
dialog.show()
except NeXusError as error:
report_error("Making Scan Macro", error)
def show_dialog():
try:
dialog = ServerDialog()
dialog.show()
except NeXusError as error:
report_error("Managing Servers", error)
def show_dialog():
try:
dialog = CalculateDialog()
dialog.show()
except NeXusError as error:
report_error("Calculating Angles", error)
