Changeset 9c0f3c17 in sasview for src/sas/sascalc/calculator


Ignore:
Timestamp:
Apr 4, 2017 12:50:04 PM (8 years ago)
Author:
Ricardo Ferraz Leal <ricleal@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
f2940c4
Parents:
463e7ffc (diff), 1779e72 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

After merge conflict

Location:
src/sas/sascalc/calculator
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/calculator/BaseComponent.py

    rdeddda1 r9a5097c  
    99from collections import OrderedDict 
    1010 
    11 import numpy 
     11import numpy as np 
    1212#TO DO: that about a way to make the parameter 
    1313#is self return if it is fittable or not 
    … …  
    119119        Then get :: 
    120120 
    121             q = numpy.sqrt(qx_prime^2+qy_prime^2) 
     121            q = np.sqrt(qx_prime^2+qy_prime^2) 
    122122 
    123123        that is a qr in 1D array; :: 
    … …  
    150150 
    151151            # calculate q_r component for 2D isotropic 
    152             q = numpy.sqrt(qx**2+qy**2) 
     152            q = np.sqrt(qx**2+qy**2) 
    153153            # vectorize the model function runXY 
    154             v_model = numpy.vectorize(self.runXY, otypes=[float]) 
     154            v_model = np.vectorize(self.runXY, otypes=[float]) 
    155155            # calculate the scattering 
    156156            iq_array = v_model(q) 
    … …  
    160160        elif qdist.__class__.__name__ == 'ndarray': 
    161161            # We have a simple 1D distribution of q-values 
    162             v_model = numpy.vectorize(self.runXY, otypes=[float]) 
     162            v_model = np.vectorize(self.runXY, otypes=[float]) 
    163163            iq_array = v_model(qdist) 
    164164            return iq_array 

  • src/sas/sascalc/calculator/instrument.py

    rb699768 r9a5097c  
    33control instrumental parameters 
    44""" 
    5 import numpy 
     5import numpy as np 
    66 
    77# defaults in cgs unit 
    … …  
    168168        self.spectrum = self.get_default_spectrum() 
    169169        # intensity in counts/sec 
    170         self.intensity = numpy.interp(self.wavelength, 
     170        self.intensity = np.interp(self.wavelength, 
    171171                                      self.spectrum[0], 
    172172                                      self.spectrum[1], 
    … …  
    203203        """ 
    204204        spectrum = self.spectrum 
    205         intensity = numpy.interp(self.wavelength, 
     205        intensity = np.interp(self.wavelength, 
    206206                                 spectrum[0], 
    207207                                 spectrum[1], 
    … …  
    244244        self.wavelength = wavelength 
    245245        validate(wavelength) 
    246         self.intensity = numpy.interp(self.wavelength, 
     246        self.intensity = np.interp(self.wavelength, 
    247247                                      self.spectrum[0], 
    248248                                      self.spectrum[1], 
    … …  
    305305        get default spectrum 
    306306        """ 
    307         return numpy.array(_LAMBDA_ARRAY) 
     307        return np.array(_LAMBDA_ARRAY) 
    308308 
    309309    def get_band(self): 
    … …  
    345345        get list of the intensity wrt wavelength_list 
    346346        """ 
    347         out = numpy.interp(self.wavelength_list, 
     347        out = np.interp(self.wavelength_list, 
    348348                           self.spectrum[0], 
    349349                           self.spectrum[1], 

  • src/sas/sascalc/calculator/resolution_calculator.py

    r463e7ffc r9c0f3c17  
    1212from math import sqrt 
    1313import math 
    14 import numpy 
     14import numpy as np 
    1515import sys 
    1616import logging 
    … …  
    395395        dx_size = (self.qx_max - self.qx_min) / (1000 - 1) 
    396396        dy_size = (self.qy_max - self.qy_min) / (1000 - 1) 
    397         x_val = numpy.arange(self.qx_min, self.qx_max, dx_size) 
    398         y_val = numpy.arange(self.qy_max, self.qy_min, -dy_size) 
    399         q_1, q_2 = numpy.meshgrid(x_val, y_val) 
     397        x_val = np.arange(self.qx_min, self.qx_max, dx_size) 
     398        y_val = np.arange(self.qy_max, self.qy_min, -dy_size) 
     399        q_1, q_2 = np.meshgrid(x_val, y_val) 
    400400        #q_phi = numpy.arctan(q_1,q_2) 
    401401        # check whether polar or cartesian 
    … …  
    889889        x_value = x_val - x0_val 
    890890        y_value = y_val - y0_val 
    891         phi_i = numpy.arctan2(y_val, x_val) 
     891        phi_i = np.arctan2(y_val, x_val) 
    892892 
    893893        # phi correction due to the gravity shift (in phi) 
    … …  
    895895        phi_i = phi_i - phi_0 + self.gravity_phi 
    896896 
    897         sin_phi = numpy.sin(self.gravity_phi) 
    898         cos_phi = numpy.cos(self.gravity_phi) 
     897        sin_phi = np.sin(self.gravity_phi) 
     898        cos_phi = np.cos(self.gravity_phi) 
    899899 
    900900        x_p = x_value * cos_phi + y_value * sin_phi 
    … …  
    910910        nu_value = -0.5 * (new_x * new_x + new_y * new_y) 
    911911 
    912         gaussian = numpy.exp(nu_value) 
     912        gaussian = np.exp(nu_value) 
    913913        # normalizing factor correction 
    914914        gaussian /= gaussian.sum() 
    … …  
    956956            nu_value *= nu_value 
    957957            nu_value *= -0.5 
    958             gaussian *= numpy.exp(nu_value) 
     958            gaussian *= np.exp(nu_value) 
    959959            gaussian /= sigma 
    960960            # normalize 
    … …  
    10281028                                                           offset_x, offset_y) 
    10291029        # distance [cm] from the beam center on detector plane 
    1030         detector_ind_x = numpy.arange(detector_pix_nums_x) 
    1031         detector_ind_y = numpy.arange(detector_pix_nums_y) 
     1030        detector_ind_x = np.arange(detector_pix_nums_x) 
     1031        detector_ind_y = np.arange(detector_pix_nums_y) 
    10321032 
    10331033        # shif 0.5 pixel so that pix position is at the center of the pixel 
    … …  
    10431043        detector_ind_y = detector_ind_y * pix_y_size 
    10441044 
    1045         qx_value = numpy.zeros(len(detector_ind_x)) 
    1046         qy_value = numpy.zeros(len(detector_ind_y)) 
     1045        qx_value = np.zeros(len(detector_ind_x)) 
     1046        qy_value = np.zeros(len(detector_ind_y)) 
    10471047        i = 0 
    10481048 
    … …  
    10631063 
    10641064        # p min and max values among the center of pixels 
    1065         self.qx_min = numpy.min(qx_value) 
    1066         self.qx_max = numpy.max(qx_value) 
    1067         self.qy_min = numpy.min(qy_value) 
    1068         self.qy_max = numpy.max(qy_value) 
     1065        self.qx_min = np.min(qx_value) 
     1066        self.qx_max = np.max(qx_value) 
     1067        self.qy_min = np.min(qy_value) 
     1068        self.qy_max = np.max(qy_value) 
    10691069 
    10701070        # Appr. min and max values of the detector display limits 
    … …  
    10901090            from sas.sascalc.dataloader.data_info import Data2D 
    10911091            output = Data2D() 
    1092             inten = numpy.zeros_like(qx_value) 
     1092            inten = np.zeros_like(qx_value) 
    10931093            output.data = inten 
    10941094            output.qx_data = qx_value 
    … …  
    11091109        plane_dist = dx_size 
    11101110        # full scattering angle on the x-axis 
    1111         theta = numpy.arctan(plane_dist / det_dist) 
    1112         qx_value = (2.0 * pi / wavelength) * numpy.sin(theta) 
     1111        theta = np.arctan(plane_dist / det_dist) 
     1112        qx_value = (2.0 * pi / wavelength) * np.sin(theta) 
    11131113        return qx_value 
    11141114 

  • src/sas/sascalc/calculator/sas_gen.py

    r463e7ffc r9c0f3c17  
    77from periodictable import formula 
    88from periodictable import nsf 
    9 import numpy 
     9import numpy as np 
    1010import os 
    1111import copy 
    … …  
    8282        ## Parameter details [units, min, max] 
    8383        self.details = {} 
    84         self.details['scale'] = ['', 0.0, numpy.inf] 
    85         self.details['background'] = ['[1/cm]', 0.0, numpy.inf] 
    86         self.details['solvent_SLD'] = ['1/A^(2)', -numpy.inf, numpy.inf] 
    87         self.details['total_volume'] = ['A^(3)', 0.0, numpy.inf] 
     84        self.details['scale'] = ['', 0.0, np.inf] 
     85        self.details['background'] = ['[1/cm]', 0.0, np.inf] 
     86        self.details['solvent_SLD'] = ['1/A^(2)', -np.inf, np.inf] 
     87        self.details['total_volume'] = ['A^(3)', 0.0, np.inf] 
    8888        self.details['Up_frac_in'] = ['[u/(u+d)]', 0.0, 1.0] 
    8989        self.details['Up_frac_out'] = ['[u/(u+d)]', 0.0, 1.0] 
    90         self.details['Up_theta'] = ['[deg]', -numpy.inf, numpy.inf] 
     90        self.details['Up_theta'] = ['[deg]', -np.inf, np.inf] 
    9191        # fixed parameters 
    9292        self.fixed = [] 
    … …  
    173173                msg = "Not a 1D." 
    174174                raise ValueError, msg 
    175             i_out = numpy.zeros_like(x[0]) 
     175            i_out = np.zeros_like(x[0]) 
    176176            # 1D I is found at y =0 in the 2D pattern 
    177177            out = self._gen(x[0], [], i_out) 
    … …  
    189189        """ 
    190190        if x.__class__.__name__ == 'list': 
    191             i_out = numpy.zeros_like(x[0]) 
     191            i_out = np.zeros_like(x[0]) 
    192192            out = self._gen(x[0], x[1], i_out) 
    193193            return out 
    … …  
    239239        self.omfdata = omfdata 
    240240        length = int(omfdata.xnodes * omfdata.ynodes * omfdata.znodes) 
    241         pos_x = numpy.arange(omfdata.xmin, 
     241        pos_x = np.arange(omfdata.xmin, 
    242242                             omfdata.xnodes*omfdata.xstepsize + omfdata.xmin, 
    243243                             omfdata.xstepsize) 
    244         pos_y = numpy.arange(omfdata.ymin, 
     244        pos_y = np.arange(omfdata.ymin, 
    245245                             omfdata.ynodes*omfdata.ystepsize + omfdata.ymin, 
    246246                             omfdata.ystepsize) 
    247         pos_z = numpy.arange(omfdata.zmin, 
     247        pos_z = np.arange(omfdata.zmin, 
    248248                             omfdata.znodes*omfdata.zstepsize + omfdata.zmin, 
    249249                             omfdata.zstepsize) 
    250         self.pos_x = numpy.tile(pos_x, int(omfdata.ynodes * omfdata.znodes)) 
     250        self.pos_x = np.tile(pos_x, int(omfdata.ynodes * omfdata.znodes)) 
    251251        self.pos_y = pos_y.repeat(int(omfdata.xnodes)) 
    252         self.pos_y = numpy.tile(self.pos_y, int(omfdata.znodes)) 
     252        self.pos_y = np.tile(self.pos_y, int(omfdata.znodes)) 
    253253        self.pos_z = pos_z.repeat(int(omfdata.xnodes * omfdata.ynodes)) 
    254254        self.mx = omfdata.mx 
    255255        self.my = omfdata.my 
    256256        self.mz = omfdata.mz 
    257         self.sld_n = numpy.zeros(length) 
     257        self.sld_n = np.zeros(length) 
    258258 
    259259        if omfdata.mx == None: 
    260             self.mx = numpy.zeros(length) 
     260            self.mx = np.zeros(length) 
    261261        if omfdata.my == None: 
    262             self.my = numpy.zeros(length) 
     262            self.my = np.zeros(length) 
    263263        if omfdata.mz == None: 
    264             self.mz = numpy.zeros(length) 
     264            self.mz = np.zeros(length) 
    265265 
    266266        self._check_data_length(length) 
    267267        self.remove_null_points(False, False) 
    268         mask = numpy.ones(len(self.sld_n), dtype=bool) 
     268        mask = np.ones(len(self.sld_n), dtype=bool) 
    269269        if shape.lower() == 'ellipsoid': 
    270270            try: 
    … …  
    330330        """ 
    331331        if remove: 
    332             is_nonzero = (numpy.fabs(self.mx) + numpy.fabs(self.my) + 
    333                           numpy.fabs(self.mz)).nonzero() 
     332            is_nonzero = (np.fabs(self.mx) + np.fabs(self.my) + 
     333                          np.fabs(self.mz)).nonzero() 
    334334            if len(is_nonzero[0]) > 0: 
    335335                self.pos_x = self.pos_x[is_nonzero] 
    … …  
    371371        """ 
    372372        desc = "" 
    373         mx = numpy.zeros(0) 
    374         my = numpy.zeros(0) 
    375         mz = numpy.zeros(0) 
     373        mx = np.zeros(0) 
     374        my = np.zeros(0) 
     375        mz = np.zeros(0) 
    376376        try: 
    377377            input_f = open(path, 'rb') 
    … …  
    391391                    _my = mag2sld(_my, valueunit) 
    392392                    _mz = mag2sld(_mz, valueunit) 
    393                     mx = numpy.append(mx, _mx) 
    394                     my = numpy.append(my, _my) 
    395                     mz = numpy.append(mz, _mz) 
     393                    mx = np.append(mx, _mx) 
     394                    my = np.append(my, _my) 
     395                    mz = np.append(mz, _mz) 
    396396                except: 
    397397                    # Skip non-data lines 
    … …  
    503503        :raise RuntimeError: when the file can't be opened 
    504504        """ 
    505         pos_x = numpy.zeros(0) 
    506         pos_y = numpy.zeros(0) 
    507         pos_z = numpy.zeros(0) 
    508         sld_n = numpy.zeros(0) 
    509         sld_mx = numpy.zeros(0) 
    510         sld_my = numpy.zeros(0) 
    511         sld_mz = numpy.zeros(0) 
    512         vol_pix = numpy.zeros(0) 
    513         pix_symbol = numpy.zeros(0) 
     505        pos_x = np.zeros(0) 
     506        pos_y = np.zeros(0) 
     507        pos_z = np.zeros(0) 
     508        sld_n = np.zeros(0) 
     509        sld_mx = np.zeros(0) 
     510        sld_my = np.zeros(0) 
     511        sld_mz = np.zeros(0) 
     512        vol_pix = np.zeros(0) 
     513        pix_symbol = np.zeros(0) 
    514514        x_line = [] 
    515515        y_line = [] 
    … …  
    545545                        _pos_y = float(line[38:46].strip()) 
    546546                        _pos_z = float(line[46:54].strip()) 
    547                         pos_x = numpy.append(pos_x, _pos_x) 
    548                         pos_y = numpy.append(pos_y, _pos_y) 
    549                         pos_z = numpy.append(pos_z, _pos_z) 
     547                        pos_x = np.append(pos_x, _pos_x) 
     548                        pos_y = np.append(pos_y, _pos_y) 
     549                        pos_z = np.append(pos_z, _pos_z) 
    550550                        try: 
    551551                            val = nsf.neutron_sld(atom_name)[0] 
    552552                            # sld in Ang^-2 unit 
    553553                            val *= 1.0e-6 
    554                             sld_n = numpy.append(sld_n, val) 
     554                            sld_n = np.append(sld_n, val) 
    555555                            atom = formula(atom_name) 
    556556                            # cm to A units 
    557557                            vol = 1.0e+24 * atom.mass / atom.density / NA 
    558                             vol_pix = numpy.append(vol_pix, vol) 
     558                            vol_pix = np.append(vol_pix, vol) 
    559559                        except: 
    560560                            print "Error: set the sld of %s to zero"% atom_name 
    561                             sld_n = numpy.append(sld_n, 0.0) 
    562                         sld_mx = numpy.append(sld_mx, 0) 
    563                         sld_my = numpy.append(sld_my, 0) 
    564                         sld_mz = numpy.append(sld_mz, 0) 
    565                         pix_symbol = numpy.append(pix_symbol, atom_name) 
     561                            sld_n = np.append(sld_n, 0.0) 
     562                        sld_mx = np.append(sld_mx, 0) 
     563                        sld_my = np.append(sld_my, 0) 
     564                        sld_mz = np.append(sld_mz, 0) 
     565                        pix_symbol = np.append(pix_symbol, atom_name) 
    566566                    elif line[0:6].strip().count('CONECT') > 0: 
    567567                        toks = line.split() 
    … …  
    632632        """ 
    633633        try: 
    634             pos_x = numpy.zeros(0) 
    635             pos_y = numpy.zeros(0) 
    636             pos_z = numpy.zeros(0) 
    637             sld_n = numpy.zeros(0) 
    638             sld_mx = numpy.zeros(0) 
    639             sld_my = numpy.zeros(0) 
    640             sld_mz = numpy.zeros(0) 
     634            pos_x = np.zeros(0) 
     635            pos_y = np.zeros(0) 
     636            pos_z = np.zeros(0) 
     637            sld_n = np.zeros(0) 
     638            sld_mx = np.zeros(0) 
     639            sld_my = np.zeros(0) 
     640            sld_mz = np.zeros(0) 
    641641            try: 
    642642                # Use numpy to speed up loading 
    643                 input_f = numpy.loadtxt(path, dtype='float', skiprows=1, 
     643                input_f = np.loadtxt(path, dtype='float', skiprows=1, 
    644644                                        ndmin=1, unpack=True) 
    645                 pos_x = numpy.array(input_f[0]) 
    646                 pos_y = numpy.array(input_f[1]) 
    647                 pos_z = numpy.array(input_f[2]) 
    648                 sld_n = numpy.array(input_f[3]) 
    649                 sld_mx = numpy.array(input_f[4]) 
    650                 sld_my = numpy.array(input_f[5]) 
    651                 sld_mz = numpy.array(input_f[6]) 
     645                pos_x = np.array(input_f[0]) 
     646                pos_y = np.array(input_f[1]) 
     647                pos_z = np.array(input_f[2]) 
     648                sld_n = np.array(input_f[3]) 
     649                sld_mx = np.array(input_f[4]) 
     650                sld_my = np.array(input_f[5]) 
     651                sld_mz = np.array(input_f[6]) 
    652652                ncols = len(input_f) 
    653653                if ncols == 8: 
    654                     vol_pix = numpy.array(input_f[7]) 
     654                    vol_pix = np.array(input_f[7]) 
    655655                elif ncols == 7: 
    656656                    vol_pix = None 
    … …  
    671671                        _sld_my = float(toks[5]) 
    672672                        _sld_mz = float(toks[6]) 
    673                         pos_x = numpy.append(pos_x, _pos_x) 
    674                         pos_y = numpy.append(pos_y, _pos_y) 
    675                         pos_z = numpy.append(pos_z, _pos_z) 
    676                         sld_n = numpy.append(sld_n, _sld_n) 
    677                         sld_mx = numpy.append(sld_mx, _sld_mx) 
    678                         sld_my = numpy.append(sld_my, _sld_my) 
    679                         sld_mz = numpy.append(sld_mz, _sld_mz) 
     673                        pos_x = np.append(pos_x, _pos_x) 
     674                        pos_y = np.append(pos_y, _pos_y) 
     675                        pos_z = np.append(pos_z, _pos_z) 
     676                        sld_n = np.append(sld_n, _sld_n) 
     677                        sld_mx = np.append(sld_mx, _sld_mx) 
     678                        sld_my = np.append(sld_my, _sld_my) 
     679                        sld_mz = np.append(sld_mz, _sld_mz) 
    680680                        try: 
    681681                            _vol_pix = float(toks[7]) 
    682                             vol_pix = numpy.append(vol_pix, _vol_pix) 
     682                            vol_pix = np.append(vol_pix, _vol_pix) 
    683683                        except: 
    684684                            vol_pix = None 
    … …  
    714714        sld_n = data.sld_n 
    715715        if sld_n == None: 
    716             sld_n = numpy.zeros(length) 
     716            sld_n = np.zeros(length) 
    717717        sld_mx = data.sld_mx 
    718718        if sld_mx == None: 
    719             sld_mx = numpy.zeros(length) 
    720             sld_my = numpy.zeros(length) 
    721             sld_mz = numpy.zeros(length) 
     719            sld_mx = np.zeros(length) 
     720            sld_my = np.zeros(length) 
     721            sld_mz = np.zeros(length) 
    722722        else: 
    723723            sld_my = data.sld_my 
    … …  
    895895            if self.is_data: 
    896896                # For data, put the value to only the pixels w non-zero M 
    897                 is_nonzero = (numpy.fabs(self.sld_mx) + 
    898                               numpy.fabs(self.sld_my) + 
    899                               numpy.fabs(self.sld_mz)).nonzero() 
    900                 self.sld_n = numpy.zeros(len(self.pos_x)) 
     897                is_nonzero = (np.fabs(self.sld_mx) + 
     898                              np.fabs(self.sld_my) + 
     899                              np.fabs(self.sld_mz)).nonzero() 
     900                self.sld_n = np.zeros(len(self.pos_x)) 
    901901                if len(self.sld_n[is_nonzero]) > 0: 
    902902                    self.sld_n[is_nonzero] = sld_n 
    … …  
    905905            else: 
    906906                # For non-data, put the value to all the pixels 
    907                 self.sld_n = numpy.ones(len(self.pos_x)) * sld_n 
     907                self.sld_n = np.ones(len(self.pos_x)) * sld_n 
    908908        else: 
    909909            self.sld_n = sld_n 
    … …  
    914914        """ 
    915915        if sld_mx.__class__.__name__ == 'float': 
    916             self.sld_mx = numpy.ones(len(self.pos_x)) * sld_mx 
     916            self.sld_mx = np.ones(len(self.pos_x)) * sld_mx 
    917917        else: 
    918918            self.sld_mx = sld_mx 
    919919        if sld_my.__class__.__name__ == 'float': 
    920             self.sld_my = numpy.ones(len(self.pos_x)) * sld_my 
     920            self.sld_my = np.ones(len(self.pos_x)) * sld_my 
    921921        else: 
    922922            self.sld_my = sld_my 
    923923        if sld_mz.__class__.__name__ == 'float': 
    924             self.sld_mz = numpy.ones(len(self.pos_x)) * sld_mz 
     924            self.sld_mz = np.ones(len(self.pos_x)) * sld_mz 
    925925        else: 
    926926            self.sld_mz = sld_mz 
    927927 
    928         sld_m = numpy.sqrt(sld_mx * sld_mx + sld_my * sld_my + \ 
     928        sld_m = np.sqrt(sld_mx * sld_mx + sld_my * sld_my + \ 
    929929                                sld_mz * sld_mz) 
    930930        self.sld_m = sld_m 
    … …  
    938938            return 
    939939        if symbol.__class__.__name__ == 'str': 
    940             self.pix_symbol = numpy.repeat(symbol, len(self.sld_n)) 
     940            self.pix_symbol = np.repeat(symbol, len(self.sld_n)) 
    941941        else: 
    942942            self.pix_symbol = symbol 
    … …  
    952952            self.vol_pix = vol 
    953953        elif vol.__class__.__name__.count('float') > 0: 
    954             self.vol_pix = numpy.repeat(vol, len(self.sld_n)) 
     954            self.vol_pix = np.repeat(vol, len(self.sld_n)) 
    955955        else: 
    956956            self.vol_pix = None 
    … …  
    995995                for x_pos in self.pos_x: 
    996996                    if xpos_pre != x_pos: 
    997                         self.xstepsize = numpy.fabs(x_pos - xpos_pre) 
     997                        self.xstepsize = np.fabs(x_pos - xpos_pre) 
    998998                        break 
    999999                for y_pos in self.pos_y: 
    10001000                    if ypos_pre != y_pos: 
    1001                         self.ystepsize = numpy.fabs(y_pos - ypos_pre) 
     1001                        self.ystepsize = np.fabs(y_pos - ypos_pre) 
    10021002                        break 
    10031003                for z_pos in self.pos_z: 
    10041004                    if zpos_pre != z_pos: 
    1005                         self.zstepsize = numpy.fabs(z_pos - zpos_pre) 
     1005                        self.zstepsize = np.fabs(z_pos - zpos_pre) 
    10061006                        break 
    10071007                #default pix volume 
    1008                 self.vol_pix = numpy.ones(len(self.pos_x)) 
     1008                self.vol_pix = np.ones(len(self.pos_x)) 
    10091009                vol = self.xstepsize * self.ystepsize * self.zstepsize 
    10101010                self.set_pixel_volumes(vol) 
    … …  
    10731073    y2 = output.pos_y+output.sld_my/max_m * gap 
    10741074    z2 = output.pos_z+output.sld_mz/max_m * gap 
    1075     x_arrow = numpy.column_stack((output.pos_x, x2)) 
    1076     y_arrow = numpy.column_stack((output.pos_y, y2)) 
    1077     z_arrow = numpy.column_stack((output.pos_z, z2)) 
     1075    x_arrow = np.column_stack((output.pos_x, x2)) 
     1076    y_arrow = np.column_stack((output.pos_y, y2)) 
     1077    z_arrow = np.column_stack((output.pos_z, z2)) 
    10781078    unit_x2 = output.sld_mx / max_m 
    10791079    unit_y2 = output.sld_my / max_m 
    10801080    unit_z2 = output.sld_mz / max_m 
    1081     color_x = numpy.fabs(unit_x2 * 0.8) 
    1082     color_y = numpy.fabs(unit_y2 * 0.8) 
    1083     color_z = numpy.fabs(unit_z2 * 0.8) 
    1084     colors = numpy.column_stack((color_x, color_y, color_z)) 
     1081    color_x = np.fabs(unit_x2 * 0.8) 
     1082    color_y = np.fabs(unit_y2 * 0.8) 
     1083    color_z = np.fabs(unit_z2 * 0.8) 
     1084    colors = np.column_stack((color_x, color_y, color_z)) 
    10851085    plt.show() 
    10861086 
    … …  
    11051105    model = GenSAS() 
    11061106    model.set_sld_data(foutput.output) 
    1107     x = numpy.arange(1000)/10000. + 1e-5 
    1108     y = numpy.arange(1000)/10000. + 1e-5 
    1109     i = numpy.zeros(1000) 
     1107    x = np.arange(1000)/10000. + 1e-5 
     1108    y = np.arange(1000)/10000. + 1e-5 
     1109    i = np.zeros(1000) 
    11101110    model.runXY([x, y, i]) 
    11111111 
Note: See TracChangeset for help on using the changeset viewer.