def main():
parser = argparse.ArgumentParser(
description="Refine orientation matrix")
parser.add_argument('-d', '--directory', default='./',
help='directory containing the NeXus file')
parser.add_argument('-f', '--filename', required=True,
help='NeXus file name')
parser.add_argument('-e', '--entries', default=['f1', 'f2', 'f3'],
nargs='+', help='names of entries to be oriented')
parser.add_argument('-o', '--omega', default='0.0', help='omega start')
args = parser.parse_args()
name, ext = os.path.splitext(args.filename)
if ext == '':
args.filename = args.filename + '.nxs'
root = nxload(os.path.join(args.directory, args.filename), 'rw')
entries = args.entries
tic=timeit.default_timer()
for e in entries:
entry = root[e]
ref = NXRefine(entry)
old_score = ref.score()
print 'Current lattice parameters: ', ref.a, ref.b, ref.c
print '%s peaks; Old score: %.4f' % (len(ref.idx), old_score)
success, info, msg = refine_orientation(ref)
new_score = ref.score()
print 'Success:', success, ' ', msg
print 'No. of function calls:', info['nfev']
print 'New lattice parameters: ', ref.a, ref.b, ref.c
print '%s peaks; New score: %.4f' % (len(ref.idx), new_score)
if new_score <= old_score and success > 0 and success < 5:
write_parameters(ref)
note = NXnote('nxorient '+' '.join(sys.argv[1:]),
('Current machine: %s\n'
'Current working directory: %s')
% (socket.gethostname(), os.getcwd()))
entry['nxorient'] = NXprocess(program='nxorient',
sequence_index=len(entry.NXprocess)+1,
version=__version__,
note=note)
toc=timeit.default_timer()
print toc-tic, 'seconds for', args.filename
def __init__(self, parent=None):
super(RefineLatticeDialog, self).__init__(parent)
self.select_entry(self.choose_entry)
self.refine = NXRefine(self.entry)
self.refine.read_parameters()
self.parameters = GridParameters()
self.parameters.add('symmetry', self.refine.symmetries, 'Symmetry',
None, self.set_symmetry)
self.parameters.add('a', self.refine.a, 'Unit Cell - a (Ang)', True)
self.parameters.add('b', self.refine.b, 'Unit Cell - b (Ang)', True)
self.parameters.add('c', self.refine.c, 'Unit Cell - c (Ang)', True)
self.parameters.add('alpha', self.refine.alpha, 'Unit Cell - alpha (deg)', False)
self.parameters.add('beta', self.refine.beta, 'Unit Cell - beta (deg)', False)
self.parameters.add('gamma', self.refine.gamma, 'Unit Cell - gamma (deg)', False)
self.parameters.add('wavelength', self.refine.wavelength, 'Wavelength (Ang)', False)
self.parameters.add('distance', self.refine.distance, 'Distance (mm)', False)
self.parameters.add('yaw', self.refine.yaw, 'Yaw (deg)', False)
self.parameters.add('pitch', self.refine.pitch, 'Pitch (deg)', False)
self.parameters.add('roll', self.refine.roll, 'Roll (deg)')
self.parameters.add('xc', self.refine.xc, 'Beam Center - x', False)
self.parameters.add('yc', self.refine.yc, 'Beam Center - y', False)
self.parameters.add('phi_start', self.refine.phi_start, 'Phi Start (deg)', False)
self.parameters.add('phi_step', self.refine.phi_step, 'Phi Step (deg)')
self.parameters.add('chi_start', self.refine.chi_start, 'Chi Start (deg)', False)
self.parameters.add('chi_step', self.refine.chi_step, 'Chi Step (deg)')
self.parameters.add('omega_start', self.refine.omega_start, 'Omega Start (deg)', False)
self.parameters.add('omega_step', self.refine.omega_step, 'Omega Step (deg)')
self.parameters.add('polar', self.refine.polar_max,
'Max. Polar Angle (deg)', None, self.set_polar_max)
self.parameters.add('polar_tolerance', self.refine.polar_tolerance, 'Polar Angle Tolerance')
self.parameters.add('peak_tolerance', self.refine.peak_tolerance, 'Peak Angle Tolerance')
self.parameters.add('orientation_matrix', False, 'Orientation Matrix', False)
self.refine_buttons = self.action_buttons(
('Refine Angles', self.refine_angles),
('Refine HKLs', self.refine_hkls),
('Restore', self.restore_parameters),
('Reset', self.reset_parameters))
self.lattice_buttons = self.action_buttons(
('Plot', self.plot_lattice),
('List', self.list_peaks),
('Save', self.write_parameters))
self.set_layout(self.entry_layout, self.parameters.grid(),
self.refine_buttons, self.lattice_buttons,
self.close_buttons())
self.parameters.grid_layout.setVerticalSpacing(1)
self.set_title('Refining Lattice')
self.parameters['symmetry'].value = self.refine.symmetry
self.set_symmetry()
self.peaks_box = None
def copy_root(self):
root = self.entry.nxroot
other_root = self.other_entry.nxroot
if root is other_root:
raise NeXusError("Cannot copy to the same root")
input = NXRefine(root["entry"])
output_main = NXRefine(other_root["entry"])
input.copy_parameters(output_main, sample=True)
for name in [entry for entry in root if entry != "entry"]:
if name in other_root:
input = NXRefine(root[name])
output = NXRefine(other_root[name])
input.copy_parameters(output, instrument=True)
output_main.link_sample(output)
def initialize_grid(self):
self.refine = NXRefine(self.entry)
self.refine.initialize_grid()
self.start_h_box.setText(str(self.refine.h_start))
self.step_h_box.setText(str(self.refine.h_step))
self.stop_h_box.setText(str(self.refine.h_stop))
self.start_k_box.setText(str(self.refine.k_start))
self.step_k_box.setText(str(self.refine.k_step))
self.stop_k_box.setText(str(self.refine.k_stop))
self.start_l_box.setText(str(self.refine.l_start))
self.step_l_box.setText(str(self.refine.l_step))
self.stop_l_box.setText(str(self.refine.l_stop))
def __init__(self, parent=None):
super(TransformDialog, self).__init__(parent)
self.select_entry(self.initialize_grid)
self.refine = NXRefine(self.entry)
self.refine.read_parameters()
grid = QtGui.QGridLayout()
grid.setSpacing(10)
header_font = QtGui.QFont()
header_font.setBold(True)
start_label = QtGui.QLabel('Start')
start_label.setFont(header_font)
grid.addWidget(start_label, 0, 1)
step_label = QtGui.QLabel('Step')
step_label.setFont(header_font)
grid.addWidget(step_label, 0, 2)
stop_label = QtGui.QLabel('Stop')
stop_label.setFont(header_font)
grid.addWidget(stop_label, 0, 3)
grid.addWidget(QtGui.QLabel('H:'), 1, 0)
grid.addWidget(QtGui.QLabel('K:'), 2, 0)
grid.addWidget(QtGui.QLabel('L:'), 3, 0)
self.start_h_box = QtGui.QLineEdit()
self.step_h_box = QtGui.QLineEdit()
self.stop_h_box = QtGui.QLineEdit()
grid.addWidget(self.start_h_box, 1, 1)
grid.addWidget(self.step_h_box, 1, 2)
grid.addWidget(self.stop_h_box, 1, 3)
self.start_k_box = QtGui.QLineEdit()
self.step_k_box = QtGui.QLineEdit()
self.stop_k_box = QtGui.QLineEdit()
grid.addWidget(self.start_k_box, 2, 1)
grid.addWidget(self.step_k_box, 2, 2)
grid.addWidget(self.stop_k_box, 2, 3)
self.start_l_box = QtGui.QLineEdit()
self.step_l_box = QtGui.QLineEdit()
self.stop_l_box = QtGui.QLineEdit()
grid.addWidget(self.start_l_box, 3, 1)
grid.addWidget(self.step_l_box, 3, 2)
grid.addWidget(self.stop_l_box, 3, 3)
self.set_layout(self.entry_layout, grid, self.close_buttons(save=True))
self.setWindowTitle('Transforming Data')
try:
self.initialize_grid()
except Exception:
pass
def __init__(self, parent=None):
super(CalculateDialog, self).__init__(parent)
self.select_entry(self.choose_entry)
self.refine = NXRefine(self.entry)
self.refine.read_parameters()
self.parameters = GridParameters()
self.parameters.add('wavelength', self.refine.wavelength, 'Wavelength (Ang)')
self.parameters.add('distance', self.refine.distance, 'Detector Distance (mm)')
self.parameters.add('xc', self.refine.xc, 'Beam Center - x')
self.parameters.add('yc', self.refine.yc, 'Beam Center - y')
self.parameters.add('pixel', self.refine.pixel_size, 'Pixel Size (mm)')
action_buttons = self.action_buttons(('Plot', self.plot_lattice),
('Save', self.write_parameters))
self.set_layout(self.entry_layout, self.parameters.grid(),
action_buttons, self.close_buttons())
self.set_title('Calculate Angles')
def __init__(self, parent=None):
super(LatticeDialog, self).__init__(parent)
self.select_entry(self.choose_entry)
self.refine = NXRefine(self.entry)
self.refine.read_parameters()
self.parameters = GridParameters()
self.parameters.add('centring', self.refine.centrings, 'Cell Centring')
self.parameters['centring'].value = self.refine.centring
self.parameters.add('a', self.refine.a, 'Unit Cell - a (Ang)')
self.parameters.add('b', self.refine.b, 'Unit Cell - b (Ang)')
self.parameters.add('c', self.refine.c, 'Unit Cell - c (Ang)')
self.parameters.add('alpha', self.refine.alpha, 'Unit Cell - alpha (deg)')
self.parameters.add('beta', self.refine.beta, 'Unit Cell - beta (deg)')
self.parameters.add('gamma', self.refine.gamma, 'Unit Cell - gamma (deg)')
action_buttons = self.action_buttons(('Plot', self.plot_lattice),
('Save', self.write_parameters))
self.set_layout(self.entry_layout, self.parameters.grid(),
action_buttons, self.close_buttons())
self.set_title('Defining Lattice')
def copy_entry(self):
if self.entry is self.other_entry:
raise NeXusError("Cannot copy to the same entry")
input = NXRefine(self.entry)
output = NXRefine(self.other_entry)
if "instrument" in self.entry:
input.copy_parameters(output, instrument=True)
if "sample" not in self.other_entry and "sample" in self.entry:
if self.entry.nxname == "entry" and self.other_entry.nxname == "entry":
input.copy_parameters(output, sample=True)
elif (
self.entry.nxname == "entry"
and self.other_entry.nxname != "entry"
and self.entry.nxroot is self.other_entry.nxroot
):
input.link_sample(output)
else:
try:
self.other_entry.makelink(self.other_entry.nxroot["entry/sample"])
except Exception:
pass
def __init__(self, parent=None):
super(OrientationDialog, self).__init__(parent)
self.select_entry(self.choose_entry)
self.refine = NXRefine(self.entry)
self.refine.read_parameters()
self.parameters = GridParameters()
self.parameters.add('phi_start', self.refine.phi_start, 'Phi Start (deg)')
self.parameters.add('phi_step', self.refine.phi_step, 'Phi Step (deg)')
self.parameters.add('chi_start', self.refine.chi_start, 'Chi Start (deg)')
self.parameters.add('chi_step', self.refine.chi_step, 'Chi Step (deg)')
self.parameters.add('omega_start', self.refine.omega_start, 'Omega Start (deg)')
self.parameters.add('omega_step', self.refine.omega_step, 'Omega Step (deg)')
self.parameters.add('polar', self.refine.polar_max, 'Max. Polar Angle (deg)')
self.parameters.add('polar_tolerance', self.refine.polar_tolerance, 'Polar Angle Tolerance')
self.parameters.add('peak_tolerance', self.refine.peak_tolerance, 'Peak Angle Tolerance')
action_buttons = self.action_buttons(
('Generate Grains', self.generate_grains),
('List Peaks', self.list_peaks))
self.grain_layout = QtGui.QHBoxLayout()
self.grain_combo = QtGui.QComboBox()
self.grain_combo.setSizeAdjustPolicy(QtGui.QComboBox.AdjustToContents)
self.grain_combo.currentIndexChanged.connect(self.set_grain)
self.grain_textbox = QtGui.QLabel()
self.grain_layout.addWidget(self.grain_combo)
self.grain_layout.addStretch()
self.grain_layout.addWidget(self.grain_textbox)
bottom_layout = QtGui.QHBoxLayout()
self.result_textbox = QtGui.QLabel()
bottom_layout.addWidget(self.result_textbox)
bottom_layout.addStretch()
bottom_layout.addWidget(self.close_buttons())
self.set_layout(self.entry_layout, self.parameters.grid(),
action_buttons, bottom_layout)
self.set_title('Defining Orientation')
class RefineLatticeDialog(BaseDialog):
def __init__(self, parent=None):
super(RefineLatticeDialog, self).__init__(parent)
self.select_entry(self.choose_entry)
self.refine = NXRefine(self.entry)
self.refine.read_parameters()
self.parameters = GridParameters()
self.parameters.add('symmetry', self.refine.symmetries, 'Symmetry',
None, self.set_symmetry)
self.parameters.add('a', self.refine.a, 'Unit Cell - a (Ang)', True)
self.parameters.add('b', self.refine.b, 'Unit Cell - b (Ang)', True)
self.parameters.add('c', self.refine.c, 'Unit Cell - c (Ang)', True)
self.parameters.add('alpha', self.refine.alpha, 'Unit Cell - alpha (deg)', False)
self.parameters.add('beta', self.refine.beta, 'Unit Cell - beta (deg)', False)
self.parameters.add('gamma', self.refine.gamma, 'Unit Cell - gamma (deg)', False)
self.parameters.add('wavelength', self.refine.wavelength, 'Wavelength (Ang)', False)
self.parameters.add('distance', self.refine.distance, 'Distance (mm)', False)
self.parameters.add('yaw', self.refine.yaw, 'Yaw (deg)', False)
self.parameters.add('pitch', self.refine.pitch, 'Pitch (deg)', False)
self.parameters.add('roll', self.refine.roll, 'Roll (deg)')
self.parameters.add('xc', self.refine.xc, 'Beam Center - x', False)
self.parameters.add('yc', self.refine.yc, 'Beam Center - y', False)
self.parameters.add('phi_start', self.refine.phi_start, 'Phi Start (deg)', False)
self.parameters.add('phi_step', self.refine.phi_step, 'Phi Step (deg)')
self.parameters.add('chi_start', self.refine.chi_start, 'Chi Start (deg)', False)
self.parameters.add('chi_step', self.refine.chi_step, 'Chi Step (deg)')
self.parameters.add('omega_start', self.refine.omega_start, 'Omega Start (deg)', False)
self.parameters.add('omega_step', self.refine.omega_step, 'Omega Step (deg)')
self.parameters.add('polar', self.refine.polar_max,
'Max. Polar Angle (deg)', None, self.set_polar_max)
self.parameters.add('polar_tolerance', self.refine.polar_tolerance, 'Polar Angle Tolerance')
self.parameters.add('peak_tolerance', self.refine.peak_tolerance, 'Peak Angle Tolerance')
self.parameters.add('orientation_matrix', False, 'Orientation Matrix', False)
self.refine_buttons = self.action_buttons(
('Refine Angles', self.refine_angles),
('Refine HKLs', self.refine_hkls),
('Restore', self.restore_parameters),
('Reset', self.reset_parameters))
self.lattice_buttons = self.action_buttons(
('Plot', self.plot_lattice),
('List', self.list_peaks),
('Save', self.write_parameters))
self.set_layout(self.entry_layout, self.parameters.grid(),
self.refine_buttons, self.lattice_buttons,
self.close_buttons())
self.parameters.grid_layout.setVerticalSpacing(1)
self.set_title('Refining Lattice')
self.parameters['symmetry'].value = self.refine.symmetry
self.set_symmetry()
self.peaks_box = None
def choose_entry(self):
self.refine = NXRefine(self.entry)
self.update_parameters()
def update_parameters(self):
self.parameters['a'].value = self.refine.a
self.parameters['b'].value = self.refine.b
self.parameters['c'].value = self.refine.c
self.parameters['alpha'].value = self.refine.alpha
self.parameters['beta'].value = self.refine.beta
self.parameters['gamma'].value = self.refine.gamma
self.parameters['wavelength'].value = self.refine.wavelength
self.parameters['distance'].value = self.refine.distance
self.parameters['yaw'].value = self.refine.yaw
self.parameters['pitch'].value = self.refine.pitch
self.parameters['roll'].value = self.refine.roll
self.parameters['xc'].value = self.refine.xc
self.parameters['yc'].value = self.refine.yc
self.parameters['phi_start'].value = self.refine.phi_start
self.parameters['phi_step'].value = self.refine.phi_step
self.parameters['chi_start'].value = self.refine.chi_start
self.parameters['chi_step'].value = self.refine.chi_step
self.parameters['omega_start'].value = self.refine.omega_start
self.parameters['omega_step'].value = self.refine.omega_step
self.parameters['polar'].value = self.refine.polar_max
self.parameters['polar_tolerance'].value = self.refine.polar_tolerance
try:
self.refine.polar_angles, self.refine.azimuthal_angles = \
self.refine.calculate_angles(self.refine.xp, self.refine.yp)
except Exception:
pass
def transfer_parameters(self):
self.refine.a, self.refine.b, self.refine.c, \
self.refine.alpha, self.refine.beta, self.refine.gamma = \
self.get_lattice_parameters()
self.refine.set_symmetry()
self.refine.wavelength = self.get_wavelength()
self.refine.distance = self.get_distance()
self.refine.yaw, self.refine.pitch, self.refine.roll = self.get_tilts()
self.refine.xc, self.refine.yc = self.get_centers()
self.refine.phi_start, self.refine.phi_step = self.get_phi()
self.refine.chi_start, self.refine.chi_step = self.get_chi()
self.refine.omega_start, self.refine.omega_step = self.get_omega()
self.refine.polar_max = self.get_polar_max()
self.refine.polar_tol = self.get_tolerance()
self.refine.polar_angles
def write_parameters(self):
self.transfer_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()
def get_symmetry(self):
return self.parameters['symmetry'].value
def set_symmetry(self):
self.refine.symmetry = self.get_symmetry()
self.refine.set_symmetry()
self.update_parameters()
if self.refine.symmetry == 'cubic':
self.parameters['b'].vary = False
self.parameters['c'].vary = False
self.parameters['alpha'].vary = False
self.parameters['beta'].vary = False
self.parameters['gamma'].vary = False
elif self.refine.symmetry == 'tetragonal':
self.parameters['b'].vary = False
self.parameters['alpha'].vary = False
self.parameters['beta'].vary = False
self.parameters['gamma'].vary = False
elif self.refine.symmetry == 'orthorhombic':
self.parameters['alpha'].vary = False
self.parameters['beta'].vary = False
self.parameters['gamma'].vary = False
elif self.refine.symmetry == 'hexagonal':
self.parameters['b'].vary = False
self.parameters['alpha'].vary = False
self.parameters['beta'].vary = False
self.parameters['gamma'].vary = False
elif self.refine.symmetry == 'monoclinic':
self.parameters['alpha'].vary = False
self.parameters['gamma'].vary = False
def get_lattice_parameters(self):
return (self.parameters['a'].value,
self.parameters['b'].value,
self.parameters['c'].value,
self.parameters['alpha'].value,
self.parameters['beta'].value,
self.parameters['gamma'].value)
def get_wavelength(self):
return self.parameters['wavelength'].value
def get_distance(self):
return self.parameters['distance'].value
def get_tilts(self):
return (self.parameters['yaw'].value,
self.parameters['pitch'].value,
self.parameters['roll'].value)
def get_centers(self):
return self.parameters['xc'].value, self.parameters['yc'].value
def get_polar_max(self):
return self.parameters['polar'].value
def set_polar_max(self):
self.refine.polar_max = self.get_polar_max()
def get_tolerance(self):
return self.parameters['polar_tolerance'].value
def get_phi(self):
return (self.parameters['phi_start'].value,
self.parameters['phi_step'].value)
def get_chi(self):
return (self.parameters['chi_start'].value,
self.parameters['chi_step'].value)
def get_omega(self):
return (self.parameters['omega_start'].value,
self.parameters['omega_step'].value)
def get_hkl_tolerance(self):
try:
return np.float32(self.tolerance_box.text())
except Exception:
return self.refine.hkl_tolerance
def plot_lattice(self):
self.transfer_parameters()
self.set_polar_max()
self.plot_peaks()
self.plot_rings()
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='Peak Angles'))
except NeXusError as error:
report_error('Plotting Lattice', error)
def plot_rings(self, polar_max=None):
if polar_max is None:
polar_max = self.refine.polar_max
peaks = self.refine.calculate_rings(polar_max)
plotview = get_plotview()
plotview.vlines(peaks, colors='r', linestyles='dotted')
plotview.draw()
def plot_peak(self, i):
x, y, z = self.refine.xp[i], self.refine.yp[i], self.refine.zp[i]/10.0
xmin, xmax = max(0,int(x)-200), min(int(x)+200,data.v.shape[2])
ymin, ymax = max(0,int(y)-200), min(int(y)+200,data.v.shape[1])
zmin, zmax = max(0.0,z-20.0), min(z+20.0, 360.0)
xslab=np.s_[zmin:zmax,ymin:ymax,x]
yslab=np.s_[zmin:zmax,y,xmin:xmax]
zslab=np.s_[z,ymin:ymax,xmin:xmax]
pvz.plot(data[zslab], log=True)
pvz.crosshairs(x, y)
pvy.plot(data[yslab], log=True)
pvy.crosshairs(x, z)
pvx.plot(data[xslab], log=True)
pvx.crosshairs(y, z)
def refine_angles(self):
self.parameters['orientation_matrix'].vary = False
self.parameters['phi_start'].vary = False
self.parameters['chi_start'].vary = False
self.parameters['omega_start'].vary = False
self.parameters.refine_parameters(self.angle_residuals)
self.update_parameters()
def angle_residuals(self, p):
self.parameters.get_parameters(p)
self.transfer_parameters()
polar_angles, _ = self.refine.calculate_angles(self.refine.x, self.refine.y)
rings = self.refine.calculate_rings()
residuals = np.array([find_nearest(rings, polar_angle) - polar_angle
for polar_angle in polar_angles])
return np.sum(residuals**2)
def refine_hkls(self):
self.parameters.refine_parameters(self.hkl_residuals)
self.update_parameters()
if self.peaks_box is None:
self.list_peaks()
else:
self.update_table()
def hkl_residuals(self, p):
self.parameters.get_parameters(p)
self.transfer_parameters()
return self.refine.score(self.refine.idx)
def restore_parameters(self):
self.parameters.restore_parameters()
self.transfer_parameters()
def reset_parameters(self):
self.refine.read_parameters()
self.update_parameters()
def list_peaks(self):
if self.peaks_box is not None:
self.update_table()
return
self.peaks_box = BaseDialog(self)
self.peaks_box.setMinimumWidth(600)
self.peaks_box.setMinimumHeight(600)
header = ['i', 'x', 'y', 'z', 'Polar', 'Azi', 'Intensity',
'H', 'K', 'L', 'Diff']
peak_list = self.refine.get_peaks()
self.refine.assign_rings()
self.rings = self.refine.get_ring_hkls()
orient_layout = QtGui.QHBoxLayout()
if self.refine.primary is None:
self.refine.primary = 0
if self.refine.secondary is None:
self.refine.secondary = 1
self.primary_box = QtGui.QLineEdit(str(self.refine.primary))
self.primary_box.setAlignment(QtCore.Qt.AlignRight)
self.primary_box.setFixedWidth(80)
self.secondary_box = QtGui.QLineEdit(str(self.refine.secondary))
self.secondary_box.setAlignment(QtCore.Qt.AlignRight)
self.secondary_box.setFixedWidth(80)
orient_button = QtGui.QPushButton('Orient')
orient_button.clicked.connect(self.orient)
orient_layout.addStretch()
orient_layout.addWidget(QtGui.QLabel('Primary'))
orient_layout.addWidget(self.primary_box)
orient_layout.addWidget(QtGui.QLabel('Secondary'))
orient_layout.addWidget(self.secondary_box)
orient_layout.addStretch()
orient_layout.addWidget(orient_button)
self.table_view = QtGui.QTableView()
self.table_model = NXTableModel(self, peak_list, header)
self.table_view.setModel(self.table_model)
self.table_view.resizeColumnsToContents()
self.table_view.horizontalHeader().stretchLastSection()
self.table_view.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
self.table_view.doubleClicked.connect(self.plot_peak)
self.table_view.setSortingEnabled(True)
self.table_view.sortByColumn(0, QtCore.Qt.AscendingOrder)
layout = QtGui.QVBoxLayout()
layout.addLayout(orient_layout)
layout.addWidget(self.table_view)
close_layout = QtGui.QHBoxLayout()
self.status_text = QtGui.QLabel('Score: %.4f' % self.refine.score())
self.tolerance_box = QtGui.QLineEdit(str(self.refine.hkl_tolerance))
self.tolerance_box.setAlignment(QtCore.Qt.AlignRight)
self.tolerance_box.setMaxLength(5)
self.tolerance_box.editingFinished.connect(self.update_table)
self.tolerance_box.setFixedWidth(80)
save_button = QtGui.QPushButton('Save Orientation')
save_button.clicked.connect(self.save_orientation)
close_button = QtGui.QPushButton('Close Window')
close_button.clicked.connect(self.close_peaks_box)
close_layout.addWidget(self.status_text)
close_layout.addStretch()
close_layout.addWidget(QtGui.QLabel('Threshold'))
close_layout.addWidget(self.tolerance_box)
close_layout.addStretch()
close_layout.addWidget(save_button)
close_layout.addStretch()
close_layout.addWidget(close_button)
layout.addLayout(close_layout)
self.peaks_box.setLayout(layout)
self.peaks_box.setWindowTitle('%s Peak Table' % self.entry.nxtitle)
self.peaks_box.adjustSize()
self.peaks_box.show()
self.plotview = None
def update_table(self):
self.transfer_parameters()
self.refine.hkl_tolerance = self.get_hkl_tolerance()
self.table_model.peak_list = self.refine.get_peaks()
rows, columns = len(self.table_model.peak_list), 11
self.table_model.dataChanged.emit(self.table_model.createIndex(0, 0),
self.table_model.createIndex(rows-1, columns-1))
self.status_text.setText('Score: %.4f' % self.refine.score())
def plot_peak(self):
row = self.table_view.currentIndex().row()
data = self.entry.data
x, y, z = [self.table_view.model().peak_list[row][i] for i in range(1, 4)]
xmin, xmax = max(0,x-200), min(x+200,data.nxsignal.shape[2])
ymin, ymax = max(0,y-200), min(y+200,data.nxsignal.shape[1])
zmin, zmax = max(0,z-200), min(z+200,data.nxsignal.shape[0])
zslab=np.s_[z,ymin:ymax,xmin:xmax]
if self.plotview is None:
self.plotview = NXPlotView('X-Y Projection')
self.plotview.plot(data[zslab], log=True)
self.plotview.crosshairs(x, y)
def orient(self):
self.refine.primary = int(self.primary_box.text())
self.refine.secondary = int(self.secondary_box.text())
self.refine.Umat = self.refine.get_UBmat(self.refine.primary,
self.refine.secondary) \
* self.refine.Bimat
self.update_table()
def save_orientation(self):
self.write_parameters()
def close_peaks_box(self):
self.peaks_box.close()
self.peaks_box = None
class CalculateDialog(BaseDialog):
def __init__(self, parent=None):
super(CalculateDialog, self).__init__(parent)
self.select_entry(self.choose_entry)
self.refine = NXRefine(self.entry)
self.refine.read_parameters()
self.parameters = GridParameters()
self.parameters.add('wavelength', self.refine.wavelength, 'Wavelength (Ang)')
self.parameters.add('distance', self.refine.distance, 'Detector Distance (mm)')
self.parameters.add('xc', self.refine.xc, 'Beam Center - x')
self.parameters.add('yc', self.refine.yc, 'Beam Center - y')
self.parameters.add('pixel', self.refine.pixel_size, 'Pixel Size (mm)')
action_buttons = self.action_buttons(('Plot', self.plot_lattice),
('Save', self.write_parameters))
self.set_layout(self.entry_layout, self.parameters.grid(),
action_buttons, self.close_buttons())
self.set_title('Calculate Angles')
def choose_entry(self):
self.refine = NXRefine(self.entry)
self.update_parameters()
def update_parameters(self):
self.parameters['wavelength'].value = self.refine.wavelength
self.parameters['distance'].value = self.refine.distance
self.parameters['xc'].value = self.refine.xc
self.parameters['yc'].value = self.refine.yc
self.parameters['pixel'].value = self.refine.pixel_size
def get_wavelength(self):
return self.parameters['wavelength'].value
def get_distance(self):
return self.parameters['distance'].value
def get_centers(self):
return self.parameters['xc'].value, self.parameters['yc'].value
def get_pixel_size(self):
return self.parameters['pixel'].value
def get_parameters(self):
self.refine.wavelength = self.get_wavelength()
self.refine.distance = self.get_distance()
self.refine.xc, self.refine.yc = self.get_centers()
self.refine.pixel_size = self.get_pixel_size()
self.refine.yaw = self.refine.pitch = self.refine.roll = None
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 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 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)
class OrientationDialog(BaseDialog):
def __init__(self, parent=None):
super(OrientationDialog, self).__init__(parent)
self.select_entry(self.choose_entry)
self.refine = NXRefine(self.entry)
self.refine.read_parameters()
self.parameters = GridParameters()
self.parameters.add('phi_start', self.refine.phi_start, 'Phi Start (deg)')
self.parameters.add('phi_step', self.refine.phi_step, 'Phi Step (deg)')
self.parameters.add('chi_start', self.refine.chi_start, 'Chi Start (deg)')
self.parameters.add('chi_step', self.refine.chi_step, 'Chi Step (deg)')
self.parameters.add('omega_start', self.refine.omega_start, 'Omega Start (deg)')
self.parameters.add('omega_step', self.refine.omega_step, 'Omega Step (deg)')
self.parameters.add('polar', self.refine.polar_max, 'Max. Polar Angle (deg)')
self.parameters.add('polar_tolerance', self.refine.polar_tolerance, 'Polar Angle Tolerance')
self.parameters.add('peak_tolerance', self.refine.peak_tolerance, 'Peak Angle Tolerance')
action_buttons = self.action_buttons(
('Generate Grains', self.generate_grains),
('List Peaks', self.list_peaks))
self.grain_layout = QtGui.QHBoxLayout()
self.grain_combo = QtGui.QComboBox()
self.grain_combo.setSizeAdjustPolicy(QtGui.QComboBox.AdjustToContents)
self.grain_combo.currentIndexChanged.connect(self.set_grain)
self.grain_textbox = QtGui.QLabel()
self.grain_layout.addWidget(self.grain_combo)
self.grain_layout.addStretch()
self.grain_layout.addWidget(self.grain_textbox)
bottom_layout = QtGui.QHBoxLayout()
self.result_textbox = QtGui.QLabel()
bottom_layout.addWidget(self.result_textbox)
bottom_layout.addStretch()
bottom_layout.addWidget(self.close_buttons())
self.set_layout(self.entry_layout, self.parameters.grid(),
action_buttons, bottom_layout)
self.set_title('Defining Orientation')
def choose_entry(self):
self.refine = NXRefine(self.entry)
self.update_parameters()
def update_parameters(self):
self.parameters['phi_start'].value = self.refine.phi_start
self.parameters['phi_step'].value = self.refine.phi_step
self.parameters['chi_start'].value = self.refine.chi_start
self.parameters['chi_step'].value = self.refine.chi_step
self.parameters['omega_start'].value = self.refine.omega_start
self.parameters['omega_step'].value = self.refine.omega_step
self.parameters['polar'].value = self.refine.polar_max
self.parameters['polar_tolerance'].value = self.refine.polar_tolerance
self.parameters['peak_tolerance'].value = self.refine.peak_tolerance
def get_phi(self):
return (self.parameters['phi_start'].value,
self.parameters['phi_step'].value)
def set_phi(self):
self.refine.phi_start, self.refine.phi_step = self.get_phi()
def get_chi(self):
return (self.parameters['chi_start'].value,
self.parameters['chi_step'].value)
def set_chi(self):
self.refine.chi_start, self.refine.chi_step = self.get_chi()
def get_omega(self):
return (self.parameters['omega_start'].value,
self.parameters['omega_step'].value)
def set_omega(self):
self.refine.omega_start, self.refine.omega_step = self.get_omega()
@property
def polar_max(self):
return self.parameters['polar'].value
def set_polar_max(self):
self.refine.polar_max = self.polar_max
def get_polar_tolerance(self):
return self.parameters['polar_tolerance'].value
def set_polar_tolerance(self):
self.refine.polar_tolerance = self.get_polar_tolerance()
def get_peak_tolerance(self):
return self.parameters['peak_tolerance'].value
def set_peak_tolerance(self):
self.refine.peak_tolerance = self.get_peak_tolerance()
def generate_grains(self):
self.set_polar_max()
self.refine.generate_grains()
if self.refine.grains is not None:
self.layout.insertLayout(2, self.grain_layout)
self.grain_combo.clear()
for i in range(len(self.refine.grains)):
self.grain_combo.addItem('Grain %s' % i)
self.grain_combo.setCurrentIndex(0)
self.set_grain()
def set_grain(self):
try:
grain = self.refine.grains[self.get_grain()]
self.grain_textbox.setText('%s peaks; Score: %.4f'
% (len(grain), grain.score))
self.refine.Umat = grain.Umat
self.refine.primary = grain.primary
self.refine.secondary = grain.secondary
self.get_score()
except:
self.grain_textbox.setText('')
def get_grain(self):
return int(self.grain_combo.currentText().split()[-1])
def list_peaks(self):
self.refine.phi_start, self.refine.phi_step = self.get_phi()
self.refine.chi_start, self.refine.chi_step = self.get_chi()
self.refine.omega_start, self.refine.omega_step = self.get_omega()
if self.refine.grains is not None:
grain = self.refine.grains[self.get_grain()]
self.refine.Umat = grain.Umat
self.list_orientations()
else:
self.list_orientations()
def get_score(self):
if self.refine.Umat is not None:
self.score = self.refine.score()
self.result_textbox.setText('%s peaks; Score: %.4f'
% (len(self.refine.idx), self.score))
def list_orientations(self):
message_box = BaseDialog(self)
message_box.setMinimumWidth(600)
message_box.setMinimumHeight(600)
header = ['i', 'x', 'y', 'z', 'Polar', 'Azi', 'Intensity',
'H', 'K', 'L', 'Diff']
peak_list = self.refine.get_peaks()
self.refine.assign_rings()
self.rings = self.refine.get_ring_hkls()
orient_layout = QtGui.QHBoxLayout()
if self.refine.primary is None:
self.refine.primary = 0
if self.refine.secondary is None:
self.refine.secondary = 1
self.primary_box = QtGui.QLineEdit(str(self.refine.primary))
self.primary_box.setAlignment(QtCore.Qt.AlignRight)
self.primary_box.setFixedWidth(80)
self.secondary_box = QtGui.QLineEdit(str(self.refine.secondary))
self.secondary_box.setAlignment(QtCore.Qt.AlignRight)
self.secondary_box.setFixedWidth(80)
orient_button = QtGui.QPushButton('Orient')
orient_button.clicked.connect(self.orient)
refine_button = QtGui.QPushButton('Refine')
refine_button.clicked.connect(self.refine_orientation)
restore_button = QtGui.QPushButton('Restore')
restore_button.clicked.connect(self.restore_orientation)
orient_layout.addStretch()
orient_layout.addWidget(QtGui.QLabel('Primary'))
orient_layout.addWidget(self.primary_box)
orient_layout.addWidget(QtGui.QLabel('Secondary'))
orient_layout.addWidget(self.secondary_box)
orient_layout.addStretch()
orient_layout.addWidget(orient_button)
orient_layout.addWidget(refine_button)
orient_layout.addWidget(restore_button)
grid = QtGui.QGridLayout()
grid.setSpacing(10)
self.lattice = GridParameters()
self.lattice.add('a', self.refine.a, 'a', False)
self.lattice.add('b', self.refine.b, 'b', False)
self.lattice.add('c', self.refine.c, 'c', False)
self.lattice.add('alpha', self.refine.alpha, 'alpha', False)
self.lattice.add('beta', self.refine.beta, 'beta', False)
self.lattice.add('gamma', self.refine.gamma, 'gamma', False)
p = self.lattice['a']
p.box.setFixedWidth(80)
label, value, checkbox = p.label, p.value, p.vary
grid.addWidget(p.label, 0, 0, QtCore.Qt.AlignRight)
grid.addWidget(p.box, 0, 1, QtCore.Qt.AlignHCenter)
grid.addWidget(p.checkbox, 0, 2, QtCore.Qt.AlignHCenter)
p = self.lattice['b']
p.box.setFixedWidth(80)
label, value, checkbox = p.label, p.value, p.vary
grid.addWidget(p.label, 0, 3, QtCore.Qt.AlignRight)
grid.addWidget(p.box, 0, 4, QtCore.Qt.AlignHCenter)
grid.addWidget(p.checkbox, 0, 5, QtCore.Qt.AlignHCenter)
p = self.lattice['c']
p.box.setFixedWidth(80)
label, value, checkbox = p.label, p.value, p.vary
grid.addWidget(p.label, 0, 6, QtCore.Qt.AlignRight)
grid.addWidget(p.box, 0, 7, QtCore.Qt.AlignHCenter)
grid.addWidget(p.checkbox, 0, 8, QtCore.Qt.AlignHCenter)
p = self.lattice['alpha']
p.box.setFixedWidth(80)
label, value, checkbox = p.label, p.value, p.vary
grid.addWidget(p.label, 1, 0, QtCore.Qt.AlignRight)
grid.addWidget(p.box, 1, 1, QtCore.Qt.AlignHCenter)
grid.addWidget(p.checkbox, 1, 2, QtCore.Qt.AlignHCenter)
p = self.lattice['beta']
p.box.setFixedWidth(80)
label, value, checkbox = p.label, p.value, p.vary
grid.addWidget(p.label, 1, 3, QtCore.Qt.AlignRight)
grid.addWidget(p.box, 1, 4, QtCore.Qt.AlignHCenter)
grid.addWidget(p.checkbox, 1, 5, QtCore.Qt.AlignHCenter)
p = self.lattice['gamma']
p.box.setFixedWidth(80)
label, value, checkbox = p.label, p.value, p.vary
grid.addWidget(p.label, 1, 6, QtCore.Qt.AlignRight)
grid.addWidget(p.box, 1, 7, QtCore.Qt.AlignHCenter)
grid.addWidget(p.checkbox, 1, 8, QtCore.Qt.AlignHCenter)
self.table_view = QtGui.QTableView()
self.table_model = NXTableModel(self, peak_list, header)
self.table_view.setModel(self.table_model)
self.table_view.resizeColumnsToContents()
self.table_view.horizontalHeader().stretchLastSection()
self.table_view.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
self.table_view.doubleClicked.connect(self.plot_peak)
self.table_view.setSortingEnabled(True)
self.table_view.sortByColumn(0, QtCore.Qt.AscendingOrder)
layout = QtGui.QVBoxLayout()
layout.addLayout(orient_layout)
layout.addLayout(grid)
layout.addWidget(self.table_view)
close_layout = QtGui.QHBoxLayout()
self.status_text = QtGui.QLabel('Score: %.4f' % self.refine.score())
self.tolerance_box = QtGui.QLineEdit(str(self.refine.hkl_tolerance))
self.tolerance_box.setAlignment(QtCore.Qt.AlignRight)
self.tolerance_box.setMaxLength(5)
self.tolerance_box.editingFinished.connect(self.update_table)
self.tolerance_box.setFixedWidth(80)
save_button = QtGui.QPushButton('Save Orientation')
save_button.clicked.connect(self.save_orientation)
close_button = QtGui.QPushButton('Close Window')
close_button.clicked.connect(message_box.close)
close_layout.addWidget(self.status_text)
close_layout.addStretch()
close_layout.addWidget(QtGui.QLabel('Threshold'))
close_layout.addWidget(self.tolerance_box)
close_layout.addStretch()
close_layout.addWidget(save_button)
close_layout.addStretch()
close_layout.addWidget(close_button)
layout.addLayout(close_layout)
message_box.setLayout(layout)
message_box.setWindowTitle('%s Peak Table' % self.entry.nxtitle)
message_box.adjustSize()
message_box.show()
self.plotview = None
def plot_peak(self):
row = self.table_view.currentIndex().row()
data = self.entry.data
x, y, z = [self.table_view.model().peak_list[row][i] for i in range(1, 4)]
xmin, xmax = max(0,x-200), min(x+200,data.nxsignal.shape[2])
ymin, ymax = max(0,y-200), min(y+200,data.nxsignal.shape[1])
zmin, zmax = max(0,z-200), min(z+200,data.nxsignal.shape[0])
zslab=np.s_[z,ymin:ymax,xmin:xmax]
if self.plotview is None:
self.plotview = NXPlotView('X-Y Projection')
self.plotview.plot(data[zslab], log=True)
self.plotview.crosshairs(x, y)
def orient(self):
self.refine.primary = int(self.primary_box.text())
self.refine.secondary = int(self.secondary_box.text())
self.refine.Umat = self.refine.get_UBmat(self.refine.primary,
self.refine.secondary) \
* self.refine.Bimat
self.update_table()
def refine_orientation(self):
idx = self.refine.idx
intensities = self.refine.intensity[idx]
sigma = np.average(intensities) / intensities
p0 = self.set_parameters(idx)
def diffs(p):
self.get_parameters(p)
UBimat = np.linalg.inv(self.refine.UBmat)
Q = [UBimat * self.Gvec[i] for i in idx]
dQ = Q - np.rint(Q)
return np.array([np.linalg.norm(self.refine.Bmat*np.matrix(dQ[i]))
for i in idx]) / sigma
popt, C, info, msg, success = leastsq(diffs, p0, full_output=1)
self.get_parameters(popt)
self.update_lattice()
self.update_table()
self.status_text.setText('Score: %.4f' % self.refine.score())
def restore_orientation(self):
self.refine.Umat = self.Umat
for par in self.lattice.values():
par.value = par.init_value
self.update_table()
def update_table(self):
self.refine.hkl_tolerance = np.float32(self.tolerance_box.text())
self.table_model.peak_list = self.refine.get_peaks()
rows, columns = len(self.table_model.peak_list), 11
self.table_model.dataChanged.emit(self.table_model.createIndex(0, 0),
self.table_model.createIndex(rows-1, columns-1))
self.status_text.setText('Score: %.4f' % self.refine.score())
def update_lattice(self):
self.lattice['a'].value = self.refine.a
self.lattice['b'].value = self.refine.b
self.lattice['c'].value = self.refine.c
self.lattice['alpha'].value = self.refine.alpha
self.lattice['beta'].value = self.refine.beta
self.lattice['gamma'].value = self.refine.gamma
def set_parameters(self, idx):
x, y, z = self.refine.xp[idx], self.refine.yp[idx], self.refine.zp[idx]
self.Gvec = [self.refine.Gvec(xx,yy,zz) for xx,yy,zz in zip(x,y,z)]
self.Umat = self.refine.Umat
pars = []
for par in self.lattice.values():
par.init_value = par.value
if par.vary:
pars.append(par.value)
p0 = np.zeros(shape=(len(pars)+9), dtype=np.float32)
p0[:len(pars)] = pars
p0[len(pars):] = np.ravel(self.refine.Umat)
return p0
def get_parameters(self, p):
i = 0
for par in self.lattice.values():
if par.vary:
par.value = p[i]
i += 1
self.refine.a, self.refine.b, self.refine.c, \
self.refine.alpha, self.refine.beta, self.refine.gamma = \
[par.value for par in self.lattice.values()]
self.refine.set_symmetry()
self.refine.Umat = np.matrix(p[i:]).reshape(3,3)
def save_orientation(self):
self.write_parameters()
def write_parameters(self):
try:
self.refine.write_parameters()
except NeXusError as error:
report_error('Defining Orientation', error)
class LatticeDialog(BaseDialog):
def __init__(self, parent=None):
super(LatticeDialog, self).__init__(parent)
self.select_entry(self.choose_entry)
self.refine = NXRefine(self.entry)
self.refine.read_parameters()
self.parameters = GridParameters()
self.parameters.add('centring', self.refine.centrings, 'Cell Centring')
self.parameters['centring'].value = self.refine.centring
self.parameters.add('a', self.refine.a, 'Unit Cell - a (Ang)')
self.parameters.add('b', self.refine.b, 'Unit Cell - b (Ang)')
self.parameters.add('c', self.refine.c, 'Unit Cell - c (Ang)')
self.parameters.add('alpha', self.refine.alpha, 'Unit Cell - alpha (deg)')
self.parameters.add('beta', self.refine.beta, 'Unit Cell - beta (deg)')
self.parameters.add('gamma', self.refine.gamma, 'Unit Cell - gamma (deg)')
action_buttons = self.action_buttons(('Plot', self.plot_lattice),
('Save', self.write_parameters))
self.set_layout(self.entry_layout, self.parameters.grid(),
action_buttons, self.close_buttons())
self.set_title('Defining Lattice')
def choose_entry(self):
self.refine = NXRefine(self.entry)
self.update_parameters()
def update_parameters(self):
self.parameters['centring'].value = self.refine.centring
self.parameters['a'].value = self.refine.a
self.parameters['b'].value = self.refine.b
self.parameters['c'].value = self.refine.c
self.parameters['alpha'].value = self.refine.alpha
self.parameters['beta'].value = self.refine.beta
self.parameters['gamma'].value = self.refine.gamma
def get_centring(self):
return self.parameters['centring'].value
def get_lattice_parameters(self):
return (self.parameters['a'].value,
self.parameters['b'].value,
self.parameters['c'].value,
self.parameters['alpha'].value,
self.parameters['beta'].value,
self.parameters['gamma'].value)
def get_parameters(self):
self.refine.a, self.refine.b, self.refine.c, \
self.refine.alpha, self.refine.beta, self.refine.gamma = self.get_lattice_parameters()
self.refine.centring = self.get_centring()
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 write_parameters(self):
try:
self.get_parameters()
self.refine.write_parameters()
except NeXusError as error:
report_error('Defining 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 plot_rings(self, polar_max=None):
if polar_max is None:
polar_max = self.refine.polar_max
peaks = self.refine.calculate_rings(polar_max)
plotview = get_plotview()
plotview.vlines(peaks, colors='r', linestyles='dotted')
plotview.draw()
def choose_entry(self):
self.refine = NXRefine(self.entry)
self.update_parameters()
def main():
parser = argparse.ArgumentParser(
description="Copy sample and instrument parameters to another file or entry")
parser.add_argument('-f', '--filename', required=True,
help='name of the input NeXus file')
parser.add_argument('-e', '--entry',
help='path of input NXentry group')
parser.add_argument('-t', '--target', help='path of target NXentry group')
parser.add_argument('-o', '--output', help='output NeXus file (if different)')
args = parser.parse_args()
if args.output:
input = nxload(args.filename)
input_ref = NXRefine(input['entry'])
output = nxload(args.output, 'rw')
output_entry_ref = NXRefine(output['entry'])
input_ref.copy_parameters(output_entry_ref, sample=True)
for name in [entry for entry in input if entry != 'entry']:
if name in output:
input_ref = NXRefine(input[name])
output_ref = NXRefine(output[name])
input_ref.copy_parameters(output_ref, instrument=True)
output_entry_ref.link_sample(output_ref)
else:
input = nxload(args.filename, 'rw')
input_ref = NXRefine(input[args.entry])
output_ref = NXRefine(input[args.target])
input_ref.copy_parameters(output_ref, instrument=True)
if 'sample' not in input[args.target] and 'sample' in input['entry']:
input_ref = NXRefine(input['entry'])
input_ref.link_sample(output_ref)
def prepare_transform(entry, Qh, Qk, Ql, output, settings):
refine = NXRefine(entry)
refine.read_parameters()
refine.output_file = output
refine.settings_file = settings
refine.h_start, refine.h_step, refine.h_stop = Qh
refine.k_start, refine.k_step, refine.k_stop = Qk
refine.l_start, refine.l_step, refine.l_stop = Ql
refine.define_grid()
refine.prepare_transform(output)
refine.write_settings(settings)
refine.write_parameters()
class TransformDialog(BaseDialog):
def __init__(self, parent=None):
super(TransformDialog, self).__init__(parent)
self.select_entry(self.initialize_grid)
self.refine = NXRefine(self.entry)
self.refine.read_parameters()
grid = QtGui.QGridLayout()
grid.setSpacing(10)
header_font = QtGui.QFont()
header_font.setBold(True)
start_label = QtGui.QLabel('Start')
start_label.setFont(header_font)
grid.addWidget(start_label, 0, 1)
step_label = QtGui.QLabel('Step')
step_label.setFont(header_font)
grid.addWidget(step_label, 0, 2)
stop_label = QtGui.QLabel('Stop')
stop_label.setFont(header_font)
grid.addWidget(stop_label, 0, 3)
grid.addWidget(QtGui.QLabel('H:'), 1, 0)
grid.addWidget(QtGui.QLabel('K:'), 2, 0)
grid.addWidget(QtGui.QLabel('L:'), 3, 0)
self.start_h_box = QtGui.QLineEdit()
self.step_h_box = QtGui.QLineEdit()
self.stop_h_box = QtGui.QLineEdit()
grid.addWidget(self.start_h_box, 1, 1)
grid.addWidget(self.step_h_box, 1, 2)
grid.addWidget(self.stop_h_box, 1, 3)
self.start_k_box = QtGui.QLineEdit()
self.step_k_box = QtGui.QLineEdit()
self.stop_k_box = QtGui.QLineEdit()
grid.addWidget(self.start_k_box, 2, 1)
grid.addWidget(self.step_k_box, 2, 2)
grid.addWidget(self.stop_k_box, 2, 3)
self.start_l_box = QtGui.QLineEdit()
self.step_l_box = QtGui.QLineEdit()
self.stop_l_box = QtGui.QLineEdit()
grid.addWidget(self.start_l_box, 3, 1)
grid.addWidget(self.step_l_box, 3, 2)
grid.addWidget(self.stop_l_box, 3, 3)
self.set_layout(self.entry_layout, grid, self.close_buttons(save=True))
self.setWindowTitle('Transforming Data')
try:
self.initialize_grid()
except Exception:
pass
def get_output_file(self):
return os.path.splitext(self.entry.data.nxsignal.nxfilename)[0]+'_transform.nxs'
def get_settings_file(self):
return os.path.splitext(self.entry.data.nxsignal.nxfilename)[0]+'_transform.pars'
def get_h_grid(self):
return (np.float32(self.start_h_box.text()),
np.float32(self.step_h_box.text()),
np.float32(self.stop_h_box.text()))
def get_k_grid(self):
return (np.float32(self.start_k_box.text()),
np.float32(self.step_k_box.text()),
np.float32(self.stop_k_box.text()))
def get_l_grid(self):
return (np.float32(self.start_l_box.text()),
np.float32(self.step_l_box.text()),
np.float32(self.stop_l_box.text()))
def initialize_grid(self):
self.refine = NXRefine(self.entry)
self.refine.initialize_grid()
self.start_h_box.setText(str(self.refine.h_start))
self.step_h_box.setText(str(self.refine.h_step))
self.stop_h_box.setText(str(self.refine.h_stop))
self.start_k_box.setText(str(self.refine.k_start))
self.step_k_box.setText(str(self.refine.k_step))
self.stop_k_box.setText(str(self.refine.k_stop))
self.start_l_box.setText(str(self.refine.l_start))
self.step_l_box.setText(str(self.refine.l_step))
self.stop_l_box.setText(str(self.refine.l_stop))
def write_parameters(self):
self.refine.output_file = self.get_output_file()
self.refine.settings_file = self.get_settings_file()
self.refine.h_start, self.refine.h_step, self.refine.h_stop = self.get_h_grid()
self.refine.k_start, self.refine.k_step, self.refine.k_stop = self.get_k_grid()
self.refine.l_start, self.refine.l_step, self.refine.l_stop = self.get_l_grid()
self.refine.define_grid()
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)
