Пример #1
0
 def init_dir(self):
     """Initialize NeXpy home directory"""
     home_dir = os.path.abspath(os.path.expanduser('~'))
     nexpy_dir = os.path.join(home_dir, '.nexpy')
     if not os.path.exists(nexpy_dir):
         parent = os.path.dirname(nexpy_dir)
         if not os.access(parent, os.W_OK):
             nexpy_dir = tempfile.mkdtemp()
         else:
             os.mkdir(nexpy_dir)
     for subdirectory in ['backups', 'functions', 'plugins', 'readers', 
                          'scripts']:
         directory = os.path.join(nexpy_dir, subdirectory)
         if not os.path.exists(directory):
             os.mkdir(directory)
     global _nexpy_dir
     self.nexpy_dir = _nexpy_dir = nexpy_dir
     self.backup_dir = os.path.join(self.nexpy_dir, 'backups')
     self.plugin_dir = os.path.join(self.nexpy_dir, 'plugins')
     self.reader_dir = os.path.join(self.nexpy_dir, 'readers')
     self.script_dir = os.path.join(self.nexpy_dir, 'scripts')
     self.function_dir = os.path.join(self.nexpy_dir, 'functions')
     sys.path.append(self.function_dir)
     self.scratch_file = os.path.join(self.nexpy_dir, 'w0.nxs')
     if not os.path.exists(self.scratch_file):
         NXroot().save(self.scratch_file)
Пример #2
0
    def save_map(self):
        X,Y,Z, xi, yi = self.plot_map()
        try:
            self.tree.map2ddata = NXroot()
            self.tree.map2ddata['roi' + '_' + str(self.roi_dn) + ':' + str(self.roi_up)] = NXentry()
            self.tree.map2ddata['roi' + '_' + str(self.roi_dn) + ':' + str(self.roi_up)]['data'] = NXdata(Z, [yi,xi])

        except:
            try:
                self.tree.map2ddata['roi' + '_' + str(self.roi_dn) + ':' + str(self.roi_up)] = NXentry()
                self.tree.map2ddata['roi' + '_' + str(self.roi_dn) + ':' + str(self.roi_up)]['data'] = NXdata(Z, [yi,xi])
            except:
                del  self.tree.map2ddata['roi' + '_' + str(self.roi_dn) + ':' + str(self.roi_up)]
                self.tree.map2ddata['roi' + '_' + str(self.roi_dn) + ':' + str(self.roi_up)] = NXentry()
                self.tree.map2ddata['roi' + '_' + str(self.roi_dn) + ':' + str(self.roi_up)]['data'] = NXdata(Z, [yi,xi])
        
        plt.figure()
        plt.contourf(X,Y,Z)
        plt.gca().invert_yaxis()
        plt.gca().invert_xaxis()
        plt.xlabel('x (mm)')
        plt.ylabel('y (mm)')
        plt.title("2D Contour Map")
        plt.colorbar()
        plt.show()
        return self.tree.map2ddata 
Пример #3
0
 def plot_xas(self):
     self.x1 = np.array(self.energy)
     self.y1 = np.array(self.entry['instrument/absorbed_beam'][self.signal])
     try:
         self.tree.singleXas = NXroot(NXentry(NXdata(yi, xi)))
     except:
         self.tree.singleXas['entry/data'][self.signal] = NXfield(yi)
     
     self.tree.singleXas.oplot(xmin = min(self.x1), xmax=max(self.x1), ymin = min(self.y1), ymax = max(self.y1))
     return x1, y1
Пример #4
0
 def add(self, node):
     if isinstance(node, NXgroup):
         shell_names = self.get_shell_names(node)
         if shell_names:
             node.nxname = shell_names[0]
         if isinstance(node, NXroot):
             self[node.nxname] = node
             self[node.nxname]._file_modified = False
         elif isinstance(node, NXentry):
             group = NXroot(node)
             name = self.get_new_name()
             self[name] = group
             print("NeXpy: '%s' added to tree in '%s'" %
                   (node.nxname, group.nxname))
         else:
             group = NXroot(NXentry(node))
             name = self.get_new_name()
             self[name] = group
             print("NeXpy: '%s' added to tree in '%s%s'" %
                   (node.nxname, group.nxname, node.nxgroup.nxpath))
     else:
         raise NeXusError("Only an NXgroup can be added to the tree")
Пример #5
0
    def __init__(self, parent=None):
        super().__init__(parent)

        self.settings = NXSettings().settings

        self.configuration_file = NXroot()
        self.configuration_file['entry'] = NXentry()

        self.detectors = {}
        self.entries = {}

        self.setup_groups()
        self.setup_configuration()
        self.setup_analysis()
        self.setup_scan()
        self.setup_instrument()

        self.set_layout(
            self.directorybox('Choose Experiment Directory', default=False),
            self.configuration.grid(header=False),
            self.analysis.grid(header=False, title='Analysis Settings'),
            self.scan.grid(header=False, title='Scan Settings'),
            self.instrument.grid(header=False, title='Detector Settings'))
        self.set_title('New Configuration')
Пример #6
0
 def __init__(self, exptitle, *items, **opts):
     self._entry = NXentry(*items, **opts)
     self._entry.FileName = string_('')
     self._entry.data = NXdata()
     self._entry.user1 = NXuser(role=string_('local_contact'))
     self._entry.user2 = NXuser(role=string_('experiment_team'))
     # TODO data will not written correctly !!!
     # look into NexusFile class, where the list of axes has to be written
     self._entry.monitor = NXmonitor()  # axes='channel_number')
     self._entry.instrument = NXinstrument(platform=string_('Linux'))
     self._entry.instrument.name = string_('TOFTOF')
     self._entry.instrument.chopper = NXdisk_chopper()
     self._entry.instrument.detector = NXdetector()
     self._entry.sample = NXsample()
     self.root = NXroot(self._entry)
Пример #7
0
 def save_fit(self):
     """Saves fit results to an NXentry"""
     self.read_parameters()
     entry = NXentry()
     entry['data'] = self.data
     for f in self.functions:
         entry[f.name] = self.get_model(f)
         parameters = NXparameters()
         for p in f.parameters:
             parameters[p.name] = NXfield(p.value,
                                          error=p.stderr,
                                          initial_value=p.init_value,
                                          min=str(p.min),
                                          max=str(p.max))
         entry[f.name].insert(parameters)
     if self.fit is not None:
         entry['title'] = 'Fit Results'
         entry['fit'] = self.get_model()
         fit = NXparameters()
         fit.nfev = self.fit.result.nfev
         fit.ier = self.fit.result.ier
         fit.chisq = self.fit.result.chisqr
         fit.redchi = self.fit.result.redchi
         fit.message = self.fit.result.message
         fit.lmdif_message = self.fit.result.lmdif_message
         entry['statistics'] = fit
     else:
         entry['title'] = 'Fit Model'
         entry['model'] = self.get_model()
     if 'w0' not in self.tree.keys():
         self.tree.add(NXroot(name='w0'))
     ind = []
     for key in self.tree['w0'].keys():
         try:
             if key.startswith('f'):
                 ind.append(int(key[1:]))
         except ValueError:
             pass
     if not ind:
         ind = [0]
     name = 'f' + str(sorted(ind)[-1] + 1)
     self.tree['w0'][name] = entry
Пример #8
0
class ConfigurationDialog(NXDialog):
    def __init__(self, parent=None):
        super().__init__(parent)

        self.settings = NXSettings().settings

        self.configuration_file = NXroot()
        self.configuration_file['entry'] = NXentry()

        self.detectors = {}
        self.entries = {}

        self.setup_groups()
        self.setup_configuration()
        self.setup_analysis()
        self.setup_scan()
        self.setup_instrument()

        self.set_layout(
            self.directorybox('Choose Experiment Directory', default=False),
            self.configuration.grid(header=False),
            self.analysis.grid(header=False, title='Analysis Settings'),
            self.scan.grid(header=False, title='Scan Settings'),
            self.instrument.grid(header=False, title='Detector Settings'))
        self.set_title('New Configuration')

    def setup_groups(self):
        entry = self.configuration_file['entry']
        entry['nxreduce'] = NXparameters()
        entry['instrument'] = NXinstrument()
        entry['instrument/monochromator'] = NXmonochromator()
        entry['instrument/goniometer'] = NXgoniometer()
        entry['instrument/detector'] = NXdetector()

    def setup_configuration(self):
        default = self.settings['nxrefine']
        entry = self.configuration_file['entry']
        entry['instrument/monochromator/wavelength'] = NXfield(
            default['wavelength'], dtype=np.float32)
        entry['instrument/monochromator/wavelength'].attrs['units'] = (
            'Angstroms')
        entry['instrument/monochromator/energy'] = NXfield(12.398419739640717 /
                                                           0.5,
                                                           dtype=np.float32)
        entry['instrument/monochromator/energy'].attrs['units'] = 'keV'
        entry['instrument/goniometer'] = NXgoniometer()
        entry['instrument/detector'] = NXdetector()
        self.configuration = GridParameters()
        self.configuration.add('configuration', 'configuration',
                               'Configuration Filename')
        self.configuration.add('wavelength',
                               entry['instrument/monochromator/wavelength'],
                               'Wavelength (Å)')

    def setup_analysis(self):
        default = self.settings['nxreduce']
        entry = self.configuration_file['entry']
        entry['nxreduce/threshold'] = NXfield(default['threshold'],
                                              dtype=float)
        entry['nxreduce/monitor'] = NXfield(default['monitor'])
        entry['nxreduce/norm'] = NXfield(default['norm'], dtype=float)
        entry['nxreduce/first_frame'] = NXfield(default['first'], dtype=int)
        entry['nxreduce/last_frame'] = NXfield(default['last'], dtype=int)
        entry['nxreduce/radius'] = NXfield(default['radius'], dtype=float)
        self.analysis = GridParameters()
        self.analysis.add('threshold', entry['nxreduce/threshold'],
                          'Peak Threshold')
        self.analysis.add('first', entry['nxreduce/first_frame'],
                          'First Frame')
        self.analysis.add('last', entry['nxreduce/last_frame'], 'Last Frame')
        self.analysis.add('monitor', ['monitor1', 'monitor2'],
                          'Normalization Monitor')
        self.analysis['monitor'].value = default['monitor']
        self.analysis.add('norm', entry['nxreduce/norm'],
                          'Normalization Value')
        self.analysis.add('radius', entry['nxreduce/radius'],
                          'Punch Radius (Å)')

    def setup_scan(self):
        default = self.settings['nxrefine']
        entry = self.configuration_file['entry']
        entry['instrument/goniometer/chi'] = (NXfield(default['chi'],
                                                      dtype=float))
        entry['instrument/goniometer/chi'].attrs['units'] = 'degree'
        entry['instrument/goniometer/phi'] = (NXfield(default['phi'],
                                                      dtype=float))
        entry['instrument/goniometer/phi'].attrs['step'] = (NXfield(
            default['phi_step'], dtype=float))
        entry['instrument/goniometer/phi'].attrs['end'] = (NXfield(
            default['phi_end'], dtype=float))
        entry['instrument/goniometer/phi'].attrs['units'] = 'degree'
        entry['instrument/detector/frame_time'] = (NXfield(
            1 / float(default['frame_rate']), dtype=float))
        self.scan = GridParameters()
        self.scan.add('chi', default['chi'], 'Chi (deg)')
        self.scan.add('phi_start', default['phi'], 'Phi Start (deg)')
        self.scan.add('phi_end', default['phi_end'], 'Phi End (deg)')
        self.scan.add('phi_step', default['phi_step'], 'Phi Step (deg)')
        self.scan.add('frame_rate', default['frame_rate'], 'Frame Rate (Hz)')

    def setup_instrument(self):
        default = self.settings['nxrefine']
        entry = self.configuration_file['entry']
        entry['instrument/detector/distance'] = NXfield(default['distance'],
                                                        dtype=float)
        entry['instrument/detector/distance'].attrs['units'] = 'mm'
        self.instrument = GridParameters()
        self.instrument.add('distance', entry['instrument/detector/distance'],
                            'Detector Distance (mm)')
        detector_list = sorted(
            list(set([detector().name
                      for detector in ALL_DETECTORS.values()])))
        self.instrument.add('detector', detector_list, 'Detector')
        self.instrument['detector'].value = 'Pilatus CdTe 2M'
        self.instrument.add('positions', [0, 1, 2, 3, 4, 5, 6, 7, 8],
                            'Number of Detector Positions',
                            slot=self.set_entries)
        self.instrument['positions'].value = '0'

    def setup_entry(self, position):
        default = self.settings['nxrefine']
        entry = NXentry()
        self.detectors[position] = GridParameters()
        self.detectors[position].add('x', default['x'], 'Translation - x (mm)')
        self.detectors[position].add('y', default['y'], 'Translation - y (mm)')
        self.detectors[position].add('omega', default['omega'], 'Omega (deg)')
        self.configuration_file[f'f{position}'] = entry

    def get_detector(self):
        for detector in ALL_DETECTORS:
            if (ALL_DETECTORS[detector]().name ==
                    self.instrument['detector'].value):
                return ALL_DETECTORS[detector]()

    @property
    def positions(self):
        return int(self.instrument['positions'].value)

    @property
    def position(self):
        try:
            return int(self.entry_box.currentText())
        except ValueError:
            return 1

    def set_entries(self):
        self.entry_box = self.select_box(
            [str(i) for i in range(1, self.positions + 1)],
            slot=self.choose_position)
        self.entry_layout = self.make_layout(
            self.labels('Position', header=True), self.entry_box)
        self.add_layout(self.entry_layout)
        for position in range(1, self.positions + 1):
            self.setup_entry(position)
            self.add_layout(self.detectors[position].grid(header=False))
            if position != 1:
                self.detectors[position].hide_grid()
        self.add_layout(self.close_buttons(save=True))

    def choose_position(self):
        for i in self.detectors:
            self.detectors[i].hide_grid()
        if self.position in self.detectors:
            self.detectors[self.position].show_grid()

    def get_parameters(self):
        entry = self.configuration_file['entry']
        entry['nxreduce/threshold'] = self.analysis['threshold'].value
        entry['nxreduce/first_frame'] = self.analysis['first'].value
        entry['nxreduce/last_frame'] = self.analysis['last'].value
        entry['nxreduce/monitor'] = self.analysis['monitor'].value
        entry['nxreduce/norm'] = self.analysis['norm'].value
        entry['nxreduce/radius'] = self.analysis['radius'].value
        entry['instrument/monochromator/wavelength'] = (
            self.configuration['wavelength'].value)
        entry['instrument/monochromator/energy'] = (
            12.398419739640717 / self.configuration['wavelength'].value)
        detector = self.get_detector()
        entry['instrument/detector/description'] = detector.name
        entry['instrument/detector/distance'] = (
            self.instrument['distance'].value)
        entry['instrument/detector/pixel_size'] = detector.pixel1 * 1000
        entry['instrument/detector/pixel_size'].attrs['units'] = 'mm'
        entry['instrument/detector/pixel_mask'] = detector.mask
        entry['instrument/detector/shape'] = detector.shape
        entry['instrument/detector/yaw'] = 0.0
        entry['instrument/detector/pitch'] = 0.0
        entry['instrument/detector/roll'] = 0.0
        for position in range(1, self.positions + 1):
            entry = self.configuration_file[f'f{position}']
            entry['instrument'] = self.configuration_file['entry/instrument']
            entry['instrument/detector/translation_x'] = (
                self.detectors[position]['x'].value)
            entry['instrument/detector/translation_x'].attrs['units'] = 'mm'
            entry['instrument/detector/translation_y'] = (
                self.detectors[position]['y'].value)
            entry['instrument/detector/translation_y'].attrs['units'] = 'mm'
            if self.scan['frame_rate'].value > 0.0:
                entry['instrument/detector/frame_time'] = (
                    1.0 / self.scan['frame_rate'].value)
            else:
                entry['instrument/detector/frame_time'] = 0.1
            entry['instrument/detector/frame_time'].attrs['units'] = 's'
            entry['instrument/goniometer/phi'] = self.scan['phi_start'].value
            entry['instrument/goniometer/phi'].attrs['step'] = (
                self.scan['phi_step'].value)
            entry['instrument/goniometer/phi'].attrs['end'] = (
                self.scan['phi_end'].value)
            entry['instrument/goniometer/chi'] = self.scan['chi'].value
            entry['instrument/goniometer/omega'] = (
                self.detectors[position]['omega'].value)

    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)
Пример #9
0
class ScanDialog(NXDialog):

    def __init__(self, parent=None):
        super().__init__(parent)

        self.config_file = None
        self.positions = 1
        self.entries = {}

        self.settings = NXSettings()

        self.directory_box = self.directorybox('Choose Experiment Directory',
                                               self.choose_directory,
                                               default=False)
        self.sample_box = self.select_sample()
        self.sample_layout = self.make_layout(
            self.action_buttons(('Choose Sample', self.choose_sample)),
            self.sample_box)
        self.configuration_box = self.select_configuration()
        self.configuration_layout = self.make_layout(
            self.action_buttons(('Choose Experiment Configuration',
                                 self.choose_configuration)),
            self.configuration_box)
        self.scan_box = self.select_box(['1'], slot=self.choose_position)
        self.scan_layout = self.make_layout(
            self.labels('Position', header=True), self.scan_box)
        self.set_layout(self.directory_box,
                        self.close_buttons(close=True))

        self.set_title('New Scan')

    @property
    def configuration(self):
        return self.configuration_box.currentText()

    @property
    def sample(self):
        return self.sample_box.currentText().split('/')[0]

    @property
    def label(self):
        return self.sample_box.currentText().split('/')[1]

    @property
    def position(self):
        try:
            return int(self.scan_box.currentText())
        except ValueError:
            return 1

    def choose_directory(self):
        super().choose_directory()
        self.mainwindow.default_directory = self.get_directory()
        self.setup_directory()
        self.insert_layout(1, self.sample_layout)

    def setup_directory(self):
        self.sample_box.clear()
        samples = self.get_samples()
        for sample in samples:
            self.sample_box.addItem(sample)
        self.sample_box.adjustSize()
        configurations = self.get_configurations()
        self.configuration_box.clear()
        for configuration in configurations:
            self.configuration_box.addItem(configuration)

    def select_sample(self):
        return self.select_box(self.get_samples())

    def get_samples(self):
        home_directory = self.get_directory()
        if os.path.exists(home_directory):
            sample_directories = [f for f in os.listdir(home_directory)
                                  if (not f.startswith('.') and
                                      os.path.isdir(
                                      os.path.join(home_directory, f)))]
        else:
            return []
        samples = []
        for sample_directory in sample_directories:
            label_directories = [
                f
                for f in os.listdir(
                    os.path.join(home_directory, sample_directory))
                if os.path.isdir(
                    os.path.join(home_directory, sample_directory, f))]
            for label_directory in label_directories:
                samples.append(os.path.join(sample_directory, label_directory))
        return [sample.strip() for sample in samples]

    def choose_sample(self):
        self.insert_layout(2, self.configuration_layout)

    def select_configuration(self):
        return self.select_box(self.get_configurations())

    def get_configurations(self):
        home_directory = self.get_directory()
        if (os.path.exists(home_directory) and
                'configurations' in os.listdir(home_directory)):
            return sorted(
                [f
                 for f in os.listdir(
                     os.path.join(home_directory, 'configurations'))
                 if f.endswith('.nxs')])
        else:
            return []

    def choose_configuration(self):
        home_directory = self.get_directory()
        config_file = os.path.join(home_directory, 'configurations',
                                   self.configuration)
        if os.path.exists(config_file):
            self.config_file = nxload(config_file)
            self.positions = len(self.config_file.entries) - 1
            self.scan_box.clear()
            for position in range(1, self.positions+1):
                self.scan_box.addItem(f'{position}')
            self.scan_box.setCurrentIndex(0)
            self.copy_configuration()
        self.setup_scans()
        self.read_parameters()
        self.insert_layout(3, self.scan.grid(header=False))
        self.insert_layout(4, self.scan_layout)
        for p in range(1, self.positions+1):
            self.insert_layout(p+4, self.entries[p].grid_layout)
        self.insert_layout(self.positions+5,
                           self.action_buttons(('Make Scan File',
                                                self.make_scan)))

    def setup_scans(self):
        default = self.settings['nxrefine']
        self.scan = GridParameters()
        self.scan.add('scan', 'scan', 'Scan Label')
        self.scan.add('temperature', 300.0, 'Temperature (K)')
        self.scan.add('phi_start', default['phi'], 'Phi Start (deg)')
        self.scan.add('phi_end', default['phi_end'], 'Phi End (deg)')
        self.scan.add('phi_step', default['phi_step'], 'Phi Step (deg)')
        self.scan.add('frame_rate', default['frame_rate'], 'Frame Rate (Hz)')

        for position in range(1, self.positions+1):
            self.setup_position(position)

    def setup_position(self, position):
        default = self.settings['nxrefine']
        self.entries[position] = GridParameters()
        self.entries[position].add('chi', default['chi'], 'Chi (deg)')
        self.entries[position].add('omega', default['omega'], 'Omega (deg)')
        self.entries[position].add('x', default['x'], 'Translation - x (mm)')
        self.entries[position].add('y', default['y'], 'Translation - y (mm)')
        self.entries[position].add('linkfile', f'f{position:d}.h5',
                                   'Detector Filename')
        self.entries[position].add(
            'linkpath', '/entry/data/data', 'Detector Data Path')
        self.entries[position].grid(header=False)
        if position != 1:
            self.entries[position].hide_grid()

    def choose_position(self):
        for i in self.entries:
            self.entries[i].hide_grid()
        if self.position in self.entries:
            self.entries[self.position].show_grid()

    def copy_configuration(self):
        self.scan_file = NXroot()
        for entry in self.config_file.entries:
            self.scan_file[entry] = self.config_file[entry]

    def read_parameters(self):
        for position in range(1, self.positions+1):
            entry = self.scan_file[f'f{position:d}']
            if 'instrument/goniometer/chi' in entry:
                self.entries[position]['chi'].value = (
                    entry['instrument/goniometer/chi'])
            if 'instrument/goniometer/omega' in entry:
                self.entries[position]['omega'].value = (
                    entry['instrument/goniometer/omega'])
            if 'instrument/detector/translation_x' in entry:
                self.entries[position]['x'].value = (
                    entry['instrument/detector/translation_x'])
            if 'instrument/detector/translation_y' in entry:
                self.entries[position]['y'].value = (
                    entry['instrument/detector/translation_y'])

    def get_parameters(self):
        entry = self.scan_file['entry']
        if 'sample' not in entry:
            entry['sample'] = NXsample()
        entry['sample/name'] = self.sample
        entry['sample/label'] = self.label
        entry['sample/temperature'] = self.scan['temperature'].value
        entry['sample/temperature'].attrs['units'] = 'K'
        y_size, x_size = entry['instrument/detector/shape'].nxvalue
        scan = self.scan['scan'].value
        for position in range(1, self.positions+1):
            entry = self.scan_file[f'f{position:d}']
            entry.makelink(self.scan_file['entry/sample'])
            phi_start = self.scan['phi_start'].value
            phi_end = self.scan['phi_end'].value
            phi_step = self.scan['phi_step'].value
            chi = self.entries[position]['chi'].value
            omega = self.entries[position]['omega'].value
            frame_rate = self.scan['frame_rate'].value
            if 'goniometer' not in entry['instrument']:
                entry['instrument/goniometer'] = NXgoniometer()
            entry['instrument/goniometer/phi'] = phi_start
            entry['instrument/goniometer/phi_set'] = phi_start
            entry['instrument/goniometer/phi'].attrs['step'] = phi_step
            entry['instrument/goniometer/phi'].attrs['end'] = phi_end
            entry['instrument/goniometer/chi'] = chi
            entry['instrument/goniometer/chi_set'] = chi
            entry['instrument/goniometer/omega'] = omega
            entry['instrument/goniometer/omega_set'] = omega
            if frame_rate > 0.0:
                entry['instrument/detector/frame_time'] = 1.0 / frame_rate
            linkpath = self.entries[position]['linkpath'].value
            linkfile = os.path.join(
                scan, self.entries[position]['linkfile'].value)
            entry['data'] = NXdata()
            entry['data'].nxsignal = NXlink(linkpath, linkfile)
            entry['data/x_pixel'] = np.arange(x_size, dtype=np.int32)
            entry['data/y_pixel'] = np.arange(y_size, dtype=np.int32)
            entry['data/frame_number'] = np.arange(
                (phi_end-phi_start)/phi_step, dtype=np.int32)
            entry['data'].nxaxes = [entry['data/frame_number'],
                                    entry['data/y_pixel'],
                                    entry['data/x_pixel']]

    def make_scan(self):
        home_directory = self.get_directory()
        self.mainwindow.default_directory = home_directory
        sample_directory = os.path.join(home_directory, self.sample)
        label_directory = os.path.join(home_directory, self.sample, self.label)
        scan_directory = os.path.join(
            label_directory, str(self.scan['scan'].value))
        scan_name = self.sample+'_'+self.scan['scan'].value
        try:
            os.makedirs(scan_directory)
        except Exception:
            pass
        self.copy_configuration()
        self.get_parameters()
        self.scan_file.save(os.path.join(label_directory, scan_name+'.nxs'))
        self.treeview.tree.load(self.scan_file.nxfilename, 'r')
Пример #10
0
 def copy_configuration(self):
     self.scan_file = NXroot()
     for entry in self.config_file.entries:
         self.scan_file[entry] = self.config_file[entry]