Ignore:
Timestamp:
Mar 26, 2017 9:33:16 PM (7 years ago)
Author:
andyfaff
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:
ed2276f
Parents:
9146ed9
Message:

MAINT: import numpy as np

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rd2fd8fc r9a5097c  
    77from periodictable import formula 
    88from periodictable import nsf 
    9 import numpy 
     9import numpy as np 
    1010import os 
    1111import copy 
    … …  
    8080        ## Parameter details [units, min, max] 
    8181        self.details = {} 
    82         self.details['scale'] = ['', 0.0, numpy.inf] 
    83         self.details['background'] = ['[1/cm]', 0.0, numpy.inf] 
    84         self.details['solvent_SLD'] = ['1/A^(2)', -numpy.inf, numpy.inf] 
    85         self.details['total_volume'] = ['A^(3)', 0.0, numpy.inf] 
     82        self.details['scale'] = ['', 0.0, np.inf] 
     83        self.details['background'] = ['[1/cm]', 0.0, np.inf] 
     84        self.details['solvent_SLD'] = ['1/A^(2)', -np.inf, np.inf] 
     85        self.details['total_volume'] = ['A^(3)', 0.0, np.inf] 
    8686        self.details['Up_frac_in'] = ['[u/(u+d)]', 0.0, 1.0] 
    8787        self.details['Up_frac_out'] = ['[u/(u+d)]', 0.0, 1.0] 
    88         self.details['Up_theta'] = ['[deg]', -numpy.inf, numpy.inf] 
     88        self.details['Up_theta'] = ['[deg]', -np.inf, np.inf] 
    8989        # fixed parameters 
    9090        self.fixed = [] 
    … …  
    171171                msg = "Not a 1D." 
    172172                raise ValueError, msg 
    173             i_out = numpy.zeros_like(x[0]) 
     173            i_out = np.zeros_like(x[0]) 
    174174            # 1D I is found at y =0 in the 2D pattern 
    175175            out = self._gen(x[0], [], i_out) 
    … …  
    187187        """ 
    188188        if x.__class__.__name__ == 'list': 
    189             i_out = numpy.zeros_like(x[0]) 
     189            i_out = np.zeros_like(x[0]) 
    190190            out = self._gen(x[0], x[1], i_out) 
    191191            return out 
    … …  
    237237        self.omfdata = omfdata 
    238238        length = int(omfdata.xnodes * omfdata.ynodes * omfdata.znodes) 
    239         pos_x = numpy.arange(omfdata.xmin, 
     239        pos_x = np.arange(omfdata.xmin, 
    240240                             omfdata.xnodes*omfdata.xstepsize + omfdata.xmin, 
    241241                             omfdata.xstepsize) 
    242         pos_y = numpy.arange(omfdata.ymin, 
     242        pos_y = np.arange(omfdata.ymin, 
    243243                             omfdata.ynodes*omfdata.ystepsize + omfdata.ymin, 
    244244                             omfdata.ystepsize) 
    245         pos_z = numpy.arange(omfdata.zmin, 
     245        pos_z = np.arange(omfdata.zmin, 
    246246                             omfdata.znodes*omfdata.zstepsize + omfdata.zmin, 
    247247                             omfdata.zstepsize) 
    248         self.pos_x = numpy.tile(pos_x, int(omfdata.ynodes * omfdata.znodes)) 
     248        self.pos_x = np.tile(pos_x, int(omfdata.ynodes * omfdata.znodes)) 
    249249        self.pos_y = pos_y.repeat(int(omfdata.xnodes)) 
    250         self.pos_y = numpy.tile(self.pos_y, int(omfdata.znodes)) 
     250        self.pos_y = np.tile(self.pos_y, int(omfdata.znodes)) 
    251251        self.pos_z = pos_z.repeat(int(omfdata.xnodes * omfdata.ynodes)) 
    252252        self.mx = omfdata.mx 
    253253        self.my = omfdata.my 
    254254        self.mz = omfdata.mz 
    255         self.sld_n = numpy.zeros(length) 
     255        self.sld_n = np.zeros(length) 
    256256 
    257257        if omfdata.mx == None: 
    258             self.mx = numpy.zeros(length) 
     258            self.mx = np.zeros(length) 
    259259        if omfdata.my == None: 
    260             self.my = numpy.zeros(length) 
     260            self.my = np.zeros(length) 
    261261        if omfdata.mz == None: 
    262             self.mz = numpy.zeros(length) 
     262            self.mz = np.zeros(length) 
    263263 
    264264        self._check_data_length(length) 
    265265        self.remove_null_points(False, False) 
    266         mask = numpy.ones(len(self.sld_n), dtype=bool) 
     266        mask = np.ones(len(self.sld_n), dtype=bool) 
    267267        if shape.lower() == 'ellipsoid': 
    268268            try: 
    … …  
    328328        """ 
    329329        if remove: 
    330             is_nonzero = (numpy.fabs(self.mx) + numpy.fabs(self.my) + 
    331                           numpy.fabs(self.mz)).nonzero() 
     330            is_nonzero = (np.fabs(self.mx) + np.fabs(self.my) + 
     331                          np.fabs(self.mz)).nonzero() 
    332332            if len(is_nonzero[0]) > 0: 
    333333                self.pos_x = self.pos_x[is_nonzero] 
    … …  
    369369        """ 
    370370        desc = "" 
    371         mx = numpy.zeros(0) 
    372         my = numpy.zeros(0) 
    373         mz = numpy.zeros(0) 
     371        mx = np.zeros(0) 
     372        my = np.zeros(0) 
     373        mz = np.zeros(0) 
    374374        try: 
    375375            input_f = open(path, 'rb') 
    … …  
    389389                    _my = mag2sld(_my, valueunit) 
    390390                    _mz = mag2sld(_mz, valueunit) 
    391                     mx = numpy.append(mx, _mx) 
    392                     my = numpy.append(my, _my) 
    393                     mz = numpy.append(mz, _mz) 
     391                    mx = np.append(mx, _mx) 
     392                    my = np.append(my, _my) 
     393                    mz = np.append(mz, _mz) 
    394394                except: 
    395395                    # Skip non-data lines 
    … …  
    501501        :raise RuntimeError: when the file can't be opened 
    502502        """ 
    503         pos_x = numpy.zeros(0) 
    504         pos_y = numpy.zeros(0) 
    505         pos_z = numpy.zeros(0) 
    506         sld_n = numpy.zeros(0) 
    507         sld_mx = numpy.zeros(0) 
    508         sld_my = numpy.zeros(0) 
    509         sld_mz = numpy.zeros(0) 
    510         vol_pix = numpy.zeros(0) 
    511         pix_symbol = numpy.zeros(0) 
     503        pos_x = np.zeros(0) 
     504        pos_y = np.zeros(0) 
     505        pos_z = np.zeros(0) 
     506        sld_n = np.zeros(0) 
     507        sld_mx = np.zeros(0) 
     508        sld_my = np.zeros(0) 
     509        sld_mz = np.zeros(0) 
     510        vol_pix = np.zeros(0) 
     511        pix_symbol = np.zeros(0) 
    512512        x_line = [] 
    513513        y_line = [] 
    … …  
    543543                        _pos_y = float(line[38:46].strip()) 
    544544                        _pos_z = float(line[46:54].strip()) 
    545                         pos_x = numpy.append(pos_x, _pos_x) 
    546                         pos_y = numpy.append(pos_y, _pos_y) 
    547                         pos_z = numpy.append(pos_z, _pos_z) 
     545                        pos_x = np.append(pos_x, _pos_x) 
     546                        pos_y = np.append(pos_y, _pos_y) 
     547                        pos_z = np.append(pos_z, _pos_z) 
    548548                        try: 
    549549                            val = nsf.neutron_sld(atom_name)[0] 
    550550                            # sld in Ang^-2 unit 
    551551                            val *= 1.0e-6 
    552                             sld_n = numpy.append(sld_n, val) 
     552                            sld_n = np.append(sld_n, val) 
    553553                            atom = formula(atom_name) 
    554554                            # cm to A units 
    555555                            vol = 1.0e+24 * atom.mass / atom.density / NA 
    556                             vol_pix = numpy.append(vol_pix, vol) 
     556                            vol_pix = np.append(vol_pix, vol) 
    557557                        except: 
    558558                            print "Error: set the sld of %s to zero"% atom_name 
    559                             sld_n = numpy.append(sld_n, 0.0) 
    560                         sld_mx = numpy.append(sld_mx, 0) 
    561                         sld_my = numpy.append(sld_my, 0) 
    562                         sld_mz = numpy.append(sld_mz, 0) 
    563                         pix_symbol = numpy.append(pix_symbol, atom_name) 
     559                            sld_n = np.append(sld_n, 0.0) 
     560                        sld_mx = np.append(sld_mx, 0) 
     561                        sld_my = np.append(sld_my, 0) 
     562                        sld_mz = np.append(sld_mz, 0) 
     563                        pix_symbol = np.append(pix_symbol, atom_name) 
    564564                    elif line[0:6].strip().count('CONECT') > 0: 
    565565                        toks = line.split() 
    … …  
    630630        """ 
    631631        try: 
    632             pos_x = numpy.zeros(0) 
    633             pos_y = numpy.zeros(0) 
    634             pos_z = numpy.zeros(0) 
    635             sld_n = numpy.zeros(0) 
    636             sld_mx = numpy.zeros(0) 
    637             sld_my = numpy.zeros(0) 
    638             sld_mz = numpy.zeros(0) 
     632            pos_x = np.zeros(0) 
     633            pos_y = np.zeros(0) 
     634            pos_z = np.zeros(0) 
     635            sld_n = np.zeros(0) 
     636            sld_mx = np.zeros(0) 
     637            sld_my = np.zeros(0) 
     638            sld_mz = np.zeros(0) 
    639639            try: 
    640640                # Use numpy to speed up loading 
    641                 input_f = numpy.loadtxt(path, dtype='float', skiprows=1, 
     641                input_f = np.loadtxt(path, dtype='float', skiprows=1, 
    642642                                        ndmin=1, unpack=True) 
    643                 pos_x = numpy.array(input_f[0]) 
    644                 pos_y = numpy.array(input_f[1]) 
    645                 pos_z = numpy.array(input_f[2]) 
    646                 sld_n = numpy.array(input_f[3]) 
    647                 sld_mx = numpy.array(input_f[4]) 
    648                 sld_my = numpy.array(input_f[5]) 
    649                 sld_mz = numpy.array(input_f[6]) 
     643                pos_x = np.array(input_f[0]) 
     644                pos_y = np.array(input_f[1]) 
     645                pos_z = np.array(input_f[2]) 
     646                sld_n = np.array(input_f[3]) 
     647                sld_mx = np.array(input_f[4]) 
     648                sld_my = np.array(input_f[5]) 
     649                sld_mz = np.array(input_f[6]) 
    650650                ncols = len(input_f) 
    651651                if ncols == 8: 
    652                     vol_pix = numpy.array(input_f[7]) 
     652                    vol_pix = np.array(input_f[7]) 
    653653                elif ncols == 7: 
    654654                    vol_pix = None 
    … …  
    669669                        _sld_my = float(toks[5]) 
    670670                        _sld_mz = float(toks[6]) 
    671                         pos_x = numpy.append(pos_x, _pos_x) 
    672                         pos_y = numpy.append(pos_y, _pos_y) 
    673                         pos_z = numpy.append(pos_z, _pos_z) 
    674                         sld_n = numpy.append(sld_n, _sld_n) 
    675                         sld_mx = numpy.append(sld_mx, _sld_mx) 
    676                         sld_my = numpy.append(sld_my, _sld_my) 
    677                         sld_mz = numpy.append(sld_mz, _sld_mz) 
     671                        pos_x = np.append(pos_x, _pos_x) 
     672                        pos_y = np.append(pos_y, _pos_y) 
     673                        pos_z = np.append(pos_z, _pos_z) 
     674                        sld_n = np.append(sld_n, _sld_n) 
     675                        sld_mx = np.append(sld_mx, _sld_mx) 
     676                        sld_my = np.append(sld_my, _sld_my) 
     677                        sld_mz = np.append(sld_mz, _sld_mz) 
    678678                        try: 
    679679                            _vol_pix = float(toks[7]) 
    680                             vol_pix = numpy.append(vol_pix, _vol_pix) 
     680                            vol_pix = np.append(vol_pix, _vol_pix) 
    681681                        except: 
    682682                            vol_pix = None 
    … …  
    712712        sld_n = data.sld_n 
    713713        if sld_n == None: 
    714             sld_n = numpy.zeros(length) 
     714            sld_n = np.zeros(length) 
    715715        sld_mx = data.sld_mx 
    716716        if sld_mx == None: 
    717             sld_mx = numpy.zeros(length) 
    718             sld_my = numpy.zeros(length) 
    719             sld_mz = numpy.zeros(length) 
     717            sld_mx = np.zeros(length) 
     718            sld_my = np.zeros(length) 
     719            sld_mz = np.zeros(length) 
    720720        else: 
    721721            sld_my = data.sld_my 
    … …  
    893893            if self.is_data: 
    894894                # For data, put the value to only the pixels w non-zero M 
    895                 is_nonzero = (numpy.fabs(self.sld_mx) + 
    896                               numpy.fabs(self.sld_my) + 
    897                               numpy.fabs(self.sld_mz)).nonzero() 
    898                 self.sld_n = numpy.zeros(len(self.pos_x)) 
     895                is_nonzero = (np.fabs(self.sld_mx) + 
     896                              np.fabs(self.sld_my) + 
     897                              np.fabs(self.sld_mz)).nonzero() 
     898                self.sld_n = np.zeros(len(self.pos_x)) 
    899899                if len(self.sld_n[is_nonzero]) > 0: 
    900900                    self.sld_n[is_nonzero] = sld_n 
    … …  
    903903            else: 
    904904                # For non-data, put the value to all the pixels 
    905                 self.sld_n = numpy.ones(len(self.pos_x)) * sld_n 
     905                self.sld_n = np.ones(len(self.pos_x)) * sld_n 
    906906        else: 
    907907            self.sld_n = sld_n 
    … …  
    912912        """ 
    913913        if sld_mx.__class__.__name__ == 'float': 
    914             self.sld_mx = numpy.ones(len(self.pos_x)) * sld_mx 
     914            self.sld_mx = np.ones(len(self.pos_x)) * sld_mx 
    915915        else: 
    916916            self.sld_mx = sld_mx 
    917917        if sld_my.__class__.__name__ == 'float': 
    918             self.sld_my = numpy.ones(len(self.pos_x)) * sld_my 
     918            self.sld_my = np.ones(len(self.pos_x)) * sld_my 
    919919        else: 
    920920            self.sld_my = sld_my 
    921921        if sld_mz.__class__.__name__ == 'float': 
    922             self.sld_mz = numpy.ones(len(self.pos_x)) * sld_mz 
     922            self.sld_mz = np.ones(len(self.pos_x)) * sld_mz 
    923923        else: 
    924924            self.sld_mz = sld_mz 
    925925 
    926         sld_m = numpy.sqrt(sld_mx * sld_mx + sld_my * sld_my + \ 
     926        sld_m = np.sqrt(sld_mx * sld_mx + sld_my * sld_my + \ 
    927927                                sld_mz * sld_mz) 
    928928        self.sld_m = sld_m 
    … …  
    936936            return 
    937937        if symbol.__class__.__name__ == 'str': 
    938             self.pix_symbol = numpy.repeat(symbol, len(self.sld_n)) 
     938            self.pix_symbol = np.repeat(symbol, len(self.sld_n)) 
    939939        else: 
    940940            self.pix_symbol = symbol 
    … …  
    950950            self.vol_pix = vol 
    951951        elif vol.__class__.__name__.count('float') > 0: 
    952             self.vol_pix = numpy.repeat(vol, len(self.sld_n)) 
     952            self.vol_pix = np.repeat(vol, len(self.sld_n)) 
    953953        else: 
    954954            self.vol_pix = None 
    … …  
    993993                for x_pos in self.pos_x: 
    994994                    if xpos_pre != x_pos: 
    995                         self.xstepsize = numpy.fabs(x_pos - xpos_pre) 
     995                        self.xstepsize = np.fabs(x_pos - xpos_pre) 
    996996                        break 
    997997                for y_pos in self.pos_y: 
    998998                    if ypos_pre != y_pos: 
    999                         self.ystepsize = numpy.fabs(y_pos - ypos_pre) 
     999                        self.ystepsize = np.fabs(y_pos - ypos_pre) 
    10001000                        break 
    10011001                for z_pos in self.pos_z: 
    10021002                    if zpos_pre != z_pos: 
    1003                         self.zstepsize = numpy.fabs(z_pos - zpos_pre) 
     1003                        self.zstepsize = np.fabs(z_pos - zpos_pre) 
    10041004                        break 
    10051005                #default pix volume 
    1006                 self.vol_pix = numpy.ones(len(self.pos_x)) 
     1006                self.vol_pix = np.ones(len(self.pos_x)) 
    10071007                vol = self.xstepsize * self.ystepsize * self.zstepsize 
    10081008                self.set_pixel_volumes(vol) 
    … …  
    10711071    y2 = output.pos_y+output.sld_my/max_m * gap 
    10721072    z2 = output.pos_z+output.sld_mz/max_m * gap 
    1073     x_arrow = numpy.column_stack((output.pos_x, x2)) 
    1074     y_arrow = numpy.column_stack((output.pos_y, y2)) 
    1075     z_arrow = numpy.column_stack((output.pos_z, z2)) 
     1073    x_arrow = np.column_stack((output.pos_x, x2)) 
     1074    y_arrow = np.column_stack((output.pos_y, y2)) 
     1075    z_arrow = np.column_stack((output.pos_z, z2)) 
    10761076    unit_x2 = output.sld_mx / max_m 
    10771077    unit_y2 = output.sld_my / max_m 
    10781078    unit_z2 = output.sld_mz / max_m 
    1079     color_x = numpy.fabs(unit_x2 * 0.8) 
    1080     color_y = numpy.fabs(unit_y2 * 0.8) 
    1081     color_z = numpy.fabs(unit_z2 * 0.8) 
    1082     colors = numpy.column_stack((color_x, color_y, color_z)) 
     1079    color_x = np.fabs(unit_x2 * 0.8) 
     1080    color_y = np.fabs(unit_y2 * 0.8) 
     1081    color_z = np.fabs(unit_z2 * 0.8) 
     1082    colors = np.column_stack((color_x, color_y, color_z)) 
    10831083    plt.show() 
    10841084 
    … …  
    11031103    model = GenSAS() 
    11041104    model.set_sld_data(foutput.output) 
    1105     x = numpy.arange(1000)/10000. + 1e-5 
    1106     y = numpy.arange(1000)/10000. + 1e-5 
    1107     i = numpy.zeros(1000) 
     1105    x = np.arange(1000)/10000. + 1e-5 
     1106    y = np.arange(1000)/10000. + 1e-5 
     1107    i = np.zeros(1000) 
    11081108    model.runXY([x, y, i]) 
    11091109 
Note: See TracChangeset for help on using the changeset viewer.