Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r9a5097c r463e7ffc  
    77from periodictable import formula 
    88from periodictable import nsf 
    9 import numpy as np 
     9import numpy 
    1010import os 
    1111import copy 
    1212import sys 
    1313import logging 
     14 
     15logger = logging.getLogger(__name__) 
    1416 
    1517MFACTOR_AM = 2.853E-12 
    … …  
    8082        ## Parameter details [units, min, max] 
    8183        self.details = {} 
    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] 
     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] 
    8688        self.details['Up_frac_in'] = ['[u/(u+d)]', 0.0, 1.0] 
    8789        self.details['Up_frac_out'] = ['[u/(u+d)]', 0.0, 1.0] 
    88         self.details['Up_theta'] = ['[deg]', -np.inf, np.inf] 
     90        self.details['Up_theta'] = ['[deg]', -numpy.inf, numpy.inf] 
    8991        # fixed parameters 
    9092        self.fixed = [] 
    … …  
    171173                msg = "Not a 1D." 
    172174                raise ValueError, msg 
    173             i_out = np.zeros_like(x[0]) 
     175            i_out = numpy.zeros_like(x[0]) 
    174176            # 1D I is found at y =0 in the 2D pattern 
    175177            out = self._gen(x[0], [], i_out) 
    … …  
    187189        """ 
    188190        if x.__class__.__name__ == 'list': 
    189             i_out = np.zeros_like(x[0]) 
     191            i_out = numpy.zeros_like(x[0]) 
    190192            out = self._gen(x[0], x[1], i_out) 
    191193            return out 
    … …  
    237239        self.omfdata = omfdata 
    238240        length = int(omfdata.xnodes * omfdata.ynodes * omfdata.znodes) 
    239         pos_x = np.arange(omfdata.xmin, 
     241        pos_x = numpy.arange(omfdata.xmin, 
    240242                             omfdata.xnodes*omfdata.xstepsize + omfdata.xmin, 
    241243                             omfdata.xstepsize) 
    242         pos_y = np.arange(omfdata.ymin, 
     244        pos_y = numpy.arange(omfdata.ymin, 
    243245                             omfdata.ynodes*omfdata.ystepsize + omfdata.ymin, 
    244246                             omfdata.ystepsize) 
    245         pos_z = np.arange(omfdata.zmin, 
     247        pos_z = numpy.arange(omfdata.zmin, 
    246248                             omfdata.znodes*omfdata.zstepsize + omfdata.zmin, 
    247249                             omfdata.zstepsize) 
    248         self.pos_x = np.tile(pos_x, int(omfdata.ynodes * omfdata.znodes)) 
     250        self.pos_x = numpy.tile(pos_x, int(omfdata.ynodes * omfdata.znodes)) 
    249251        self.pos_y = pos_y.repeat(int(omfdata.xnodes)) 
    250         self.pos_y = np.tile(self.pos_y, int(omfdata.znodes)) 
     252        self.pos_y = numpy.tile(self.pos_y, int(omfdata.znodes)) 
    251253        self.pos_z = pos_z.repeat(int(omfdata.xnodes * omfdata.ynodes)) 
    252254        self.mx = omfdata.mx 
    253255        self.my = omfdata.my 
    254256        self.mz = omfdata.mz 
    255         self.sld_n = np.zeros(length) 
     257        self.sld_n = numpy.zeros(length) 
    256258 
    257259        if omfdata.mx == None: 
    258             self.mx = np.zeros(length) 
     260            self.mx = numpy.zeros(length) 
    259261        if omfdata.my == None: 
    260             self.my = np.zeros(length) 
     262            self.my = numpy.zeros(length) 
    261263        if omfdata.mz == None: 
    262             self.mz = np.zeros(length) 
     264            self.mz = numpy.zeros(length) 
    263265 
    264266        self._check_data_length(length) 
    265267        self.remove_null_points(False, False) 
    266         mask = np.ones(len(self.sld_n), dtype=bool) 
     268        mask = numpy.ones(len(self.sld_n), dtype=bool) 
    267269        if shape.lower() == 'ellipsoid': 
    268270            try: 
    … …  
    285287                mask = (x_dir2 + y_dir2 + z_dir2) <= 1.0 
    286288            except: 
    287                 logging.error(sys.exc_value) 
     289                logger.error(sys.exc_value) 
    288290        self.output = MagSLD(self.pos_x[mask], self.pos_y[mask], 
    289291                             self.pos_z[mask], self.sld_n[mask], 
    … …  
    328330        """ 
    329331        if remove: 
    330             is_nonzero = (np.fabs(self.mx) + np.fabs(self.my) + 
    331                           np.fabs(self.mz)).nonzero() 
     332            is_nonzero = (numpy.fabs(self.mx) + numpy.fabs(self.my) + 
     333                          numpy.fabs(self.mz)).nonzero() 
    332334            if len(is_nonzero[0]) > 0: 
    333335                self.pos_x = self.pos_x[is_nonzero] 
    … …  
    369371        """ 
    370372        desc = "" 
    371         mx = np.zeros(0) 
    372         my = np.zeros(0) 
    373         mz = np.zeros(0) 
     373        mx = numpy.zeros(0) 
     374        my = numpy.zeros(0) 
     375        mz = numpy.zeros(0) 
    374376        try: 
    375377            input_f = open(path, 'rb') 
    … …  
    389391                    _my = mag2sld(_my, valueunit) 
    390392                    _mz = mag2sld(_mz, valueunit) 
    391                     mx = np.append(mx, _mx) 
    392                     my = np.append(my, _my) 
    393                     mz = np.append(mz, _mz) 
     393                    mx = numpy.append(mx, _mx) 
     394                    my = numpy.append(my, _my) 
     395                    mz = numpy.append(mz, _mz) 
    394396                except: 
    395397                    # Skip non-data lines 
    396                     logging.error(sys.exc_value) 
     398                    logger.error(sys.exc_value) 
    397399                #Reading Header; Segment count ignored 
    398400                s_line = line.split(":", 1) 
    … …  
    501503        :raise RuntimeError: when the file can't be opened 
    502504        """ 
    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) 
     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) 
    512514        x_line = [] 
    513515        y_line = [] 
    … …  
    543545                        _pos_y = float(line[38:46].strip()) 
    544546                        _pos_z = float(line[46:54].strip()) 
    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) 
     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) 
    548550                        try: 
    549551                            val = nsf.neutron_sld(atom_name)[0] 
    550552                            # sld in Ang^-2 unit 
    551553                            val *= 1.0e-6 
    552                             sld_n = np.append(sld_n, val) 
     554                            sld_n = numpy.append(sld_n, val) 
    553555                            atom = formula(atom_name) 
    554556                            # cm to A units 
    555557                            vol = 1.0e+24 * atom.mass / atom.density / NA 
    556                             vol_pix = np.append(vol_pix, vol) 
     558                            vol_pix = numpy.append(vol_pix, vol) 
    557559                        except: 
    558560                            print "Error: set the sld of %s to zero"% 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) 
     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) 
    564566                    elif line[0:6].strip().count('CONECT') > 0: 
    565567                        toks = line.split() 
    … …  
    589591                        z_lines.append(z_line) 
    590592                except: 
    591                     logging.error(sys.exc_value) 
     593                    logger.error(sys.exc_value) 
    592594 
    593595            output = MagSLD(pos_x, pos_y, pos_z, sld_n, sld_mx, sld_my, sld_mz) 
    … …  
    630632        """ 
    631633        try: 
    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) 
     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) 
    639641            try: 
    640642                # Use numpy to speed up loading 
    641                 input_f = np.loadtxt(path, dtype='float', skiprows=1, 
     643                input_f = numpy.loadtxt(path, dtype='float', skiprows=1, 
    642644                                        ndmin=1, unpack=True) 
    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]) 
     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]) 
    650652                ncols = len(input_f) 
    651653                if ncols == 8: 
    652                     vol_pix = np.array(input_f[7]) 
     654                    vol_pix = numpy.array(input_f[7]) 
    653655                elif ncols == 7: 
    654656                    vol_pix = None 
    … …  
    669671                        _sld_my = float(toks[5]) 
    670672                        _sld_mz = float(toks[6]) 
    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) 
     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) 
    678680                        try: 
    679681                            _vol_pix = float(toks[7]) 
    680                             vol_pix = np.append(vol_pix, _vol_pix) 
     682                            vol_pix = numpy.append(vol_pix, _vol_pix) 
    681683                        except: 
    682684                            vol_pix = None 
    683685                    except: 
    684686                        # Skip non-data lines 
    685                         logging.error(sys.exc_value) 
     687                        logger.error(sys.exc_value) 
    686688            output = MagSLD(pos_x, pos_y, pos_z, sld_n, 
    687689                            sld_mx, sld_my, sld_mz) 
    … …  
    712714        sld_n = data.sld_n 
    713715        if sld_n == None: 
    714             sld_n = np.zeros(length) 
     716            sld_n = numpy.zeros(length) 
    715717        sld_mx = data.sld_mx 
    716718        if sld_mx == None: 
    717             sld_mx = np.zeros(length) 
    718             sld_my = np.zeros(length) 
    719             sld_mz = np.zeros(length) 
     719            sld_mx = numpy.zeros(length) 
     720            sld_my = numpy.zeros(length) 
     721            sld_mz = numpy.zeros(length) 
    720722        else: 
    721723            sld_my = data.sld_my 
    … …  
    893895            if self.is_data: 
    894896                # For data, put the value to only the pixels w non-zero M 
    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)) 
     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)) 
    899901                if len(self.sld_n[is_nonzero]) > 0: 
    900902                    self.sld_n[is_nonzero] = sld_n 
    … …  
    903905            else: 
    904906                # For non-data, put the value to all the pixels 
    905                 self.sld_n = np.ones(len(self.pos_x)) * sld_n 
     907                self.sld_n = numpy.ones(len(self.pos_x)) * sld_n 
    906908        else: 
    907909            self.sld_n = sld_n 
    … …  
    912914        """ 
    913915        if sld_mx.__class__.__name__ == 'float': 
    914             self.sld_mx = np.ones(len(self.pos_x)) * sld_mx 
     916            self.sld_mx = numpy.ones(len(self.pos_x)) * sld_mx 
    915917        else: 
    916918            self.sld_mx = sld_mx 
    917919        if sld_my.__class__.__name__ == 'float': 
    918             self.sld_my = np.ones(len(self.pos_x)) * sld_my 
     920            self.sld_my = numpy.ones(len(self.pos_x)) * sld_my 
    919921        else: 
    920922            self.sld_my = sld_my 
    921923        if sld_mz.__class__.__name__ == 'float': 
    922             self.sld_mz = np.ones(len(self.pos_x)) * sld_mz 
     924            self.sld_mz = numpy.ones(len(self.pos_x)) * sld_mz 
    923925        else: 
    924926            self.sld_mz = sld_mz 
    925927 
    926         sld_m = np.sqrt(sld_mx * sld_mx + sld_my * sld_my + \ 
     928        sld_m = numpy.sqrt(sld_mx * sld_mx + sld_my * sld_my + \ 
    927929                                sld_mz * sld_mz) 
    928930        self.sld_m = sld_m 
    … …  
    936938            return 
    937939        if symbol.__class__.__name__ == 'str': 
    938             self.pix_symbol = np.repeat(symbol, len(self.sld_n)) 
     940            self.pix_symbol = numpy.repeat(symbol, len(self.sld_n)) 
    939941        else: 
    940942            self.pix_symbol = symbol 
    … …  
    950952            self.vol_pix = vol 
    951953        elif vol.__class__.__name__.count('float') > 0: 
    952             self.vol_pix = np.repeat(vol, len(self.sld_n)) 
     954            self.vol_pix = numpy.repeat(vol, len(self.sld_n)) 
    953955        else: 
    954956            self.vol_pix = None 
    … …  
    993995                for x_pos in self.pos_x: 
    994996                    if xpos_pre != x_pos: 
    995                         self.xstepsize = np.fabs(x_pos - xpos_pre) 
     997                        self.xstepsize = numpy.fabs(x_pos - xpos_pre) 
    996998                        break 
    997999                for y_pos in self.pos_y: 
    9981000                    if ypos_pre != y_pos: 
    999                         self.ystepsize = np.fabs(y_pos - ypos_pre) 
     1001                        self.ystepsize = numpy.fabs(y_pos - ypos_pre) 
    10001002                        break 
    10011003                for z_pos in self.pos_z: 
    10021004                    if zpos_pre != z_pos: 
    1003                         self.zstepsize = np.fabs(z_pos - zpos_pre) 
     1005                        self.zstepsize = numpy.fabs(z_pos - zpos_pre) 
    10041006                        break 
    10051007                #default pix volume 
    1006                 self.vol_pix = np.ones(len(self.pos_x)) 
     1008                self.vol_pix = numpy.ones(len(self.pos_x)) 
    10071009                vol = self.xstepsize * self.ystepsize * self.zstepsize 
    10081010                self.set_pixel_volumes(vol) 
    … …  
    10711073    y2 = output.pos_y+output.sld_my/max_m * gap 
    10721074    z2 = output.pos_z+output.sld_mz/max_m * gap 
    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)) 
     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)) 
    10761078    unit_x2 = output.sld_mx / max_m 
    10771079    unit_y2 = output.sld_my / max_m 
    10781080    unit_z2 = output.sld_mz / max_m 
    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)) 
     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)) 
    10831085    plt.show() 
    10841086 
    … …  
    11031105    model = GenSAS() 
    11041106    model.set_sld_data(foutput.output) 
    1105     x = np.arange(1000)/10000. + 1e-5 
    1106     y = np.arange(1000)/10000. + 1e-5 
    1107     i = np.zeros(1000) 
     1107    x = numpy.arange(1000)/10000. + 1e-5 
     1108    y = numpy.arange(1000)/10000. + 1e-5 
     1109    i = numpy.zeros(1000) 
    11081110    model.runXY([x, y, i]) 
    11091111 
Note: See TracChangeset for help on using the changeset viewer.