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 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: 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 = 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 = 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 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)