コード例 #1
0
ファイル: xas_plot.py プロジェクト: LeilahR/SGM_Nexpy
    def plot_xas(self):
        self.singleXas = NXdata(self.signal_s, self.energy)
        self.singleXas.plot(xmin=min(self.energy),
                            xmax=max(self.energy),
                            ymin=min(self.signal_s),
                            ymax=max(self.signal_s))

        return
コード例 #2
0
    def get_data(self):
        prefix = self.get_prefix()
        if prefix:
            self.import_file = prefix
        else:
            self.import_file = self.get_directory()
        filenames = self.get_files()
        try:
            import fabio
        except ImportError:
            raise NeXusError("Please install the 'fabio' module")
        im = self.read_image(filenames[0])
        v0 = im.data
        x = NXfield(range(v0.shape[1]), dtype=np.uint16, name='x')
        y = NXfield(range(v0.shape[0]), dtype=np.uint16, name='y')
        z = NXfield(range(1, len(filenames)+1), dtype=np.uint16, name='z')
        v = NXfield(shape=(len(filenames), v0.shape[0], v0.shape[1]),
                    dtype=v0.dtype, name='v')
        v[0] = v0
        if v._memfile:
            chunk_size = v._memfile['data'].chunks[0]
        else:
            chunk_size = v.shape[0]/10
        self.progress_bar.setVisible(True)
        self.progress_bar.setRange(0, len(filenames))
        for i in range(0, len(filenames), chunk_size):
            try:
                files = []
                for j in range(i, i+chunk_size):
                    files.append(filenames[j])
                    self.progress_bar.setValue(j)
                self.update_progress()
                v[i:i+chunk_size, :, :] = self.read_images(files)
            except IndexError as error:
                pass
        global maximum
        v.maximum = maximum

        if im.getclassname() == 'CbfImage':
            note = NXnote(type='text/plain', file_name=self.import_file)
            note.data = im.header.pop('_array_data.header_contents', '')
            note.description = im.header.pop(
                '_array_data.header_convention', '')
        else:
            note = None

        header = NXcollection()
        for key, value in im.header.items():
            header[key] = value

        if note:
            return NXentry(
                NXdata(
                    v, (z, y, x),
                    CBF_header=note, header=header))
        else:
            return NXentry(NXdata(v, (z, y, x), header=header))
コード例 #3
0
ファイル: fitdialogs.py プロジェクト: JPHammonds/nexpy
 def initialize_data(self, data):
     if isinstance(data, NXdata):
         if len(data.nxsignal.shape) > 1:
             raise NeXusError("Fitting only possible on one-dimensional arrays")
         fit_data = NXdata(data.nxsignal, data.nxaxes, title=data.nxtitle)
         if data.nxerrors:
             fit_data.errors = data.nxerrors
         return fit_data
     else:
         raise NeXusError("Must be an NXdata group")
コード例 #4
0
 def initialize_data(self, data):
     if isinstance(data, NXdata):
         if len(data.nxsignal.shape) > 1:
             raise NeXusError(
                 "Fitting only possible on one-dimensional arrays")
         fit_data = NXdata(data.nxsignal, data.nxaxes, title=data.nxtitle)
         if data.nxerrors:
             fit_data.errors = data.nxerrors
         return fit_data
     else:
         raise NeXusError("Must be an NXdata group")
コード例 #5
0
 def get_data(self):
     prefix = self.get_prefix()
     if prefix:
         self.import_file = prefix
     else:
         self.import_file = self.get_directory()
     filenames = self.get_files()
     v0 = self.read_image(filenames[0])
     x = NXfield(range(v0.shape[1]), dtype=np.uint16, name='x')
     y = NXfield(range(v0.shape[0]), dtype=np.uint16, name='y')
     z = NXfield(range(1, len(filenames) + 1), dtype=np.uint16, name='z')
     v = NXfield(shape=(len(filenames), v0.shape[0], v0.shape[1]),
                 dtype=v0.dtype,
                 name='v')
     v[0] = v0
     if v._memfile:
         chunk_size = v._memfile['data'].chunks[0]
     else:
         chunk_size = v.shape[0] / 10
     self.progress_bar.setVisible(True)
     self.progress_bar.setRange(0, len(filenames))
     for i in range(0, len(filenames)):
         try:
             files = []
             for j in range(i, i + chunk_size):
                 files.append(filenames[j])
                 self.progress_bar.setValue(j)
             self.update_progress()
             v[i:i + chunk_size, :, :] = self.read_images(files)
         except IndexError as error:
             pass
     global maximum
     v.maximum = maximum
     return NXentry(NXdata(v, (z, y, x)))
コード例 #6
0
def mfit(data, xmin, xmax, ymin, ymax, dy):

    fs = [Function('Linear', linear), Function('Gaussian', gaussian)]
    x = np.linspace(xmin, xmax, 200)

    ylo, yhi = ymin, ymin + dy

    while yhi < ymax:

        slab = data[ylo:yhi, xmin:xmax]
        diff = slab.nxsignal.shape[0]
        cut = slab.sum([0])
        cut.plot()

        fit = Fit(cut, fs, use_errors=True)

        y = np.array(fit.y)
        for f in fs:
            f.guess_parameters(fit.x, y)
            y = y - f.function_values(fit.x)

        fit.fit_data()

        NXdata(fit.get_model(x), x).oplot('-')

        if raw_input('Keep? [y,N] ') == 'y':
            data[ylo:yhi, xmin:xmax] = slab - fit.get_model(f=fs[1]) / diff

        ylo = yhi
        yhi = ylo + dy

    return data
コード例 #7
0
    def save(self, x=None):
        """Save the fit results in a NXprocess group.

        Parameters
        ----------
        x : ndarray, optional
            x-values at which to calculate the model. Defaults to `self.x`
        Returns
        -------
        group : NXprocess
            NXprocess group that contains the data, models and parameters.
        """
        group = NXprocess(program='lmfit', version=__version__)
        group['data'] = self.data
        for f in self.functions:
            group[f.name] = NXdata(NXfield(self.get_model(x, f), name='model'),
                                   NXfield(x, name=self.data.nxaxes[0].nxname),
                                   title='Fit Results')
            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))
            group[f.name]['parameters'] = parameters
        group['title'] = 'Fit Results'
        group['fit'] = NXdata(NXfield(self.get_model(x), name='model'),
                              NXfield(x, name=self.data.nxaxes[0].nxname),
                              title='Fit Results')
        if self.result is not None:
            fit = NXparameters()
            fit.nfev = self.result.nfev
            fit.chisq = self.result.chisqr
            fit.redchi = self.result.redchi
            fit.message = self.result.message
            group['statistics'] = fit
            group.note = NXnote(
                self.fit.result.message, f'Chi^2 = {self.fit.result.chisqr}\n'
                f'Reduced Chi^2 = {self.fit.result.redchi}\n'
                f'No. of Function Evaluations = {self.fit.result.nfev}\n'
                f'No. of Variables = {self.fit.result.nvarys}\n'
                f'No. of Data Points = {self.fit.result.ndata}\n'
                f'No. of Degrees of Freedom = {self.fit.result.nfree}\n'
                f'{self.fit.fit_report()}')

        return group
コード例 #8
0
 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']]
コード例 #9
0
ファイル: xas_plot_bak.py プロジェクト: LeilahR/SGM_Nexpy
 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
コード例 #10
0
ファイル: map_plot.py プロジェクト: LeilahR/SGM_Nexpy
    def plot_map(self):
        self.x1 = np.array(self.entry['sample/positioner'][self.axis1])
        self.y1 = np.array(self.entry['sample/positioner'][self.axis2])
        self.sdd = np.array(self.entry['instrument/fluorescence'][self.signal])
        row, col = np.shape(self.sdd)
        self.z1 = np.zeros(row)
        for i in range(0, row):
            self.z1[i] = self.sdd[i, self.roi_dn:self.roi_up].sum(axis=0)
        
        self.ylen = self.getylen()
        if self.ylen:
            self.xlen = len(self.entry['sample/positioner'][self.axis1])/self.ylen
        else:
            self.ylen = 100
            self.xlen = 100

        X,Y,Z,xi,yi = self.grid(self.x1, self.y1, self.z1, self.xlen, self.ylen)
        self.data = NXdata(Z, [yi, xi])
        self.data.plot(xmin = min(self.x1), xmax=max(self.x1), ymin = min(self.y1), ymax = max(self.y1), zmin = min(self.z1), zmax = max(self.z1))
        return X, Y, Z, xi, yi
コード例 #11
0
 def get_model(self, f=None):
     self.read_parameters()
     fit = Fit(self.data, self.functions)
     if self.plot_checkbox.isChecked():
         x = fit.x
     else:
         x = np.linspace(float(self.plot_minbox.text()),
                         float(self.plot_maxbox.text()), 1001)
     return NXdata(NXfield(fit.get_model(x, f), name='model'),
                   NXfield(x, name=fit.data.nxaxes[0].nxname),
                   title='Fit Results')
コード例 #12
0
ファイル: xas_plot.py プロジェクト: LeilahR/SGM_Nexpy
class XasDialog(BaseDialog):
    def __init__(self, parent=None):

        super(XasDialog, self).__init__(parent)
        self.select_entry()
        dets_list = {}
        self.dets = self.entry['instrument/absorbed_beam']
        self.signal_combo = self.select_box(self.dets,
                                            default='sdd3_2',
                                            slot=self.plot_xas)
        self.lab_sig = self.labels('Signal :', align='left')
        self.set_layout(self.entry_layout, self.lab_sig, self.signal_combo,
                        self.close_buttons())
        self.set_title('Plot Single XAS')

    @property
    def signal_s(self):
        return np.array(self.entry.instrument.absorbed_beam[
            self.signal_combo.currentText()])

    @property
    def energy(self):
        return np.array(self.entry.instrument.monochromator.en)

    def plot_xas(self):
        self.singleXas = NXdata(self.signal_s, self.energy)
        self.singleXas.plot(xmin=min(self.energy),
                            xmax=max(self.energy),
                            ymin=min(self.signal_s),
                            ymax=max(self.signal_s))

        return

    def accept(self):
        try:
            self.plot_xas
            super(XasDialog, self).accept()
        except NeXusError as error:
            report_error("Plot Single XAS", error)
            super(XasDialog, self).reject()
コード例 #13
0
ファイル: utils.py プロジェクト: nexpy/nexpy
def load_image(filename):
    if os.path.splitext(
            filename.lower())[1] in ['.png', '.jpg', '.jpeg', '.gif']:
        from matplotlib.image import imread
        im = imread(filename)
        z = NXfield(im, name='z')
        y = NXfield(range(z.shape[0]), name='y')
        x = NXfield(range(z.shape[1]), name='x')
        if z.ndim > 2:
            rgba = NXfield(range(z.shape[2]), name='rgba')
            if len(rgba) == 3:
                z.interpretation = 'rgb-image'
            elif len(rgba) == 4:
                z.interpretation = 'rgba-image'
            data = NXdata(z, (y, x, rgba))
        else:
            data = NXdata(z, (y, x))
    else:
        try:
            im = fabio.open(filename)
        except Exception as error:
            if fabio:
                raise NeXusError("Unable to open image")
            else:
                raise NeXusError(
                    "Unable to open image. Please install the 'fabio' module")
        z = NXfield(im.data, name='z')
        y = NXfield(range(z.shape[0]), name='y')
        x = NXfield(range(z.shape[1]), name='x')
        data = NXdata(z, (y, x))
        if im.header:
            header = NXcollection()
            for k, v in im.header.items():
                if v or v == 0:
                    header[k] = v
            data.header = header
        if im.getclassname() == 'CbfImage':
            note = NXnote(type='text/plain', file_name=filename)
            note.data = im.header.pop('_array_data.header_contents', '')
            note.description = im.header.pop('_array_data.header_convention',
                                             '')
            data.CBF_header = note
    data.title = filename
    return data
コード例 #14
0
    def get_data(self):
        self.import_file = self.get_filename()
        if not self.import_file:
            raise NeXusError("No file specified")
        try:
            import tifffile as TIFF
        except ImportError:
            raise NeXusError("Please install the 'tifffile' module")
        im = TIFF.imread(self.import_file)
        z = NXfield(im, name='z')
        y = NXfield(np.arange(z.shape[0], dtype=float), name='y')
        x = NXfield(np.arange(z.shape[1], dtype=float), name='x')

        return NXentry(NXdata(z, (y, x)))
コード例 #15
0
ファイル: readspe.py プロジェクト: nexpy/nexpy
def convert_QE(entry, dQ, dE):
    """Convert S(phi,eps) to S(Q,eps)"""
    az = entry.data.azimuthal.nxdata[:]
    pol = entry.data.polar.nxdata[:]
    pol, en = centers(entry.data.nxsignal, entry.data.nxaxes)
    data = entry.data.data.nxdata[:]
    errors = entry.data.errors.nxdata[:]

    Ei = entry.instrument.monochromator.incident_energy.nxdata

    Q = np.zeros((len(pol), len(en)))
    E = np.zeros((len(pol), len(en)))

    for i in range(0, len(pol)):
        for j in range(0, len(en)):
            Q[i][j] = np.sqrt((2*Ei - en[j] - 2*np.sqrt(Ei*(Ei-en[j]))
                               * np.cos(pol[i]*np.pi/180.0))/2.0721)
            E[i][j] = en[j]

    s = Q.shape
    Qin = Q.reshape(s[0]*s[1])
    Ein = E.reshape(s[0]*s[1])
    datain = data.reshape(s[0]*s[1])
    errorsin = errors.reshape(s[0]*s[1])

    qmin = Q.min()
    qmax = Q.max()
    emin = E.min()
    emax = E.max()
    NQ = int((qmax-qmin)/dQ) + 1
    NE = int((emax-emin)/dE) + 1
    Qb = np.linspace(qmin, qmax, NQ)
    Eb = np.linspace(emin, emax, NE)
    # histogram and normalize
    norm, nbin = np.histogramdd((Ein, Qin), bins=(Eb, Qb))
    hist, hbin = np.histogramdd((Ein, Qin), bins=(Eb, Qb), weights=datain)
    histe, hbin = np.histogramdd(
        (Ein, Qin),
        bins=(Eb, Qb),
        weights=errorsin * errorsin)
    histe = histe**0.5

    Ib = NXfield(hist/norm, name='S(Q,E)')
    err = histe/norm

    Qb = NXfield(Qb[:-1]+dQ/2., name='Q')
    Eb = NXfield(Eb[:-1]+dE/2., name='E')

    return NXdata(Ib, (Eb, Qb), errors=NXfield(err))
コード例 #16
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)
コード例 #17
0
 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)
コード例 #18
0
ファイル: refine_lattice.py プロジェクト: rayosborn/nxrefine
 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)
コード例 #19
0
ファイル: refine_lattice.py プロジェクト: rayosborn/nxrefine
 def export_peaks(self):
     peaks = list(
         zip(*[
             p for p in self.table_model.peak_list
             if p[-1] < self.get_hkl_tolerance()
         ]))
     idx = NXfield(peaks[0], name='index')
     x = NXfield(peaks[1], name='x')
     y = NXfield(peaks[2], name='y')
     z = NXfield(peaks[3], name='z')
     pol = NXfield(peaks[4], name='polar_angle', units='degree')
     azi = NXfield(peaks[5], name='azimuthal_angle', units='degree')
     polarization = self.refine.get_polarization()
     intensity = NXfield(peaks[6] / polarization[y, x], name='intensity')
     H = NXfield(peaks[7], name='H', units='rlu')
     K = NXfield(peaks[8], name='K', units='rlu')
     L = NXfield(peaks[9], name='L', units='rlu')
     diff = NXfield(peaks[10], name='diff')
     peaks_data = NXdata(intensity, idx, diff, H, K, L, pol, azi, x, y, z)
     export_dialog = ExportDialog(peaks_data, parent=self)
     export_dialog.show()
コード例 #20
0
ファイル: readspe.py プロジェクト: nexpy/nexpy
def rebin2D(self, spw, phi, psi, omega, dphi, dpsi):
    rot = np.linspace(np.round(phi.min() - 0.5 * dphi, 2),
                      np.round(phi.max() + 0.5 * dphi, 2),
                      np.round(phi.ptp() / dphi)).astype(np.float32)
    tilt = np.linspace(np.round(psi.min() - 0.5 * dpsi, 2),
                       np.round(psi.max() + 0.5 * dpsi, 2),
                       np.round(psi.ptp() / dpsi)).astype(np.float32)
    en = 0.5*(omega[1:]+omega[:-1])
    data = NXfield(name='data', dtype='float32', shape=[
                   rot.size-1, tilt.size-1, omega.size-1])
    rotation_angle = NXfield(rot, name='rotation_angle', units='degree')
    tilt_angle = NXfield(tilt, name='tilt_angle', units='degree')
    energy_transfer = NXfield(omega, name='energy_transfer', units='meV')
    pixels = np.array(zip(np.repeat(phi, en.size), np.repeat(
        psi, en.size), np.tile(en, phi.size)))
    hist, edges = np.histogramdd(
        pixels, [rot, tilt, omega],
        weights=spw.reshape(spw.size))
    return NXdata(
        NXfield(hist, name='intensity'),
        (rotation_angle, tilt_angle, energy_transfer))
コード例 #21
0
 def plot_cake(self):
     if 'Cake Plot' in plotviews:
         plotview = plotviews['Cake Plot']
     else:
         plotview = NXPlotView('Cake Plot')
     if not self.is_calibrated:
         raise NeXusError('No refinement performed')
     res = self.cake_geometry.integrate2d(self.counts,
                                          1024, 1024,
                                          method='csr',
                                          unit='2th_deg',
                                          correctSolidAngle=True)
     self.cake_data = NXdata(res[0],
                             (NXfield(res[2], name='azimumthal_angle'),
                              NXfield(res[1], name='polar_angle')))
     self.cake_data['title'] = 'Cake Plot'
     plotview.plot(self.cake_data, log=True)
     wavelength = self.parameters['wavelength'].value
     polar_angles = [2 * np.degrees(np.arcsin(wavelength/(2*d)))
                     for d in self.calibrant.dSpacing]
     plotview.vlines([polar_angle for polar_angle in polar_angles
                      if polar_angle < plotview.xaxis.max],
                     linestyle=':', color='r')
コード例 #22
0
ファイル: map_plot.py プロジェクト: LeilahR/SGM_Nexpy
    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 
コード例 #23
0
ファイル: map_plot.py プロジェクト: LeilahR/SGM_Nexpy
class MapDialog(BaseDialog):

    def __init__(self, parent=None):

        super(MapDialog, self).__init__(parent)

        self.select_entry()
        dets_list = {}
        self.dets = self.entry['instrument/fluorescence']
        self.signal_combo = self.select_box(self.dets, default='sdd3')
        self.axes = self.entry['sample/positioner']
        self.axis1_combo = self.select_box(self.axes, default='hex_xp')
        self.axis2_combo = self.select_box(self.axes, default='hex_yp')
        
        
        roi_peak_layout = QtGui.QHBoxLayout()
        roi_peak_layout.addWidget(QtGui.QLabel('ROI Peak'))
        self.roi_peak = QtGui.QSlider(Qt.Horizontal)
        self.pLabel = QtGui.QLineEdit()
        self.pLabel.setText('800')
        self.pLabel.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Minimum))
        self.pLabel.setAlignment(Qt.AlignRight) 
        self.roi_peak.setMinimum(0)
        self.roi_peak.setMaximum(256)
        self.roi_peak.setValue(80)
        self.roi_peak.setTickPosition(QtGui.QSlider.TicksBelow)
        self.roi_peak.setTickInterval(1)
        roi_peak_layout.addWidget(self.roi_peak)
        self.roi_peak.valueChanged.connect(self.setRoi)
        self.pLabel.returnPressed.connect(self.setRoi2)
        self.pUnits = QtGui.QLabel('eV')
        roi_peak_layout.addWidget(self.pLabel)
        roi_peak_layout.addWidget(self.pUnits)


        roi_width_layout = QtGui.QHBoxLayout()
        roi_width_layout.addWidget(QtGui.QLabel('ROI Width'))
        self.roi_width = QtGui.QSlider(Qt.Horizontal)
        self.wLabel = QtGui.QLineEdit()
        self.wLabel.setText('200')
        self.wLabel.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Minimum))
        self.wLabel.setAlignment(Qt.AlignRight) 
        self.roi_width.setMinimum(2)
        self.roi_width.setMaximum(100)
        self.roi_width.setValue(20)
        self.roi_width.setTickPosition(QtGui.QSlider.TicksBelow)
        self.roi_peak.setTickInterval(1)
        roi_width_layout.addWidget(self.roi_width)

        self.roi_width.valueChanged.connect(self.setRoi)
        self.wLabel.returnPressed.connect(self.setRoi2)
        self.signal_combo.activated.connect(self.setRoi)
        self.axis1_combo.activated.connect(self.setRoi)
        self.axis2_combo.activated.connect(self.setRoi)
        self.entry_box.activated.connect(self.setRoi)
        
        self.wUnits = QtGui.QLabel('eV')
        roi_width_layout.addWidget(self.wLabel)
        roi_width_layout.addWidget(self.wUnits)

        lab_sig_layout = QtGui.QHBoxLayout()
        self.lab_sig = self.labels('Detector :', align='left')
        lab_sig_layout.addLayout(self.lab_sig)
        lab_sig_layout.addWidget(self.signal_combo)
        lab_sig_layout.addStretch()
        
        lab_axis1_layout = QtGui.QHBoxLayout()
        self.lab_axis1 = self.labels('X-Axis :', align='left')
        lab_axis1_layout.addLayout(self.lab_axis1)
        lab_axis1_layout.addWidget(self.axis1_combo)
        lab_axis1_layout.addStretch()

        lab_axis2_layout = QtGui.QHBoxLayout()
        self.lab_axis2 = self.labels('Y-Axis :', align='left')
        lab_axis2_layout.addLayout(self.lab_axis2)
        lab_axis2_layout.addWidget(self.axis2_combo)
        lab_axis2_layout.addStretch()

        self.set_layout(self.entry_layout, lab_sig_layout, lab_axis1_layout,
                            lab_axis2_layout, roi_peak_layout, roi_width_layout, self.close_buttons())
        self.set_title('Convert to 2D map')

    @property
    def signal(self):
        return self.signal_combo.currentText()

    @property
    def axis1(self):
        return self.axis1_combo.currentText()

    @property
    def axis2(self):
        return self.axis2_combo.currentText()


    def get_pLabel(self):
        value = int(self.pLabel.text())
        value = value/10
        return value


    def get_wLabel(self):
        value = int(self.wLabel.text())
        value = value/10
        return value


    @property
    def roi_up(self):
        up = self.peak + self.width/2
        if up > 256:
            return 256

        return up

    @property
    def roi_dn(self):
        dn = self.peak - self.width/2
        if dn < 0:
            return 0

        return dn
        

    def roi_peak_label(self):
        self.roi_peak.setValue(self.peak)
        self.pLabel.setText(str(self.peak) + '0')
        return self.pLabel

    def roi_width_label(self):
        self.roi_width.setValue(self.width)
        self.wLabel.setText(str(self.width) + '0')
        return self.wLabel

    def setRoi2(self):
        self.roi_width.setValue(self.get_wLabel())
        self.roi_peak.setValue(self.get_pLabel())
        return

    def setRoi(self):
        self.peak = self.roi_peak.value()
        self.width = self.roi_width.value()
        self.roi_width_label()
        self.roi_peak_label()
        self.plot_map()
        return self.roi_dn, self.roi_up
    
    def getylen(self):
        command = self.entry['command']
        if str(command).split(" ")[0] == "cmesh":
            str_n = str(command).split(" ")[8]
            num = int(str_n)
            return num
        else:
            return False

    def grid(self, x, y, z, resX, resY):
        shift = 0.5
        x_ad = x
        xi = linspace(min(x), max(x), resX)
        yi = linspace(min(y), max(y), resY)
        for i in range(1, len(x)):
            x_ad[i] = x[i] + shift*(x[i] - x[i-1])

        Z = griddata(x_ad, y, z, xi, yi, interp='linear')
        X, Y = meshgrid(xi, yi)
        return X, Y, Z, xi, yi

    def plot_map(self):
        self.x1 = np.array(self.entry['sample/positioner'][self.axis1])
        self.y1 = np.array(self.entry['sample/positioner'][self.axis2])
        self.sdd = np.array(self.entry['instrument/fluorescence'][self.signal])
        row, col = np.shape(self.sdd)
        self.z1 = np.zeros(row)
        for i in range(0, row):
            self.z1[i] = self.sdd[i, self.roi_dn:self.roi_up].sum(axis=0)
        
        self.ylen = self.getylen()
        if self.ylen:
            self.xlen = len(self.entry['sample/positioner'][self.axis1])/self.ylen
        else:
            self.ylen = 100
            self.xlen = 100

        X,Y,Z,xi,yi = self.grid(self.x1, self.y1, self.z1, self.xlen, self.ylen)
        self.data = NXdata(Z, [yi, xi])
        self.data.plot(xmin = min(self.x1), xmax=max(self.x1), ymin = min(self.y1), ymax = max(self.y1), zmin = min(self.z1), zmax = max(self.z1))
        return X, Y, Z, xi, yi

    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 


    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()
コード例 #24
0
ファイル: prepare_mask.py プロジェクト: rayosborn/nxrefine
 def plot_mask(self):
     self.plotview = NXPlotView('3D Mask')
     self.plotview.plot(
         NXdata(self.mask,
                self.reduce.data.nxaxes,
                title=f"3D Mask: {self.reduce.name}"))
コード例 #25
0
ファイル: convert_qe.py プロジェクト: nexpy/nexpy
    def convert_QE(self):
        """Convert S(phi,eps) to S(Q,eps)"""

        self.read_parameters()

        Ei = self.Ei
        dQ = self.dQ
        dE = self.dE

        signal = self.entry['data'].nxsignal
        pol = centers(self.entry['data/polar_angle'], signal.shape[0])
        tof = centers(self.entry['data/time_of_flight'], signal.shape[1])
        en = self.convert_tof(tof)

        idx_max = min(np.where(np.abs(en - 0.75 * Ei) < 0.1)[0])

        en = en[:idx_max]

        data = signal.nxdata[:, :idx_max]
        if self.entry['data'].nxerrors:
            errors = self.entry['data'].nxerrors.nxdata[:]

        Q = np.zeros((len(pol), len(en)))
        E = np.zeros((len(pol), len(en)))

        for i in range(0, len(pol)):
            p = pol[i]
            Q[i, :] = np.array(
                np.sqrt(
                    (2 * Ei - en -
                     2 * np.sqrt(Ei * (Ei - en)) * np.cos(p * np.pi / 180.0)) /
                    2.0721))
            E[i, :] = np.array(en)

        s = Q.shape
        Qin = Q.reshape(s[0] * s[1])
        Ein = E.reshape(s[0] * s[1])
        datain = data.reshape(s[0] * s[1])
        if self.entry['data'].nxerrors:
            errorsin = errors.reshape(s[0] * s[1])

        qmin = Q.min()
        qmax = Q.max()
        emin = E.min()
        emax = E.max()
        NQ = int((qmax - qmin) / dQ) + 1
        NE = int((emax - emin) / dE) + 1
        Qb = np.linspace(qmin, qmax, NQ)
        Eb = np.linspace(emin, emax, NE)
        # histogram and normalize
        norm, nbin = np.histogramdd((Ein, Qin), bins=(Eb, Qb))
        hist, hbin = np.histogramdd((Ein, Qin), bins=(Eb, Qb), weights=datain)
        if self.entry['data'].nxerrors:
            histe, hbin = np.histogramdd((Ein, Qin),
                                         bins=(Eb, Qb),
                                         weights=errorsin * errorsin)
            histe = histe**0.5
            err = histe / norm

        Ib = NXfield(hist / norm, name='S(Q,E)')

        Qb = NXfield(Qb[:-1] + dQ / 2., name='Q')
        Eb = NXfield(Eb[:-1] + dE / 2., name='E')

        result = NXdata(Ib, (Eb, Qb))
        if self.entry.data.nxerrors:
            result.errors = NXfield(err)
        return result
コード例 #26
0
ファイル: datadialogs.py プロジェクト: tacaswell/nexpy
 def accept(self):
     data = NXdata(self.signal, self.get_axes(), title=self.signal.nxtitle)
     data.plot(fmt=self.fmt)
     super(PlotDialog, self).accept()
コード例 #27
0
ファイル: convert_qe.py プロジェクト: tacaswell/nexpy
    def convert_QE(self):
        """Convert S(phi,eps) to S(Q,eps)"""

        self.read_parameters()

        entry = self.root['entry']
        Ei = self.Ei
        dQ = self.dQ
        dE = self.dE

        pol, tof = centers(entry.data.nxsignal, entry.data.nxaxes)
        en = self.convert_tof(tof)

        idx_max = min(np.where(np.abs(en-0.75*Ei)<0.1)[0])

        en = en[:idx_max]

        data = entry.data.nxsignal.nxdata[:,:idx_max]
        if entry.data.nxerrors:
            errors = entry.data.nxerrors.nxdata[:]

        Q = np.zeros((len(pol), len(en)))
        E = np.zeros((len(pol), len(en)))

        for i in range(0,len(pol)):
            for j in range(0,len(en)):
                Q[i,j] = np.sqrt((2*Ei - en[j] - 2*np.sqrt(Ei*(Ei-en[j])) 
                                   * np.cos(pol[i]*np.pi/180.0))/2.0721)
                E[i,j]=en[j]

        s = Q.shape
        Qin = Q.reshape(s[0]*s[1])
        Ein = E.reshape(s[0]*s[1])
        datain = data.reshape(s[0]*s[1])
        if entry.data.nxerrors:
            errorsin = errors.reshape(s[0]*s[1])

        qmin = Q.min()
        qmax = Q.max()
        emin = E.min()
        emax = E.max()
        NQ = int((qmax-qmin)/dQ) + 1
        NE = int((emax-emin)/dE) + 1
        Qb = np.linspace(qmin, qmax, NQ)
        Eb = np.linspace(emin, emax, NE)
        #histogram and normalize 
        norm, nbin = np.histogramdd((Ein,Qin), bins=(Eb,Qb))
        hist, hbin = np.histogramdd((Ein,Qin), bins=(Eb,Qb), weights=datain)
        if entry.data.nxerrors:
            histe, hbin = np.histogramdd((Ein,Qin), bins=(Eb,Qb), weights=errorsin*errorsin)
            histe = histe**0.5
            err = histe/norm

        I = NXfield(hist/norm, name='S(Q,E)')

        Qb = NXfield(Qb[:-1]+dQ/2., name='Q')
        Eb = NXfield(Eb[:-1]+dE/2., name='E')

        result = NXdata(I, (Eb, Qb))
        if entry.data.nxerrors:
            result.errors = NXfield(err)
        return result
コード例 #28
0
ファイル: readspe.py プロジェクト: nexpy/nexpy
 def get_spe(self, phxfile=None):
     entry = NXentry()
     phi, omega, spw, errors = readspe(self.get_filename())
     if phxfile:
         theta, phi, dtheta, dpsi = readphx(phxfile)
         phip, psi = angles(theta, phi)
         instrument = NXinstrument(NXdetector())
         instrument.detector.polar_angle = NXfield(theta, units="degrees")
         Ei = self.get_energy()
         if Ei and Ei > 0.0:
             instrument.monochromator = NXmonochromator(
                 NXfield(Ei, name="incident_energy", units="meV"))
         if phi.ptp() > 1.0:  # i.e., the azimuthal angle is specified
             instrument.detector.azimuthal_angle = NXfield(
                 phi, units="degrees")
             instrument.detector.rotation_angle = NXfield(
                 phip, units="degrees")
             instrument.detector.tilt_angle = NXfield(psi, units="degrees")
             data = NXdata(
                 NXfield(
                     spw, name="intensity",
                     long_name="Neutron Intensity"),
                 (
                     NXfield(
                         np.arange(1, len(theta) + 1),
                         name="spectrum_index",
                         long_name="Spectrum Index"),
                     NXfield(
                         omega, name="energy_transfer", units="meV",
                         long_name="Energy Transfer")),
                 errors=NXfield(
                     np.sqrt(errors),
                     name="errors", long_name="Errors"))
             if np.median(dtheta) > 0.0 and np.median(dpsi) > 0.0:
                 data2D = rebin2D(
                     spw, phip, psi, omega, np.median(dtheta),
                     np.median(dpsi))
                 return NXentry(instrument, data, data2D=data2D)
             else:
                 return NXentry(instrument, data)
         else:
             phi = np.zeros(theta.size+1)
             phi[:-1] = theta - 0.5*dtheta
             phi[-1] = theta[-1] + 0.5*dtheta[-1]
             data = NXdata(
                 NXfield(
                     spw, name="intensity",
                     long_name="Neutron Intensity"),
                 (
                     NXfield(
                         phi, name="polar_angle",
                         long_name="Polar Angle", units="degrees"),
                     NXfield(
                         omega, name="energy_transfer", units="meV",
                         long_name="Energy Transfer")),
                 errors=NXfield(
                     np.sqrt(errors),
                     name="errors", long_name="Errors"))
             return NXentry(instrument, data)
     else:
         Ei = self.get_energy()
         if Ei and Ei > 0.0:
             entry = NXentry(
                 NXinstrument(
                     NXmonochromator(
                         NXfield(
                             Ei, name="incident_energy",
                             units="meV"))))
         else:
             entry = NXentry()
         if phi.ptp() > 1.0:
             entry.data = NXdata(
                 NXfield(spw, name="intensity",
                         long_name="Neutron Intensity"),
                 (NXfield(phi, name="polar_angle", units="degrees",
                          long_name="Polar Angle"),
                     NXfield(omega, name="energy_transfer", units="meV",
                             long_name="Energy Transfer")),
                 errors=NXfield(np.sqrt(errors), name="errors",
                                long_name="Errors"))
         else:
             entry.data = NXdata(
                 NXfield(spw, name="intensity",
                         long_name="Neutron Intensity"),
                 (NXfield(np.arange(1, len(phi)+1), name="spectrum_index",
                          long_name="Spectrum Index"),
                     NXfield(omega, name="energy_transfer", units="meV",
                             long_name="Energy Transfer")),
                 errors=NXfield(np.sqrt(errors), name="errors",
                                long_name="Errors"))
         return entry