Changeset 9a5097c in sasview


Ignore:
Timestamp:
Mar 26, 2017 11:33:16 PM (2 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

Files:
64 edited

Legend:

Unmodified
Added
Removed
  • setup.py

    r1e13b53 r9a5097c  
    99from distutils.command.build_ext import build_ext 
    1010from distutils.core import Command 
    11 import numpy 
     11import numpy as np 
    1212 
    1313# Manage version number ###################################### 
     
    225225ext_modules.append( Extension("sas.sascalc.file_converter.core.bsl_loader", 
    226226                              sources = [os.path.join(mydir, "bsl_loader.c")], 
    227                               include_dirs=[numpy.get_include()], 
     227                              include_dirs=[np.get_include()], 
    228228                              ) ) 
    229229 
  • src/examples/test_chisq_panel.py

    rc10d9d6c r9a5097c  
    3030from sas.sasgui.plottools.plottables import Plottable, Graph, Data1D, Theory1D 
    3131import  sys 
    32 import numpy 
     32import numpy as np 
    3333 
    3434 
     
    7878    # Construct a simple graph 
    7979    if False: 
    80         x = numpy.array([1,2,3,4,5,6],'d') 
    81         y = numpy.array([4,5,26,5,4,-1],'d') 
    82         dy = numpy.array([0.2, 0.3, 0.1, 0.2, 0.9, 0.3]) 
     80        x = np.array([1,2,3,4,5,6],'d') 
     81        y = np.array([4,5,26,5,4,-1],'d') 
     82        dy = np.array([0.2, 0.3, 0.1, 0.2, 0.9, 0.3]) 
    8383    else: 
    84         x = numpy.linspace(0,2.0, 50) 
    85         y = numpy.sin(2*numpy.pi*x*2.8) 
    86         dy = numpy.sqrt(100*numpy.abs(y))/100 
     84        x = np.linspace(0,2.0, 50) 
     85        y = np.sin(2*np.pi*x*2.8) 
     86        dy = np.sqrt(100*np.abs(y))/100 
    8787 
    8888    from sas.sasgui.plottools.plottables import Data1D, Theory1D, Chisq , Graph 
  • src/examples/test_copy_print.py

    rd7bb526 r9a5097c  
    3030import  sys 
    3131sys.platform = 'win95' 
    32 import numpy 
     32import numpy as np 
    3333 
    3434 
     
    8181def sample_graph(): 
    8282    # Construct a simple graph 
    83     x = numpy.linspace(0,2.0, 50) 
    84     y = numpy.sin(2*numpy.pi*x*2.8) 
    85     dy = numpy.sqrt(100*numpy.abs(y))/100 
     83    x = np.linspace(0,2.0, 50) 
     84    y = np.sin(2*np.pi*x*2.8) 
     85    dy = np.sqrt(100*np.abs(y))/100 
    8686     
    8787    data = Data1D(x,y,dy=dy) 
  • src/examples/test_panel.py

    rd7bb526 r9a5097c  
    3939from sas.sasgui.plottools.PlotPanel import PlotPanel 
    4040from sas.sasgui.plottools.plottables import Data1D 
    41 import  sys 
    42 import numpy 
     41import sys 
     42import numpy as np 
    4343import random, math 
    4444 
     
    157157    def _add_data(self, event): 
    158158        data_len = 50 
    159         x  = numpy.zeros(data_len) 
    160         y  = numpy.zeros(data_len) 
    161         x2  = numpy.zeros(data_len) 
    162         y2  = numpy.zeros(data_len) 
    163         dy2  = numpy.zeros(data_len) 
    164         x3  = numpy.zeros(data_len) 
    165         y3  = numpy.zeros(data_len) 
    166         dy3  = numpy.zeros(data_len) 
     159        x  = np.zeros(data_len) 
     160        y  = np.zeros(data_len) 
     161        x2  = np.zeros(data_len) 
     162        y2  = np.zeros(data_len) 
     163        dy2  = np.zeros(data_len) 
     164        x3  = np.zeros(data_len) 
     165        y3  = np.zeros(data_len) 
     166        dy3  = np.zeros(data_len) 
    167167        for i in range(len(x)): 
    168168            x[i] = i 
  • src/examples/test_panel2D.py

    rd7bb526 r9a5097c  
    4040from sas.sasgui.plottools.plottables import Data1D, Theory1D, Data2D 
    4141import  sys,os 
    42 import numpy 
     42import numpy as np 
    4343import random, math 
    4444 
     
    226226    def _add_data(self, event): 
    227227        data_len = 50 
    228         x  = numpy.zeros(data_len) 
    229         y  = numpy.zeros(data_len) 
    230         x2  = numpy.zeros(data_len) 
    231         y2  = numpy.zeros(data_len) 
    232         dy2  = numpy.zeros(data_len) 
    233         x3  = numpy.zeros(data_len) 
    234         y3  = numpy.zeros(data_len) 
    235         dy3  = numpy.zeros(data_len) 
     228        x  = np.zeros(data_len) 
     229        y  = np.zeros(data_len) 
     230        x2  = np.zeros(data_len) 
     231        y2  = np.zeros(data_len) 
     232        dy2  = np.zeros(data_len) 
     233        x3  = np.zeros(data_len) 
     234        y3  = np.zeros(data_len) 
     235        dy3  = np.zeros(data_len) 
    236236        for i in range(len(x)): 
    237237            x[i] = i 
  • 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

    rb699768 r9a5097c  
    1212from math import sqrt 
    1313import math 
    14 import numpy 
     14import numpy as np 
    1515import sys 
    1616import logging 
     
    393393        dx_size = (self.qx_max - self.qx_min) / (1000 - 1) 
    394394        dy_size = (self.qy_max - self.qy_min) / (1000 - 1) 
    395         x_val = numpy.arange(self.qx_min, self.qx_max, dx_size) 
    396         y_val = numpy.arange(self.qy_max, self.qy_min, -dy_size) 
    397         q_1, q_2 = numpy.meshgrid(x_val, y_val) 
     395        x_val = np.arange(self.qx_min, self.qx_max, dx_size) 
     396        y_val = np.arange(self.qy_max, self.qy_min, -dy_size) 
     397        q_1, q_2 = np.meshgrid(x_val, y_val) 
    398398        #q_phi = numpy.arctan(q_1,q_2) 
    399399        # check whether polar or cartesian 
     
    887887        x_value = x_val - x0_val 
    888888        y_value = y_val - y0_val 
    889         phi_i = numpy.arctan2(y_val, x_val) 
     889        phi_i = np.arctan2(y_val, x_val) 
    890890 
    891891        # phi correction due to the gravity shift (in phi) 
     
    893893        phi_i = phi_i - phi_0 + self.gravity_phi 
    894894 
    895         sin_phi = numpy.sin(self.gravity_phi) 
    896         cos_phi = numpy.cos(self.gravity_phi) 
     895        sin_phi = np.sin(self.gravity_phi) 
     896        cos_phi = np.cos(self.gravity_phi) 
    897897 
    898898        x_p = x_value * cos_phi + y_value * sin_phi 
     
    908908        nu_value = -0.5 * (new_x * new_x + new_y * new_y) 
    909909 
    910         gaussian = numpy.exp(nu_value) 
     910        gaussian = np.exp(nu_value) 
    911911        # normalizing factor correction 
    912912        gaussian /= gaussian.sum() 
     
    954954            nu_value *= nu_value 
    955955            nu_value *= -0.5 
    956             gaussian *= numpy.exp(nu_value) 
     956            gaussian *= np.exp(nu_value) 
    957957            gaussian /= sigma 
    958958            # normalize 
     
    10261026                                                           offset_x, offset_y) 
    10271027        # distance [cm] from the beam center on detector plane 
    1028         detector_ind_x = numpy.arange(detector_pix_nums_x) 
    1029         detector_ind_y = numpy.arange(detector_pix_nums_y) 
     1028        detector_ind_x = np.arange(detector_pix_nums_x) 
     1029        detector_ind_y = np.arange(detector_pix_nums_y) 
    10301030 
    10311031        # shif 0.5 pixel so that pix position is at the center of the pixel 
     
    10411041        detector_ind_y = detector_ind_y * pix_y_size 
    10421042 
    1043         qx_value = numpy.zeros(len(detector_ind_x)) 
    1044         qy_value = numpy.zeros(len(detector_ind_y)) 
     1043        qx_value = np.zeros(len(detector_ind_x)) 
     1044        qy_value = np.zeros(len(detector_ind_y)) 
    10451045        i = 0 
    10461046 
     
    10611061 
    10621062        # p min and max values among the center of pixels 
    1063         self.qx_min = numpy.min(qx_value) 
    1064         self.qx_max = numpy.max(qx_value) 
    1065         self.qy_min = numpy.min(qy_value) 
    1066         self.qy_max = numpy.max(qy_value) 
     1063        self.qx_min = np.min(qx_value) 
     1064        self.qx_max = np.max(qx_value) 
     1065        self.qy_min = np.min(qy_value) 
     1066        self.qy_max = np.max(qy_value) 
    10671067 
    10681068        # Appr. min and max values of the detector display limits 
     
    10881088            from sas.sascalc.dataloader.data_info import Data2D 
    10891089            output = Data2D() 
    1090             inten = numpy.zeros_like(qx_value) 
     1090            inten = np.zeros_like(qx_value) 
    10911091            output.data = inten 
    10921092            output.qx_data = qx_value 
     
    11071107        plane_dist = dx_size 
    11081108        # full scattering angle on the x-axis 
    1109         theta = numpy.arctan(plane_dist / det_dist) 
    1110         qx_value = (2.0 * pi / wavelength) * numpy.sin(theta) 
     1109        theta = np.arctan(plane_dist / det_dist) 
     1110        qx_value = (2.0 * pi / wavelength) * np.sin(theta) 
    11111111        return qx_value 
    11121112 
  • 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 
  • src/sas/sascalc/data_util/err1d.py

    rb699768 r9a5097c  
    88""" 
    99from __future__ import division  # Get true division 
    10 import numpy 
     10import numpy as np 
    1111 
    1212 
     
    5959def exp(X, varX): 
    6060    """Exponentiation with error propagation""" 
    61     Z = numpy.exp(X) 
     61    Z = np.exp(X) 
    6262    varZ = varX * Z**2 
    6363    return Z, varZ 
     
    6666def log(X, varX): 
    6767    """Logarithm with error propagation""" 
    68     Z = numpy.log(X) 
     68    Z = np.log(X) 
    6969    varZ = varX / X**2 
    7070    return Z, varZ 
     
    7373# def pow(X,varX, Y,varY): 
    7474#    Z = X**Y 
    75 #    varZ = (Y**2 * varX/X**2 + varY * numpy.log(X)**2) * Z**2 
     75#    varZ = (Y**2 * varX/X**2 + varY * np.log(X)**2) * Z**2 
    7676#    return Z,varZ 
    7777# 
  • src/sas/sascalc/data_util/formatnum.py

    rb699768 r9a5097c  
    4040 
    4141import math 
    42 import numpy 
     42import numpy as np 
    4343__all__ = ['format_uncertainty', 'format_uncertainty_pm', 
    4444           'format_uncertainty_compact'] 
     
    102102    """ 
    103103    # Handle indefinite value 
    104     if numpy.isinf(value): 
     104    if np.isinf(value): 
    105105        return "inf" if value > 0 else "-inf" 
    106     if numpy.isnan(value): 
     106    if np.isnan(value): 
    107107        return "NaN" 
    108108 
    109109    # Handle indefinite uncertainty 
    110     if uncertainty is None or uncertainty <= 0 or numpy.isnan(uncertainty): 
     110    if uncertainty is None or uncertainty <= 0 or np.isnan(uncertainty): 
    111111        return "%g" % value 
    112     if numpy.isinf(uncertainty): 
     112    if np.isinf(uncertainty): 
    113113        if compact: 
    114114            return "%.2g(inf)" % value 
     
    279279 
    280280    # non-finite values 
    281     assert value_str(-numpy.inf,None) == "-inf" 
    282     assert value_str(numpy.inf,None) == "inf" 
    283     assert value_str(numpy.NaN,None) == "NaN" 
     281    assert value_str(-np.inf,None) == "-inf" 
     282    assert value_str(np.inf,None) == "inf" 
     283    assert value_str(np.NaN,None) == "NaN" 
    284284     
    285285    # bad or missing uncertainty 
    286     assert value_str(-1.23567,numpy.NaN) == "-1.23567" 
    287     assert value_str(-1.23567,-numpy.inf) == "-1.23567" 
     286    assert value_str(-1.23567,np.NaN) == "-1.23567" 
     287    assert value_str(-1.23567,-np.inf) == "-1.23567" 
    288288    assert value_str(-1.23567,-0.1) == "-1.23567" 
    289289    assert value_str(-1.23567,0) == "-1.23567" 
    290290    assert value_str(-1.23567,None) == "-1.23567" 
    291     assert value_str(-1.23567,numpy.inf) == "-1.2(inf)" 
     291    assert value_str(-1.23567,np.inf) == "-1.2(inf)" 
    292292 
    293293def test_pm(): 
     
    410410 
    411411    # non-finite values 
    412     assert value_str(-numpy.inf,None) == "-inf" 
    413     assert value_str(numpy.inf,None) == "inf" 
    414     assert value_str(numpy.NaN,None) == "NaN" 
     412    assert value_str(-np.inf,None) == "-inf" 
     413    assert value_str(np.inf,None) == "inf" 
     414    assert value_str(np.NaN,None) == "NaN" 
    415415     
    416416    # bad or missing uncertainty 
    417     assert value_str(-1.23567,numpy.NaN) == "-1.23567" 
    418     assert value_str(-1.23567,-numpy.inf) == "-1.23567" 
     417    assert value_str(-1.23567,np.NaN) == "-1.23567" 
     418    assert value_str(-1.23567,-np.inf) == "-1.23567" 
    419419    assert value_str(-1.23567,-0.1) == "-1.23567" 
    420420    assert value_str(-1.23567,0) == "-1.23567" 
    421421    assert value_str(-1.23567,None) == "-1.23567" 
    422     assert value_str(-1.23567,numpy.inf) == "-1.2 +/- inf" 
     422    assert value_str(-1.23567,np.inf) == "-1.2 +/- inf" 
    423423 
    424424def test_default(): 
  • src/sas/sascalc/data_util/qsmearing.py

    r775e0b7 r9a5097c  
    99#copyright 2008, University of Tennessee 
    1010###################################################################### 
    11 import numpy 
    1211import math 
    1312import logging 
     
    6059    if data.dx is not None and data.isSesans: 
    6160        #if data.dx[0] > 0.0: 
    62         if numpy.size(data.dx[data.dx <= 0]) == 0: 
     61        if np.size(data.dx[data.dx <= 0]) == 0: 
    6362            _found_sesans = True 
    6463        # if data.dx[0] <= 0.0: 
    65         if numpy.size(data.dx[data.dx <= 0]) > 0: 
     64        if np.size(data.dx[data.dx <= 0]) > 0: 
    6665            raise ValueError('one or more of your dx values are negative, please check the data file!') 
    6766 
     
    121120        self.resolution = resolution 
    122121        if offset is None: 
    123             offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
     122            offset = np.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
    124123        self.offset = offset 
    125124 
     
    137136        start, end = first_bin + self.offset, last_bin + self.offset 
    138137        q_calc = self.resolution.q_calc 
    139         iq_calc = numpy.empty_like(q_calc) 
     138        iq_calc = np.empty_like(q_calc) 
    140139        if start > 0: 
    141140            iq_calc[:start] = self.model.evalDistribution(q_calc[:start]) 
     
    157156        """ 
    158157        q = self.resolution.q 
    159         first = numpy.searchsorted(q, q_min) 
    160         last = numpy.searchsorted(q, q_max) 
     158        first = np.searchsorted(q, q_min) 
     159        last = np.searchsorted(q, q_max) 
    161160        return first, min(last,len(q)-1) 
    162161 
  • src/sas/sascalc/data_util/uncertainty.py

    rb699768 r9a5097c  
    1717from __future__ import division 
    1818 
    19 import numpy 
     19import numpy as np 
    2020import err1d 
    2121from formatnum import format_uncertainty 
     
    2727class Uncertainty(object): 
    2828    # Make standard deviation available 
    29     def _getdx(self): return numpy.sqrt(self.variance) 
     29    def _getdx(self): return np.sqrt(self.variance) 
    3030    def _setdx(self,dx):  
    3131        # Direct operation 
     
    144144        return self 
    145145    def __abs__(self): 
    146         return Uncertainty(numpy.abs(self.x),self.variance) 
     146        return Uncertainty(np.abs(self.x),self.variance) 
    147147 
    148148    def __str__(self): 
    149         #return str(self.x)+" +/- "+str(numpy.sqrt(self.variance)) 
    150         if numpy.isscalar(self.x): 
    151             return format_uncertainty(self.x,numpy.sqrt(self.variance)) 
     149        #return str(self.x)+" +/- "+str(np.sqrt(self.variance)) 
     150        if np.isscalar(self.x): 
     151            return format_uncertainty(self.x,np.sqrt(self.variance)) 
    152152        else: 
    153153            return [format_uncertainty(v,dv)  
    154                     for v,dv in zip(self.x,numpy.sqrt(self.variance))] 
     154                    for v,dv in zip(self.x,np.sqrt(self.variance))] 
    155155    def __repr__(self): 
    156156        return "Uncertainty(%s,%s)"%(str(self.x),str(self.variance)) 
     
    287287    # =============== vector operations ================ 
    288288    # Slicing 
    289     z = Uncertainty(numpy.array([1,2,3,4,5]),numpy.array([2,1,2,3,2])) 
     289    z = Uncertainty(np.array([1,2,3,4,5]),np.array([2,1,2,3,2])) 
    290290    assert z[2].x == 3 and z[2].variance == 2 
    291291    assert (z[2:4].x == [3,4]).all() 
    292292    assert (z[2:4].variance == [2,3]).all() 
    293     z[2:4] = Uncertainty(numpy.array([8,7]),numpy.array([4,5])) 
     293    z[2:4] = Uncertainty(np.array([8,7]),np.array([4,5])) 
    294294    assert z[2].x == 8 and z[2].variance == 4 
    295     A = Uncertainty(numpy.array([a.x]*2),numpy.array([a.variance]*2)) 
    296     B = Uncertainty(numpy.array([b.x]*2),numpy.array([b.variance]*2)) 
     295    A = Uncertainty(np.array([a.x]*2),np.array([a.variance]*2)) 
     296    B = Uncertainty(np.array([b.x]*2),np.array([b.variance]*2)) 
    297297 
    298298    # TODO complete tests of copy and inplace operations for vectors and slices. 
  • src/sas/sascalc/dataloader/data_info.py

    r2ffe241 r9a5097c  
    2323#from sas.guitools.plottables import Data1D as plottable_1D 
    2424from sas.sascalc.data_util.uncertainty import Uncertainty 
    25 import numpy 
     25import numpy as np 
    2626import math 
    2727 
     
    5151 
    5252    def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None, lam=None, dlam=None): 
    53         self.x = numpy.asarray(x) 
    54         self.y = numpy.asarray(y) 
     53        self.x = np.asarray(x) 
     54        self.y = np.asarray(y) 
    5555        if dx is not None: 
    56             self.dx = numpy.asarray(dx) 
     56            self.dx = np.asarray(dx) 
    5757        if dy is not None: 
    58             self.dy = numpy.asarray(dy) 
     58            self.dy = np.asarray(dy) 
    5959        if dxl is not None: 
    60             self.dxl = numpy.asarray(dxl) 
     60            self.dxl = np.asarray(dxl) 
    6161        if dxw is not None: 
    62             self.dxw = numpy.asarray(dxw) 
     62            self.dxw = np.asarray(dxw) 
    6363        if lam is not None: 
    64             self.lam = numpy.asarray(lam) 
     64            self.lam = np.asarray(lam) 
    6565        if dlam is not None: 
    66             self.dlam = numpy.asarray(dlam) 
     66            self.dlam = np.asarray(dlam) 
    6767 
    6868    def xaxis(self, label, unit): 
     
    109109                 qy_data=None, q_data=None, mask=None, 
    110110                 dqx_data=None, dqy_data=None): 
    111         self.data = numpy.asarray(data) 
    112         self.qx_data = numpy.asarray(qx_data) 
    113         self.qy_data = numpy.asarray(qy_data) 
    114         self.q_data = numpy.asarray(q_data) 
    115         self.mask = numpy.asarray(mask) 
    116         self.err_data = numpy.asarray(err_data) 
     111        self.data = np.asarray(data) 
     112        self.qx_data = np.asarray(qx_data) 
     113        self.qy_data = np.asarray(qy_data) 
     114        self.q_data = np.asarray(q_data) 
     115        self.mask = np.asarray(mask) 
     116        self.err_data = np.asarray(err_data) 
    117117        if dqx_data is not None: 
    118             self.dqx_data = numpy.asarray(dqx_data) 
     118            self.dqx_data = np.asarray(dqx_data) 
    119119        if dqy_data is not None: 
    120             self.dqy_data = numpy.asarray(dqy_data) 
     120            self.dqy_data = np.asarray(dqy_data) 
    121121 
    122122    def xaxis(self, label, unit): 
     
    734734        """ 
    735735        def _check(v): 
    736             if (v.__class__ == list or v.__class__ == numpy.ndarray) \ 
     736            if (v.__class__ == list or v.__class__ == np.ndarray) \ 
    737737                and len(v) > 0 and min(v) > 0: 
    738738                return True 
     
    752752 
    753753        if clone is None or not issubclass(clone.__class__, Data1D): 
    754             x = numpy.zeros(length) 
    755             dx = numpy.zeros(length) 
    756             y = numpy.zeros(length) 
    757             dy = numpy.zeros(length) 
    758             lam = numpy.zeros(length) 
    759             dlam = numpy.zeros(length) 
     754            x = np.zeros(length) 
     755            dx = np.zeros(length) 
     756            y = np.zeros(length) 
     757            dy = np.zeros(length) 
     758            lam = np.zeros(length) 
     759            dlam = np.zeros(length) 
    760760            clone = Data1D(x, y, lam=lam, dx=dx, dy=dy, dlam=dlam) 
    761761 
     
    806806            dy_other = other.dy 
    807807            if other.dy == None or (len(other.dy) != len(other.y)): 
    808                 dy_other = numpy.zeros(len(other.y)) 
     808                dy_other = np.zeros(len(other.y)) 
    809809 
    810810        # Check that we have errors, otherwise create zero vector 
    811811        dy = self.dy 
    812812        if self.dy == None or (len(self.dy) != len(self.y)): 
    813             dy = numpy.zeros(len(self.y)) 
     813            dy = np.zeros(len(self.y)) 
    814814 
    815815        return dy, dy_other 
     
    824824            result.dxw = None 
    825825        else: 
    826             result.dxw = numpy.zeros(len(self.x)) 
     826            result.dxw = np.zeros(len(self.x)) 
    827827        if self.dxl == None: 
    828828            result.dxl = None 
    829829        else: 
    830             result.dxl = numpy.zeros(len(self.x)) 
     830            result.dxl = np.zeros(len(self.x)) 
    831831 
    832832        for i in range(len(self.x)): 
     
    886886            result.dy = None 
    887887        else: 
    888             result.dy = numpy.zeros(len(self.x) + len(other.x)) 
     888            result.dy = np.zeros(len(self.x) + len(other.x)) 
    889889        if self.dx == None or other.dx is None: 
    890890            result.dx = None 
    891891        else: 
    892             result.dx = numpy.zeros(len(self.x) + len(other.x)) 
     892            result.dx = np.zeros(len(self.x) + len(other.x)) 
    893893        if self.dxw == None or other.dxw is None: 
    894894            result.dxw = None 
    895895        else: 
    896             result.dxw = numpy.zeros(len(self.x) + len(other.x)) 
     896            result.dxw = np.zeros(len(self.x) + len(other.x)) 
    897897        if self.dxl == None or other.dxl is None: 
    898898            result.dxl = None 
    899899        else: 
    900             result.dxl = numpy.zeros(len(self.x) + len(other.x)) 
    901  
    902         result.x = numpy.append(self.x, other.x) 
     900            result.dxl = np.zeros(len(self.x) + len(other.x)) 
     901 
     902        result.x = np.append(self.x, other.x) 
    903903        #argsorting 
    904         ind = numpy.argsort(result.x) 
     904        ind = np.argsort(result.x) 
    905905        result.x = result.x[ind] 
    906         result.y = numpy.append(self.y, other.y) 
     906        result.y = np.append(self.y, other.y) 
    907907        result.y = result.y[ind] 
    908908        if result.dy != None: 
    909             result.dy = numpy.append(self.dy, other.dy) 
     909            result.dy = np.append(self.dy, other.dy) 
    910910            result.dy = result.dy[ind] 
    911911        if result.dx is not None: 
    912             result.dx = numpy.append(self.dx, other.dx) 
     912            result.dx = np.append(self.dx, other.dx) 
    913913            result.dx = result.dx[ind] 
    914914        if result.dxw is not None: 
    915             result.dxw = numpy.append(self.dxw, other.dxw) 
     915            result.dxw = np.append(self.dxw, other.dxw) 
    916916            result.dxw = result.dxw[ind] 
    917917        if result.dxl is not None: 
    918             result.dxl = numpy.append(self.dxl, other.dxl) 
     918            result.dxl = np.append(self.dxl, other.dxl) 
    919919            result.dxl = result.dxl[ind] 
    920920        return result 
     
    970970 
    971971        if clone is None or not issubclass(clone.__class__, Data2D): 
    972             data = numpy.zeros(length) 
    973             err_data = numpy.zeros(length) 
    974             qx_data = numpy.zeros(length) 
    975             qy_data = numpy.zeros(length) 
    976             q_data = numpy.zeros(length) 
    977             mask = numpy.zeros(length) 
     972            data = np.zeros(length) 
     973            err_data = np.zeros(length) 
     974            qx_data = np.zeros(length) 
     975            qy_data = np.zeros(length) 
     976            q_data = np.zeros(length) 
     977            mask = np.zeros(length) 
    978978            dqx_data = None 
    979979            dqy_data = None 
     
    10311031            if other.err_data == None or \ 
    10321032                (len(other.err_data) != len(other.data)): 
    1033                 err_other = numpy.zeros(len(other.data)) 
     1033                err_other = np.zeros(len(other.data)) 
    10341034 
    10351035        # Check that we have errors, otherwise create zero vector 
     
    10371037        if self.err_data == None or \ 
    10381038            (len(self.err_data) != len(self.data)): 
    1039             err = numpy.zeros(len(other.data)) 
     1039            err = np.zeros(len(other.data)) 
    10401040        return err, err_other 
    10411041 
     
    10491049        # First, check the data compatibility 
    10501050        dy, dy_other = self._validity_check(other) 
    1051         result = self.clone_without_data(numpy.size(self.data)) 
     1051        result = self.clone_without_data(np.size(self.data)) 
    10521052        if self.dqx_data == None or self.dqy_data == None: 
    10531053            result.dqx_data = None 
    10541054            result.dqy_data = None 
    10551055        else: 
    1056             result.dqx_data = numpy.zeros(len(self.data)) 
    1057             result.dqy_data = numpy.zeros(len(self.data)) 
    1058         for i in range(numpy.size(self.data)): 
     1056            result.dqx_data = np.zeros(len(self.data)) 
     1057            result.dqy_data = np.zeros(len(self.data)) 
     1058        for i in range(np.size(self.data)): 
    10591059            result.data[i] = self.data[i] 
    10601060            if self.err_data is not None and \ 
    1061                 numpy.size(self.data) == numpy.size(self.err_data): 
     1061                            np.size(self.data) == np.size(self.err_data): 
    10621062                result.err_data[i] = self.err_data[i] 
    10631063            if self.dqx_data is not None: 
     
    11181118        # First, check the data compatibility 
    11191119        self._validity_check_union(other) 
    1120         result = self.clone_without_data(numpy.size(self.data) + \ 
    1121                                          numpy.size(other.data)) 
     1120        result = self.clone_without_data(np.size(self.data) + \ 
     1121                                         np.size(other.data)) 
    11221122        result.xmin = self.xmin 
    11231123        result.xmax = self.xmax 
     
    11291129            result.dqy_data = None 
    11301130        else: 
    1131             result.dqx_data = numpy.zeros(len(self.data) + \ 
    1132                                          numpy.size(other.data)) 
    1133             result.dqy_data = numpy.zeros(len(self.data) + \ 
    1134                                          numpy.size(other.data)) 
    1135  
    1136         result.data = numpy.append(self.data, other.data) 
    1137         result.qx_data = numpy.append(self.qx_data, other.qx_data) 
    1138         result.qy_data = numpy.append(self.qy_data, other.qy_data) 
    1139         result.q_data = numpy.append(self.q_data, other.q_data) 
    1140         result.mask = numpy.append(self.mask, other.mask) 
     1131            result.dqx_data = np.zeros(len(self.data) + \ 
     1132                                       np.size(other.data)) 
     1133            result.dqy_data = np.zeros(len(self.data) + \ 
     1134                                       np.size(other.data)) 
     1135 
     1136        result.data = np.append(self.data, other.data) 
     1137        result.qx_data = np.append(self.qx_data, other.qx_data) 
     1138        result.qy_data = np.append(self.qy_data, other.qy_data) 
     1139        result.q_data = np.append(self.q_data, other.q_data) 
     1140        result.mask = np.append(self.mask, other.mask) 
    11411141        if result.err_data is not None: 
    1142             result.err_data = numpy.append(self.err_data, other.err_data) 
     1142            result.err_data = np.append(self.err_data, other.err_data) 
    11431143        if self.dqx_data is not None: 
    1144             result.dqx_data = numpy.append(self.dqx_data, other.dqx_data) 
     1144            result.dqx_data = np.append(self.dqx_data, other.dqx_data) 
    11451145        if self.dqy_data is not None: 
    1146             result.dqy_data = numpy.append(self.dqy_data, other.dqy_data) 
     1146            result.dqy_data = np.append(self.dqy_data, other.dqy_data) 
    11471147 
    11481148        return result 
  • src/sas/sascalc/dataloader/manipulations.py

    rb2b36932 r9a5097c  
    1414#TODO: copy the meta data from the 2D object to the resulting 1D object 
    1515import math 
    16 import numpy 
     16import numpy as np 
    1717 
    1818#from data_info import plottable_2D 
     
    8282    if data2d.data == None or data2d.x_bins == None or data2d.y_bins == None: 
    8383        raise ValueError, "Can't convert this data: data=None..." 
    84     new_x = numpy.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
    85     new_y = numpy.tile(data2d.y_bins, (len(data2d.x_bins), 1)) 
     84    new_x = np.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
     85    new_y = np.tile(data2d.y_bins, (len(data2d.x_bins), 1)) 
    8686    new_y = new_y.swapaxes(0, 1) 
    8787 
     
    8989    qx_data = new_x.flatten() 
    9090    qy_data = new_y.flatten() 
    91     q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
    92     if data2d.err_data == None or numpy.any(data2d.err_data <= 0): 
    93         new_err_data = numpy.sqrt(numpy.abs(new_data)) 
     91    q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
     92    if data2d.err_data == None or np.any(data2d.err_data <= 0): 
     93        new_err_data = np.sqrt(np.abs(new_data)) 
    9494    else: 
    9595        new_err_data = data2d.err_data.flatten() 
    96     mask = numpy.ones(len(new_data), dtype=bool) 
     96    mask = np.ones(len(new_data), dtype=bool) 
    9797 
    9898    #TODO: make sense of the following two lines... 
     
    149149 
    150150        # Get data 
    151         data = data2D.data[numpy.isfinite(data2D.data)] 
    152         err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
    153         qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
    154         qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
     151        data = data2D.data[np.isfinite(data2D.data)] 
     152        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     153        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     154        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    155155 
    156156        # Build array of Q intervals 
     
    170170            raise RuntimeError, "_Slab._avg: unrecognized axis %s" % str(maj) 
    171171 
    172         x = numpy.zeros(nbins) 
    173         y = numpy.zeros(nbins) 
    174         err_y = numpy.zeros(nbins) 
    175         y_counts = numpy.zeros(nbins) 
     172        x = np.zeros(nbins) 
     173        y = np.zeros(nbins) 
     174        err_y = np.zeros(nbins) 
     175        y_counts = np.zeros(nbins) 
    176176 
    177177        # Average pixelsize in q space 
     
    225225        y = y / y_counts 
    226226        x = x / y_counts 
    227         idx = (numpy.isfinite(y) & numpy.isfinite(x)) 
     227        idx = (np.isfinite(y) & np.isfinite(x)) 
    228228 
    229229        if not idx.any(): 
     
    304304            raise RuntimeError, msg 
    305305        # Get data 
    306         data = data2D.data[numpy.isfinite(data2D.data)] 
    307         err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
    308         qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
    309         qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
     306        data = data2D.data[np.isfinite(data2D.data)] 
     307        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     308        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     309        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    310310 
    311311        y = 0.0 
     
    414414        """ 
    415415        # Get data W/ finite values 
    416         data = data2D.data[numpy.isfinite(data2D.data)] 
    417         q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
    418         err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
    419         mask_data = data2D.mask[numpy.isfinite(data2D.data)] 
     416        data = data2D.data[np.isfinite(data2D.data)] 
     417        q_data = data2D.q_data[np.isfinite(data2D.data)] 
     418        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     419        mask_data = data2D.mask[np.isfinite(data2D.data)] 
    420420 
    421421        dq_data = None 
     
    448448            dq_overlap_y *= dq_overlap_y 
    449449 
    450             dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
     450            dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
    451451            # Final protection of dq 
    452452            if dq_overlap < 0: 
    453453                dq_overlap = y_min 
    454             dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)] 
    455             dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap 
     454            dqx_data = data2D.dqx_data[np.isfinite(data2D.data)] 
     455            dqy_data = data2D.dqy_data[np.isfinite(data2D.data)] - dq_overlap 
    456456            # def; dqx_data = dq_r dqy_data = dq_phi 
    457457            # Convert dq 2D to 1D here 
    458458            dqx = dqx_data * dqx_data 
    459459            dqy = dqy_data * dqy_data 
    460             dq_data = numpy.add(dqx, dqy) 
    461             dq_data = numpy.sqrt(dq_data) 
    462  
    463         #q_data_max = numpy.max(q_data) 
     460            dq_data = np.add(dqx, dqy) 
     461            dq_data = np.sqrt(dq_data) 
     462 
     463        #q_data_max = np.max(q_data) 
    464464        if len(data2D.q_data) == None: 
    465465            msg = "Circular averaging: invalid q_data: %g" % data2D.q_data 
     
    469469        nbins = int(math.ceil((self.r_max - self.r_min) / self.bin_width)) 
    470470 
    471         x = numpy.zeros(nbins) 
    472         y = numpy.zeros(nbins) 
    473         err_y = numpy.zeros(nbins) 
    474         err_x = numpy.zeros(nbins) 
    475         y_counts = numpy.zeros(nbins) 
     471        x = np.zeros(nbins) 
     472        y = np.zeros(nbins) 
     473        err_y = np.zeros(nbins) 
     474        err_x = np.zeros(nbins) 
     475        y_counts = np.zeros(nbins) 
    476476 
    477477        for npt in range(len(data)): 
     
    527527 
    528528        err_y = err_y / y_counts 
    529         err_y[err_y == 0] = numpy.average(err_y) 
     529        err_y[err_y == 0] = np.average(err_y) 
    530530        y = y / y_counts 
    531531        x = x / y_counts 
    532         idx = (numpy.isfinite(y)) & (numpy.isfinite(x)) 
     532        idx = (np.isfinite(y)) & (np.isfinite(x)) 
    533533 
    534534        if err_x != None: 
     
    585585 
    586586        # Get data 
    587         data = data2D.data[numpy.isfinite(data2D.data)] 
    588         q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
    589         err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
    590         qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
    591         qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
     587        data = data2D.data[np.isfinite(data2D.data)] 
     588        q_data = data2D.q_data[np.isfinite(data2D.data)] 
     589        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     590        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     591        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    592592 
    593593        # Set space for 1d outputs 
    594         phi_bins = numpy.zeros(self.nbins_phi) 
    595         phi_counts = numpy.zeros(self.nbins_phi) 
    596         phi_values = numpy.zeros(self.nbins_phi) 
    597         phi_err = numpy.zeros(self.nbins_phi) 
     594        phi_bins = np.zeros(self.nbins_phi) 
     595        phi_counts = np.zeros(self.nbins_phi) 
     596        phi_values = np.zeros(self.nbins_phi) 
     597        phi_err = np.zeros(self.nbins_phi) 
    598598 
    599599        # Shift to apply to calculated phi values in order 
     
    636636            phi_values[i] = 2.0 * math.pi / self.nbins_phi * (1.0 * i) 
    637637 
    638         idx = (numpy.isfinite(phi_bins)) 
     638        idx = (np.isfinite(phi_bins)) 
    639639 
    640640        if not idx.any(): 
     
    769769 
    770770        # Get the all data & info 
    771         data = data2D.data[numpy.isfinite(data2D.data)] 
    772         q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
    773         err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
    774         qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
    775         qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
     771        data = data2D.data[np.isfinite(data2D.data)] 
     772        q_data = data2D.q_data[np.isfinite(data2D.data)] 
     773        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     774        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     775        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    776776        dq_data = None 
    777777 
     
    803803            dq_overlap_y *= dq_overlap_y 
    804804 
    805             dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
     805            dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
    806806            if dq_overlap < 0: 
    807807                dq_overlap = y_min 
    808             dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)] 
    809             dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap 
     808            dqx_data = data2D.dqx_data[np.isfinite(data2D.data)] 
     809            dqy_data = data2D.dqy_data[np.isfinite(data2D.data)] - dq_overlap 
    810810            # def; dqx_data = dq_r dqy_data = dq_phi 
    811811            # Convert dq 2D to 1D here 
    812812            dqx = dqx_data * dqx_data 
    813813            dqy = dqy_data * dqy_data 
    814             dq_data = numpy.add(dqx, dqy) 
    815             dq_data = numpy.sqrt(dq_data) 
     814            dq_data = np.add(dqx, dqy) 
     815            dq_data = np.sqrt(dq_data) 
    816816 
    817817        #set space for 1d outputs 
    818         x = numpy.zeros(self.nbins) 
    819         y = numpy.zeros(self.nbins) 
    820         y_err = numpy.zeros(self.nbins) 
    821         x_err = numpy.zeros(self.nbins) 
    822         y_counts = numpy.zeros(self.nbins) 
     818        x = np.zeros(self.nbins) 
     819        y = np.zeros(self.nbins) 
     820        y_err = np.zeros(self.nbins) 
     821        x_err = np.zeros(self.nbins) 
     822        y_counts = np.zeros(self.nbins) 
    823823 
    824824        # Get the min and max into the region: 0 <= phi < 2Pi 
     
    923923                #x[i] = math.sqrt((r_inner * r_inner + r_outer * r_outer) / 2) 
    924924                x[i] = x[i] / y_counts[i] 
    925         y_err[y_err == 0] = numpy.average(y_err) 
    926         idx = (numpy.isfinite(y) & numpy.isfinite(y_err)) 
     925        y_err[y_err == 0] = np.average(y_err) 
     926        idx = (np.isfinite(y) & np.isfinite(y_err)) 
    927927        if x_err != None: 
    928928            d_x = x_err[idx] / y_counts[idx] 
     
    10121012        qx_data = data2D.qx_data 
    10131013        qy_data = data2D.qy_data 
    1014         q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     1014        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    10151015 
    10161016        # check whether or not the data point is inside ROI 
     
    11131113 
    11141114        # get phi from data 
    1115         phi_data = numpy.arctan2(qy_data, qx_data) 
     1115        phi_data = np.arctan2(qy_data, qx_data) 
    11161116 
    11171117        # Get the min and max into the region: -pi <= phi < Pi 
  • src/sas/sascalc/dataloader/readers/IgorReader.py

    rb699768 r9a5097c  
    1313############################################################################# 
    1414import os 
    15 import numpy 
     15import numpy as np 
    1616import math 
    1717#import logging 
     
    118118        size_x = i_tot_row  # 192#128 
    119119        size_y = i_tot_row  # 192#128 
    120         output.data = numpy.zeros([size_x, size_y]) 
    121         output.err_data = numpy.zeros([size_x, size_y]) 
     120        output.data = np.zeros([size_x, size_y]) 
     121        output.err_data = np.zeros([size_x, size_y]) 
    122122      
    123123        #Read Header and 2D data 
  • src/sas/sascalc/dataloader/readers/abs_reader.py

    rb699768 r9a5097c  
    99###################################################################### 
    1010 
    11 import numpy 
     11import numpy as np 
    1212import os 
    1313from sas.sascalc.dataloader.data_info import Data1D 
     
    5353                buff = input_f.read() 
    5454                lines = buff.split('\n') 
    55                 x  = numpy.zeros(0) 
    56                 y  = numpy.zeros(0) 
    57                 dy = numpy.zeros(0) 
    58                 dx = numpy.zeros(0) 
     55                x  = np.zeros(0) 
     56                y  = np.zeros(0) 
     57                dy = np.zeros(0) 
     58                dx = np.zeros(0) 
    5959                output = Data1D(x, y, dy=dy, dx=dx) 
    6060                detector = Detector() 
     
    204204                                _dy = data_conv_i(_dy, units=output.y_unit) 
    205205                            
    206                             x = numpy.append(x, _x) 
    207                             y = numpy.append(y, _y) 
    208                             dy = numpy.append(dy, _dy) 
    209                             dx = numpy.append(dx, _dx) 
     206                            x = np.append(x, _x) 
     207                            y = np.append(y, _y) 
     208                            dy = np.append(dy, _dy) 
     209                            dx = np.append(dx, _dx) 
    210210                             
    211211                        except: 
  • src/sas/sascalc/dataloader/readers/ascii_reader.py

    rd2471870 r9a5097c  
    1414 
    1515 
    16 import numpy 
     16import numpy as np 
    1717import os 
    1818from sas.sascalc.dataloader.data_info import Data1D 
     
    6969 
    7070                # Arrays for data storage 
    71                 tx = numpy.zeros(0) 
    72                 ty = numpy.zeros(0) 
    73                 tdy = numpy.zeros(0) 
    74                 tdx = numpy.zeros(0) 
     71                tx = np.zeros(0) 
     72                ty = np.zeros(0) 
     73                tdy = np.zeros(0) 
     74                tdx = np.zeros(0) 
    7575 
    7676                # The first good line of data will define whether 
     
    140140                            is_data == False: 
    141141                            try: 
    142                                 tx = numpy.zeros(0) 
    143                                 ty = numpy.zeros(0) 
    144                                 tdy = numpy.zeros(0) 
    145                                 tdx = numpy.zeros(0) 
     142                                tx = np.zeros(0) 
     143                                ty = np.zeros(0) 
     144                                tdy = np.zeros(0) 
     145                                tdx = np.zeros(0) 
    146146                            except: 
    147147                                pass 
    148148 
    149149                        if has_error_dy == True: 
    150                             tdy = numpy.append(tdy, _dy) 
     150                            tdy = np.append(tdy, _dy) 
    151151                        if has_error_dx == True: 
    152                             tdx = numpy.append(tdx, _dx) 
    153                         tx = numpy.append(tx, _x) 
    154                         ty = numpy.append(ty, _y) 
     152                            tdx = np.append(tdx, _dx) 
     153                        tx = np.append(tx, _x) 
     154                        ty = np.append(ty, _y) 
    155155 
    156156                        #To remember the # of columns on the current line 
     
    188188                #Let's re-order the data to make cal. 
    189189                # curve look better some cases 
    190                 ind = numpy.lexsort((ty, tx)) 
    191                 x = numpy.zeros(len(tx)) 
    192                 y = numpy.zeros(len(ty)) 
    193                 dy = numpy.zeros(len(tdy)) 
    194                 dx = numpy.zeros(len(tdx)) 
     190                ind = np.lexsort((ty, tx)) 
     191                x = np.zeros(len(tx)) 
     192                y = np.zeros(len(ty)) 
     193                dy = np.zeros(len(tdy)) 
     194                dx = np.zeros(len(tdx)) 
    195195                output = Data1D(x, y, dy=dy, dx=dx) 
    196196                self.filename = output.filename = basename 
     
    212212                output.y = y[x != 0] 
    213213                output.dy = dy[x != 0] if has_error_dy == True\ 
    214                     else numpy.zeros(len(output.y)) 
     214                    else np.zeros(len(output.y)) 
    215215                output.dx = dx[x != 0] if has_error_dx == True\ 
    216                     else numpy.zeros(len(output.x)) 
     216                    else np.zeros(len(output.x)) 
    217217 
    218218                output.xaxis("\\rm{Q}", 'A^{-1}') 
  • src/sas/sascalc/dataloader/readers/danse_reader.py

    rb699768 r9a5097c  
    1515import os 
    1616import sys 
    17 import numpy 
     17import numpy as np 
    1818import logging 
    1919from sas.sascalc.dataloader.data_info import Data2D, Detector 
     
    7979            output.detector.append(detector) 
    8080             
    81             output.data = numpy.zeros([size_x,size_y]) 
    82             output.err_data = numpy.zeros([size_x, size_y]) 
     81            output.data = np.zeros([size_x,size_y]) 
     82            output.err_data = np.zeros([size_x, size_y]) 
    8383             
    8484            data_conv_q = None 
  • src/sas/sascalc/dataloader/readers/hfir1d_reader.py

    rb699768 r9a5097c  
    99#copyright 2008, University of Tennessee 
    1010###################################################################### 
    11 import numpy 
     11import numpy as np 
    1212import os 
    1313from sas.sascalc.dataloader.data_info import Data1D 
     
    5252                buff = input_f.read() 
    5353                lines = buff.split('\n') 
    54                 x = numpy.zeros(0) 
    55                 y = numpy.zeros(0) 
    56                 dx = numpy.zeros(0) 
    57                 dy = numpy.zeros(0) 
     54                x = np.zeros(0) 
     55                y = np.zeros(0) 
     56                dx = np.zeros(0) 
     57                dy = np.zeros(0) 
    5858                output = Data1D(x, y, dx=dx, dy=dy) 
    5959                self.filename = output.filename = basename 
     
    8888                            _dy = data_conv_i(_dy, units=output.y_unit) 
    8989                                                     
    90                         x = numpy.append(x, _x) 
    91                         y = numpy.append(y, _y) 
    92                         dx = numpy.append(dx, _dx) 
    93                         dy = numpy.append(dy, _dy) 
     90                        x = np.append(x, _x) 
     91                        y = np.append(y, _y) 
     92                        dx = np.append(dx, _dx) 
     93                        dy = np.append(dy, _dy) 
    9494                    except: 
    9595                        # Couldn't parse this line, skip it  
  • src/sas/sascalc/dataloader/readers/red2d_reader.py

    rb699768 r9a5097c  
    1010###################################################################### 
    1111import os 
    12 import numpy 
     12import numpy as np 
    1313import math 
    1414from sas.sascalc.dataloader.data_info import Data2D, Detector 
     
    198198                break 
    199199        # Make numpy array to remove header lines using index 
    200         lines_array = numpy.array(lines) 
     200        lines_array = np.array(lines) 
    201201 
    202202        # index for lines_array 
    203         lines_index = numpy.arange(len(lines)) 
     203        lines_index = np.arange(len(lines)) 
    204204         
    205205        # get the data lines 
     
    225225 
    226226        # numpy array form 
    227         data_array = numpy.array(data_list1) 
     227        data_array = np.array(data_list1) 
    228228        # Redimesion based on the row_num and col_num, 
    229229        #otherwise raise an error. 
     
    235235        ## Get the all data: Let's HARDcoding; Todo find better way 
    236236        # Defaults 
    237         dqx_data = numpy.zeros(0) 
    238         dqy_data = numpy.zeros(0) 
    239         err_data = numpy.ones(row_num) 
    240         qz_data = numpy.zeros(row_num) 
    241         mask = numpy.ones(row_num, dtype=bool) 
     237        dqx_data = np.zeros(0) 
     238        dqy_data = np.zeros(0) 
     239        err_data = np.ones(row_num) 
     240        qz_data = np.zeros(row_num) 
     241        mask = np.ones(row_num, dtype=bool) 
    242242        # Get from the array 
    243243        qx_data = data_point[0] 
     
    254254            dqy_data = data_point[(5 + ver)] 
    255255        #if col_num > (6 + ver): mask[data_point[(6 + ver)] < 1] = False 
    256         q_data = numpy.sqrt(qx_data*qx_data+qy_data*qy_data+qz_data*qz_data) 
     256        q_data = np.sqrt(qx_data*qx_data+qy_data*qy_data+qz_data*qz_data) 
    257257            
    258258        # Extra protection(it is needed for some data files):  
     
    262262   
    263263        # Store limits of the image in q space 
    264         xmin = numpy.min(qx_data) 
    265         xmax = numpy.max(qx_data) 
    266         ymin = numpy.min(qy_data) 
    267         ymax = numpy.max(qy_data) 
     264        xmin = np.min(qx_data) 
     265        xmax = np.max(qx_data) 
     266        ymin = np.min(qy_data) 
     267        ymax = np.max(qy_data) 
    268268 
    269269        # units 
     
    287287         
    288288        # store x and y axis bin centers in q space 
    289         x_bins = numpy.arange(xmin, xmax + xstep, xstep) 
    290         y_bins = numpy.arange(ymin, ymax + ystep, ystep) 
     289        x_bins = np.arange(xmin, xmax + xstep, xstep) 
     290        y_bins = np.arange(ymin, ymax + ystep, ystep) 
    291291        
    292292        # get the limits of q values 
     
    300300        output.data = data 
    301301        if (err_data == 1).all(): 
    302             output.err_data = numpy.sqrt(numpy.abs(data)) 
     302            output.err_data = np.sqrt(np.abs(data)) 
    303303            output.err_data[output.err_data == 0.0] = 1.0 
    304304        else: 
     
    335335                # tranfer the comp. to cartesian coord. for newer version. 
    336336                if ver != 1: 
    337                     diag = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     337                    diag = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    338338                    cos_th = qx_data / diag 
    339339                    sin_th = qy_data / diag 
    340                     output.dqx_data = numpy.sqrt((dqx_data * cos_th) * \ 
     340                    output.dqx_data = np.sqrt((dqx_data * cos_th) * \ 
    341341                                                 (dqx_data * cos_th) \ 
    342342                                                 + (dqy_data * sin_th) * \ 
    343343                                                  (dqy_data * sin_th)) 
    344                     output.dqy_data = numpy.sqrt((dqx_data * sin_th) * \ 
     344                    output.dqy_data = np.sqrt((dqx_data * sin_th) * \ 
    345345                                                 (dqx_data * sin_th) \ 
    346346                                                 + (dqy_data * cos_th) * \ 
  • src/sas/sascalc/dataloader/readers/sesans_reader.py

    r7caf3e5 r9a5097c  
    66    Jurrian Bakker  
    77""" 
    8 import numpy 
     8import numpy as np 
    99import os 
    1010from sas.sascalc.dataloader.data_info import Data1D 
     
    6060                buff = input_f.read() 
    6161                lines = buff.splitlines() 
    62                 x  = numpy.zeros(0) 
    63                 y  = numpy.zeros(0) 
    64                 dy = numpy.zeros(0) 
    65                 lam  = numpy.zeros(0) 
    66                 dlam = numpy.zeros(0) 
    67                 dx = numpy.zeros(0) 
     62                x  = np.zeros(0) 
     63                y  = np.zeros(0) 
     64                dy = np.zeros(0) 
     65                lam  = np.zeros(0) 
     66                dlam = np.zeros(0) 
     67                dx = np.zeros(0) 
    6868                 
    6969               #temp. space to sort data 
    70                 tx  = numpy.zeros(0) 
    71                 ty  = numpy.zeros(0) 
    72                 tdy = numpy.zeros(0) 
    73                 tlam  = numpy.zeros(0) 
    74                 tdlam = numpy.zeros(0) 
    75                 tdx = numpy.zeros(0) 
     70                tx  = np.zeros(0) 
     71                ty  = np.zeros(0) 
     72                tdy = np.zeros(0) 
     73                tlam  = np.zeros(0) 
     74                tdlam = np.zeros(0) 
     75                tdx = np.zeros(0) 
    7676                output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, isSesans=True) 
    7777                self.filename = output.filename = basename 
     
    128128 
    129129                x,y,lam,dy,dx,dlam = [ 
    130                    numpy.asarray(v, 'double') 
     130                    np.asarray(v, 'double') 
    131131                   for v in (x,y,lam,dy,dx,dlam) 
    132132                ] 
  • src/sas/sascalc/dataloader/readers/tiff_reader.py

    rb699768 r9a5097c  
    1313import logging 
    1414import os 
    15 import numpy 
     15import numpy as np 
    1616from sas.sascalc.dataloader.data_info import Data2D 
    1717from sas.sascalc.dataloader.manipulations import reader2D_converter 
     
    5656 
    5757        # Initiazed the output data object 
    58         output.data = numpy.zeros([im.size[0], im.size[1]]) 
    59         output.err_data = numpy.zeros([im.size[0], im.size[1]]) 
    60         output.mask = numpy.ones([im.size[0], im.size[1]], dtype=bool) 
     58        output.data = np.zeros([im.size[0], im.size[1]]) 
     59        output.err_data = np.zeros([im.size[0], im.size[1]]) 
     60        output.mask = np.ones([im.size[0], im.size[1]], dtype=bool) 
    6161         
    6262        # Initialize 
     
    9494        output.x_bins = x_vals 
    9595        output.y_bins = y_vals 
    96         output.qx_data = numpy.array(x_vals) 
    97         output.qy_data = numpy.array(y_vals) 
     96        output.qx_data = np.array(x_vals) 
     97        output.qy_data = np.array(y_vals) 
    9898        output.xmin = 0 
    9999        output.xmax = im.size[0] - 1 
  • src/sas/sascalc/fit/AbstractFitEngine.py

    ra9f579c r9a5097c  
    44import sys 
    55import math 
    6 import numpy 
     6import numpy as np 
    77 
    88from sas.sascalc.dataloader.data_info import Data1D 
     
    162162        # constant, or dy data 
    163163        if dy is None or dy == [] or dy.all() == 0: 
    164             self.dy = numpy.ones(len(y)) 
     164            self.dy = np.ones(len(y)) 
    165165        else: 
    166             self.dy = numpy.asarray(dy).copy() 
     166            self.dy = np.asarray(dy).copy() 
    167167 
    168168        ## Min Q-value 
    169169        #Skip the Q=0 point, especially when y(q=0)=None at x[0]. 
    170170        if min(self.x) == 0.0 and self.x[0] == 0 and\ 
    171                      not numpy.isfinite(self.y[0]): 
     171                     not np.isfinite(self.y[0]): 
    172172            self.qmin = min(self.x[self.x != 0]) 
    173173        else: 
     
    188188        # Skip Q=0 point, (especially for y(q=0)=None at x[0]). 
    189189        # ToDo: Find better way to do it. 
    190         if qmin == 0.0 and not numpy.isfinite(self.y[qmin]): 
     190        if qmin == 0.0 and not np.isfinite(self.y[qmin]): 
    191191            self.qmin = min(self.x[self.x != 0]) 
    192192        elif qmin != None: 
     
    239239        """ 
    240240        # Compute theory data f(x) 
    241         fx = numpy.zeros(len(self.x)) 
     241        fx = np.zeros(len(self.x)) 
    242242        fx[self.idx_unsmeared] = fn(self.x[self.idx_unsmeared]) 
    243243        
     
    247247                              self._last_unsmeared_bin) 
    248248        ## Sanity check 
    249         if numpy.size(self.dy) != numpy.size(fx): 
     249        if np.size(self.dy) != np.size(fx): 
    250250            msg = "FitData1D: invalid error array " 
    251             msg += "%d <> %d" % (numpy.shape(self.dy), numpy.size(fx)) 
     251            msg += "%d <> %d" % (np.shape(self.dy), np.size(fx)) 
    252252            raise RuntimeError, msg 
    253253        return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx] 
     
    300300        ## new error image for fitting purpose 
    301301        if self.err_data == None or self.err_data == []: 
    302             self.res_err_data = numpy.ones(len(self.data)) 
     302            self.res_err_data = np.ones(len(self.data)) 
    303303        else: 
    304304            self.res_err_data = copy.deepcopy(self.err_data) 
    305305        #self.res_err_data[self.res_err_data==0]=1 
    306306         
    307         self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2) 
     307        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2) 
    308308         
    309309        # Note: mask = True: for MASK while mask = False for NOT to mask 
     
    311311                            (self.radius <= self.qmax)) 
    312312        self.idx = (self.idx) & (self.mask) 
    313         self.idx = (self.idx) & (numpy.isfinite(self.data)) 
    314         self.num_points = numpy.sum(self.idx) 
     313        self.idx = (self.idx) & (np.isfinite(self.data)) 
     314        self.num_points = np.sum(self.idx) 
    315315 
    316316    def set_smearer(self, smearer): 
     
    334334        if qmax != None: 
    335335            self.qmax = qmax 
    336         self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2) 
     336        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2) 
    337337        self.idx = ((self.qmin <= self.radius) &\ 
    338338                            (self.radius <= self.qmax)) 
    339339        self.idx = (self.idx) & (self.mask) 
    340         self.idx = (self.idx) & (numpy.isfinite(self.data)) 
     340        self.idx = (self.idx) & (np.isfinite(self.data)) 
    341341        self.idx = (self.idx) & (self.res_err_data != 0) 
    342342 
     
    351351        Number of measurement points in data set after masking, etc. 
    352352        """ 
    353         return numpy.sum(self.idx) 
     353        return np.sum(self.idx) 
    354354 
    355355    def residuals(self, fn): 
  • src/sas/sascalc/fit/BumpsFitting.py

    r1a30720 r9a5097c  
    66import traceback 
    77 
    8 import numpy 
     8import numpy as np 
    99 
    1010from bumps import fitters 
     
    9797        try: 
    9898            p = history.population_values[0] 
    99             n,p = len(p), numpy.sort(p) 
     99            n,p = len(p), np.sort(p) 
    100100            QI,Qmid, = int(0.2*n),int(0.5*n) 
    101101            self.convergence.append((best, p[0],p[QI],p[Qmid],p[-1-QI],p[-1])) 
     
    194194 
    195195    def numpoints(self): 
    196         return numpy.sum(self.data.idx) # number of fitted points 
     196        return np.sum(self.data.idx) # number of fitted points 
    197197 
    198198    def nllf(self): 
    199         return 0.5*numpy.sum(self.residuals()**2) 
     199        return 0.5*np.sum(self.residuals()**2) 
    200200 
    201201    def theory(self): 
     
    295295            if R.success: 
    296296                if result['stderr'] is None: 
    297                     R.stderr = numpy.NaN*numpy.ones(len(param_list)) 
     297                    R.stderr = np.NaN*np.ones(len(param_list)) 
    298298                else: 
    299                     R.stderr = numpy.hstack((result['stderr'][fitted_index], 
    300                                              numpy.NaN*numpy.ones(len(fitness.computed_pars)))) 
    301                 R.pvec = numpy.hstack((result['value'][fitted_index], 
     299                    R.stderr = np.hstack((result['stderr'][fitted_index], 
     300                                          np.NaN*np.ones(len(fitness.computed_pars)))) 
     301                R.pvec = np.hstack((result['value'][fitted_index], 
    302302                                      [p.value for p in fitness.computed_pars])) 
    303                 R.fitness = numpy.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index)) 
     303                R.fitness = np.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index)) 
    304304            else: 
    305                 R.stderr = numpy.NaN*numpy.ones(len(param_list)) 
    306                 R.pvec = numpy.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars]) 
    307                 R.fitness = numpy.NaN 
     305                R.stderr = np.NaN*np.ones(len(param_list)) 
     306                R.pvec = np.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars]) 
     307                R.fitness = np.NaN 
    308308            R.convergence = result['convergence'] 
    309309            if result['uncertainty'] is not None: 
     
    336336    max_step = steps + options.get('burn', 0) 
    337337    pars = [p.name for p in problem._parameters] 
    338     #x0 = numpy.asarray([p.value for p in problem._parameters]) 
     338    #x0 = np.asarray([p.value for p in problem._parameters]) 
    339339    options['monitors'] = [ 
    340340        BumpsMonitor(handler, max_step, pars, problem.dof), 
     
    351351        errors = [] 
    352352    except Exception as exc: 
    353         best, fbest = None, numpy.NaN 
     353        best, fbest = None, np.NaN 
    354354        errors = [str(exc), traceback.format_exc()] 
    355355    finally: 
     
    358358 
    359359    convergence_list = options['monitors'][-1].convergence 
    360     convergence = (2*numpy.asarray(convergence_list)/problem.dof 
    361                    if convergence_list else numpy.empty((0,1),'d')) 
     360    convergence = (2*np.asarray(convergence_list)/problem.dof 
     361                   if convergence_list else np.empty((0,1),'d')) 
    362362 
    363363    success = best is not None 
  • src/sas/sascalc/fit/Loader.py

    rb699768 r9a5097c  
    22#import wx 
    33#import string 
    4 import numpy 
     4import numpy as np 
    55 
    66class Load: 
     
    5252                    self.y.append(y) 
    5353                    self.dy.append(dy) 
    54                     self.dx = numpy.zeros(len(self.x)) 
     54                    self.dx = np.zeros(len(self.x)) 
    5555                except: 
    5656                    print "READ ERROR", line 
  • src/sas/sascalc/fit/MultiplicationModel.py

    r68669da r9a5097c  
    11import copy 
    22 
    3 import numpy 
     3import numpy as np 
    44 
    55from sas.sascalc.calculator.BaseComponent import BaseComponent 
     
    5252        ## Parameter details [units, min, max] 
    5353        self._set_details() 
    54         self.details['scale_factor'] = ['', 0.0, numpy.inf] 
    55         self.details['background'] = ['',-numpy.inf,numpy.inf] 
     54        self.details['scale_factor'] = ['', 0.0, np.inf] 
     55        self.details['background'] = ['',-np.inf,np.inf] 
    5656 
    5757        #list of parameter that can be fitted 
  • src/sas/sascalc/fit/expression.py

    rb699768 r9a5097c  
    271271 
    272272def test_deps(): 
    273     import numpy 
     273    import numpy as np 
    274274 
    275275    # Null case 
     
    279279    _check("test1",[(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)]) 
    280280    _check("test1 renumbered",[(6,1),(7,3),(7,4),(6,7),(5,7),(3,2)]) 
    281     _check("test1 numpy",numpy.array([(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)])) 
     281    _check("test1 numpy",np.array([(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)])) 
    282282 
    283283    # No dependencies 
     
    291291 
    292292    # large test for gross speed check 
    293     A = numpy.random.randint(4000,size=(1000,2)) 
     293    A = np.random.randint(4000,size=(1000,2)) 
    294294    A[:,1] += 4000  # Avoid cycles 
    295295    _check("test-large",A) 
     
    297297    # depth tests 
    298298    k = 200 
    299     A = numpy.array([range(0,k),range(1,k+1)]).T 
     299    A = np.array([range(0,k),range(1,k+1)]).T 
    300300    _check("depth-1",A) 
    301301 
    302     A = numpy.array([range(1,k+1),range(0,k)]).T 
     302    A = np.array([range(1,k+1),range(0,k)]).T 
    303303    _check("depth-2",A) 
    304304 
  • src/sas/sascalc/invariant/invariant.py

    rb699768 r9a5097c  
    1717""" 
    1818import math 
    19 import numpy 
     19import numpy as np 
    2020 
    2121from sas.sascalc.dataloader.data_info import Data1D as LoaderData1D 
     
    5050            dy = data.dy 
    5151        else: 
    52             dy = numpy.ones(len(data.y)) 
     52            dy = np.ones(len(data.y)) 
    5353 
    5454        # Transform the data 
     
    6363 
    6464        # Create Data1D object 
    65         x_out = numpy.asarray(x_out) 
    66         y_out = numpy.asarray(y_out) 
    67         dy_out = numpy.asarray(dy_out) 
     65        x_out = np.asarray(x_out) 
     66        y_out = np.asarray(y_out) 
     67        dy_out = np.asarray(dy_out) 
    6868        linear_data = LoaderData1D(x=x_out, y=y_out, dy=dy_out) 
    6969 
     
    158158        :param x: array of q-values 
    159159        """ 
    160         p1 = numpy.array([self.dscale * math.exp(-((self.radius * q) ** 2 / 3)) \ 
     160        p1 = np.array([self.dscale * math.exp(-((self.radius * q) ** 2 / 3)) \ 
    161161                          for q in x]) 
    162         p2 = numpy.array([self.scale * math.exp(-((self.radius * q) ** 2 / 3))\ 
     162        p2 = np.array([self.scale * math.exp(-((self.radius * q) ** 2 / 3))\ 
    163163                     * (-(q ** 2 / 3)) * 2 * self.radius * self.dradius for q in x]) 
    164164        diq2 = p1 * p1 + p2 * p2 
    165         return numpy.array([math.sqrt(err) for err in diq2]) 
     165        return np.array([math.sqrt(err) for err in diq2]) 
    166166 
    167167    def _guinier(self, x): 
     
    182182            msg = "Rg expected positive value, but got %s" % self.radius 
    183183            raise ValueError(msg) 
    184         value = numpy.array([math.exp(-((self.radius * i) ** 2 / 3)) for i in x]) 
     184        value = np.array([math.exp(-((self.radius * i) ** 2 / 3)) for i in x]) 
    185185        return self.scale * value 
    186186 
     
    232232        :param x: array of q-values 
    233233        """ 
    234         p1 = numpy.array([self.dscale * math.pow(q, -self.power) for q in x]) 
    235         p2 = numpy.array([self.scale * self.power * math.pow(q, -self.power - 1)\ 
     234        p1 = np.array([self.dscale * math.pow(q, -self.power) for q in x]) 
     235        p2 = np.array([self.scale * self.power * math.pow(q, -self.power - 1)\ 
    236236                           * self.dpower for q in x]) 
    237237        diq2 = p1 * p1 + p2 * p2 
    238         return numpy.array([math.sqrt(err) for err in diq2]) 
     238        return np.array([math.sqrt(err) for err in diq2]) 
    239239 
    240240    def _power_law(self, x): 
     
    259259            raise ValueError(msg) 
    260260 
    261         value = numpy.array([math.pow(i, -self.power) for i in x]) 
     261        value = np.array([math.pow(i, -self.power) for i in x]) 
    262262        return self.scale * value 
    263263 
     
    304304        idx = (self.data.x >= qmin) & (self.data.x <= qmax) 
    305305 
    306         fx = numpy.zeros(len(self.data.x)) 
     306        fx = np.zeros(len(self.data.x)) 
    307307 
    308308        # Uncertainty 
    309         if type(self.data.dy) == numpy.ndarray and \ 
     309        if type(self.data.dy) == np.ndarray and \ 
    310310            len(self.data.dy) == len(self.data.x) and \ 
    311             numpy.all(self.data.dy > 0): 
     311                np.all(self.data.dy > 0): 
    312312            sigma = self.data.dy 
    313313        else: 
    314             sigma = numpy.ones(len(self.data.x)) 
     314            sigma = np.ones(len(self.data.x)) 
    315315 
    316316        # Compute theory data f(x) 
     
    332332            sigma2 = linearized_data.dy * linearized_data.dy 
    333333            a = -(power) 
    334             b = (numpy.sum(linearized_data.y / sigma2) \ 
    335                  - a * numpy.sum(linearized_data.x / sigma2)) / numpy.sum(1.0 / sigma2) 
     334            b = (np.sum(linearized_data.y / sigma2) \ 
     335                 - a * np.sum(linearized_data.x / sigma2)) / np.sum(1.0 / sigma2) 
    336336 
    337337 
    338338            deltas = linearized_data.x * a + \ 
    339                     numpy.ones(len(linearized_data.x)) * b - linearized_data.y 
    340             residuals = numpy.sum(deltas * deltas / sigma2) 
    341  
    342             err = math.fabs(residuals) / numpy.sum(1.0 / sigma2) 
     339                     np.ones(len(linearized_data.x)) * b - linearized_data.y 
     340            residuals = np.sum(deltas * deltas / sigma2) 
     341 
     342            err = math.fabs(residuals) / np.sum(1.0 / sigma2) 
    343343            return [a, b], [0, math.sqrt(err)] 
    344344        else: 
    345             A = numpy.vstack([linearized_data.x / linearized_data.dy, 1.0 / linearized_data.dy]).T 
    346             (p, residuals, _, _) = numpy.linalg.lstsq(A, linearized_data.y / linearized_data.dy) 
     345            A = np.vstack([linearized_data.x / linearized_data.dy, 1.0 / linearized_data.dy]).T 
     346            (p, residuals, _, _) = np.linalg.lstsq(A, linearized_data.y / linearized_data.dy) 
    347347 
    348348            # Get the covariance matrix, defined as inv_cov = a_transposed * a 
    349             err = numpy.zeros(2) 
     349            err = np.zeros(2) 
    350350            try: 
    351                 inv_cov = numpy.dot(A.transpose(), A) 
    352                 cov = numpy.linalg.pinv(inv_cov) 
     351                inv_cov = np.dot(A.transpose(), A) 
     352                cov = np.linalg.pinv(inv_cov) 
    353353                err_matrix = math.fabs(residuals) * cov 
    354354                err = [math.sqrt(err_matrix[0][0]), math.sqrt(err_matrix[1][1])] 
     
    434434        if new_data.dy is None or len(new_data.x) != len(new_data.dy) or \ 
    435435            (min(new_data.dy) == 0 and max(new_data.dy) == 0): 
    436             new_data.dy = numpy.ones(len(new_data.x)) 
     436            new_data.dy = np.ones(len(new_data.x)) 
    437437        return  new_data 
    438438 
     
    571571        """ 
    572572        #create new Data1D to compute the invariant 
    573         q = numpy.linspace(start=q_start, 
     573        q = np.linspace(start=q_start, 
    574574                           stop=q_end, 
    575575                           num=npts, 
     
    580580        result_data = LoaderData1D(x=q, y=iq, dy=diq) 
    581581        if self._smeared != None: 
    582             result_data.dxl = self._smeared * numpy.ones(len(q)) 
     582            result_data.dxl = self._smeared * np.ones(len(q)) 
    583583        return result_data 
    584584 
     
    691691 
    692692        if q_start >= q_end: 
    693             return numpy.zeros(0), numpy.zeros(0) 
     693            return np.zeros(0), np.zeros(0) 
    694694 
    695695        return self._get_extrapolated_data(\ 
     
    719719 
    720720        if q_start >= q_end: 
    721             return numpy.zeros(0), numpy.zeros(0) 
     721            return np.zeros(0), np.zeros(0) 
    722722 
    723723        return self._get_extrapolated_data(\ 
  • src/sas/sascalc/pr/fit/AbstractFitEngine.py

    rfc18690 r9a5097c  
    44import sys 
    55import math 
    6 import numpy 
     6import numpy as np 
    77 
    88from sas.sascalc.dataloader.data_info import Data1D 
     
    162162        # constant, or dy data 
    163163        if dy is None or dy == [] or dy.all() == 0: 
    164             self.dy = numpy.ones(len(y)) 
     164            self.dy = np.ones(len(y)) 
    165165        else: 
    166             self.dy = numpy.asarray(dy).copy() 
     166            self.dy = np.asarray(dy).copy() 
    167167 
    168168        ## Min Q-value 
    169169        #Skip the Q=0 point, especially when y(q=0)=None at x[0]. 
    170170        if min(self.x) == 0.0 and self.x[0] == 0 and\ 
    171                      not numpy.isfinite(self.y[0]): 
     171                     not np.isfinite(self.y[0]): 
    172172            self.qmin = min(self.x[self.x != 0]) 
    173173        else: 
     
    188188        # Skip Q=0 point, (especially for y(q=0)=None at x[0]). 
    189189        # ToDo: Find better way to do it. 
    190         if qmin == 0.0 and not numpy.isfinite(self.y[qmin]): 
     190        if qmin == 0.0 and not np.isfinite(self.y[qmin]): 
    191191            self.qmin = min(self.x[self.x != 0]) 
    192192        elif qmin != None: 
     
    239239        """ 
    240240        # Compute theory data f(x) 
    241         fx = numpy.zeros(len(self.x)) 
     241        fx = np.zeros(len(self.x)) 
    242242        fx[self.idx_unsmeared] = fn(self.x[self.idx_unsmeared]) 
    243243        
     
    247247                              self._last_unsmeared_bin) 
    248248        ## Sanity check 
    249         if numpy.size(self.dy) != numpy.size(fx): 
     249        if np.size(self.dy) != np.size(fx): 
    250250            msg = "FitData1D: invalid error array " 
    251             msg += "%d <> %d" % (numpy.shape(self.dy), numpy.size(fx)) 
     251            msg += "%d <> %d" % (np.shape(self.dy), np.size(fx)) 
    252252            raise RuntimeError, msg 
    253253        return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx] 
     
    300300        ## new error image for fitting purpose 
    301301        if self.err_data == None or self.err_data == []: 
    302             self.res_err_data = numpy.ones(len(self.data)) 
     302            self.res_err_data = np.ones(len(self.data)) 
    303303        else: 
    304304            self.res_err_data = copy.deepcopy(self.err_data) 
    305305        #self.res_err_data[self.res_err_data==0]=1 
    306306         
    307         self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2) 
     307        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2) 
    308308         
    309309        # Note: mask = True: for MASK while mask = False for NOT to mask 
     
    311311                            (self.radius <= self.qmax)) 
    312312        self.idx = (self.idx) & (self.mask) 
    313         self.idx = (self.idx) & (numpy.isfinite(self.data)) 
    314         self.num_points = numpy.sum(self.idx) 
     313        self.idx = (self.idx) & (np.isfinite(self.data)) 
     314        self.num_points = np.sum(self.idx) 
    315315 
    316316    def set_smearer(self, smearer): 
     
    334334        if qmax != None: 
    335335            self.qmax = qmax 
    336         self.radius = numpy.sqrt(self.qx_data**2 + self.qy_data**2) 
     336        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2) 
    337337        self.idx = ((self.qmin <= self.radius) &\ 
    338338                            (self.radius <= self.qmax)) 
    339339        self.idx = (self.idx) & (self.mask) 
    340         self.idx = (self.idx) & (numpy.isfinite(self.data)) 
     340        self.idx = (self.idx) & (np.isfinite(self.data)) 
    341341        self.idx = (self.idx) & (self.res_err_data != 0) 
    342342 
     
    351351        Number of measurement points in data set after masking, etc. 
    352352        """ 
    353         return numpy.sum(self.idx) 
     353        return np.sum(self.idx) 
    354354 
    355355    def residuals(self, fn): 
  • src/sas/sascalc/pr/fit/BumpsFitting.py

    rb699768 r9a5097c  
    55from datetime import timedelta, datetime 
    66 
    7 import numpy 
     7import numpy as np 
    88 
    99from bumps import fitters 
     
    9696        try: 
    9797            p = history.population_values[0] 
    98             n,p = len(p), numpy.sort(p) 
     98            n,p = len(p), np.sort(p) 
    9999            QI,Qmid, = int(0.2*n),int(0.5*n) 
    100100            self.convergence.append((best, p[0],p[QI],p[Qmid],p[-1-QI],p[-1])) 
     
    193193 
    194194    def numpoints(self): 
    195         return numpy.sum(self.data.idx) # number of fitted points 
     195        return np.sum(self.data.idx) # number of fitted points 
    196196 
    197197    def nllf(self): 
    198         return 0.5*numpy.sum(self.residuals()**2) 
     198        return 0.5*np.sum(self.residuals()**2) 
    199199 
    200200    def theory(self): 
     
    293293            R.success = result['success'] 
    294294            if R.success: 
    295                 R.stderr = numpy.hstack((result['stderr'][fitted_index], 
    296                                          numpy.NaN*numpy.ones(len(fitness.computed_pars)))) 
    297                 R.pvec = numpy.hstack((result['value'][fitted_index], 
     295                R.stderr = np.hstack((result['stderr'][fitted_index], 
     296                                      np.NaN*np.ones(len(fitness.computed_pars)))) 
     297                R.pvec = np.hstack((result['value'][fitted_index], 
    298298                                      [p.value for p in fitness.computed_pars])) 
    299                 R.fitness = numpy.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index)) 
     299                R.fitness = np.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index)) 
    300300            else: 
    301                 R.stderr = numpy.NaN*numpy.ones(len(param_list)) 
    302                 R.pvec = numpy.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars]) 
    303                 R.fitness = numpy.NaN 
     301                R.stderr = np.NaN*np.ones(len(param_list)) 
     302                R.pvec = np.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars]) 
     303                R.fitness = np.NaN 
    304304            R.convergence = result['convergence'] 
    305305            if result['uncertainty'] is not None: 
     
    331331    max_step = steps + options.get('burn', 0) 
    332332    pars = [p.name for p in problem._parameters] 
    333     #x0 = numpy.asarray([p.value for p in problem._parameters]) 
     333    #x0 = np.asarray([p.value for p in problem._parameters]) 
    334334    options['monitors'] = [ 
    335335        BumpsMonitor(handler, max_step, pars, problem.dof), 
     
    352352 
    353353    convergence_list = options['monitors'][-1].convergence 
    354     convergence = (2*numpy.asarray(convergence_list)/problem.dof 
    355                    if convergence_list else numpy.empty((0,1),'d')) 
     354    convergence = (2*np.asarray(convergence_list)/problem.dof 
     355                   if convergence_list else np.empty((0,1),'d')) 
    356356 
    357357    success = best is not None 
  • src/sas/sascalc/pr/fit/Loader.py

    rb699768 r9a5097c  
    22#import wx 
    33#import string 
    4 import numpy 
     4import numpy as np 
    55 
    66class Load: 
     
    5252                    self.y.append(y) 
    5353                    self.dy.append(dy) 
    54                     self.dx = numpy.zeros(len(self.x)) 
     54                    self.dx = np.zeros(len(self.x)) 
    5555                except: 
    5656                    print "READ ERROR", line 
  • src/sas/sascalc/pr/fit/expression.py

    rb699768 r9a5097c  
    271271 
    272272def test_deps(): 
    273     import numpy 
     273    import numpy as np 
    274274 
    275275    # Null case 
     
    279279    _check("test1",[(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)]) 
    280280    _check("test1 renumbered",[(6,1),(7,3),(7,4),(6,7),(5,7),(3,2)]) 
    281     _check("test1 numpy",numpy.array([(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)])) 
     281    _check("test1 numpy",np.array([(2,7),(1,5),(1,4),(2,1),(3,1),(5,6)])) 
    282282 
    283283    # No dependencies 
     
    291291 
    292292    # large test for gross speed check 
    293     A = numpy.random.randint(4000,size=(1000,2)) 
     293    A = np.random.randint(4000,size=(1000,2)) 
    294294    A[:,1] += 4000  # Avoid cycles 
    295295    _check("test-large",A) 
     
    297297    # depth tests 
    298298    k = 200 
    299     A = numpy.array([range(0,k),range(1,k+1)]).T 
     299    A = np.array([range(0,k),range(1,k+1)]).T 
    300300    _check("depth-1",A) 
    301301 
    302     A = numpy.array([range(1,k+1),range(0,k)]).T 
     302    A = np.array([range(1,k+1),range(0,k)]).T 
    303303    _check("depth-2",A) 
    304304 
  • src/sas/sascalc/pr/invertor.py

    r2c60f304 r9a5097c  
    77""" 
    88 
    9 import numpy 
     9import numpy as np 
    1010import sys 
    1111import math 
     
    189189        #import numpy 
    190190        if name == 'x': 
    191             out = numpy.ones(self.get_nx()) 
     191            out = np.ones(self.get_nx()) 
    192192            self.get_x(out) 
    193193            return out 
    194194        elif name == 'y': 
    195             out = numpy.ones(self.get_ny()) 
     195            out = np.ones(self.get_ny()) 
    196196            self.get_y(out) 
    197197            return out 
    198198        elif name == 'err': 
    199             out = numpy.ones(self.get_nerr()) 
     199            out = np.ones(self.get_nerr()) 
    200200            self.get_err(out) 
    201201            return out 
     
    325325            raise RuntimeError, msg 
    326326 
    327         p = numpy.ones(nfunc) 
     327        p = np.ones(nfunc) 
    328328        t_0 = time.time() 
    329329        out, cov_x, _, _, _ = optimize.leastsq(self.residuals, p, full_output=1) 
     
    341341 
    342342        if cov_x is None: 
    343             cov_x = numpy.ones([nfunc, nfunc]) 
     343            cov_x = np.ones([nfunc, nfunc]) 
    344344            cov_x *= math.fabs(chisqr) 
    345345        return out, cov_x 
     
    358358            raise RuntimeError, msg 
    359359 
    360         p = numpy.ones(nfunc) 
     360        p = np.ones(nfunc) 
    361361        t_0 = time.time() 
    362362        out, cov_x, _, _, _ = optimize.leastsq(self.pr_residuals, p, full_output=1) 
     
    435435        """ 
    436436        # Note: To make sure an array is contiguous: 
    437         # blah = numpy.ascontiguousarray(blah_original) 
     437        # blah = np.ascontiguousarray(blah_original) 
    438438        # ... before passing it to C 
    439439 
     
    456456            nfunc += 1 
    457457 
    458         a = numpy.zeros([npts + nq, nfunc]) 
    459         b = numpy.zeros(npts + nq) 
    460         err = numpy.zeros([nfunc, nfunc]) 
     458        a = np.zeros([npts + nq, nfunc]) 
     459        b = np.zeros(npts + nq) 
     460        err = np.zeros([nfunc, nfunc]) 
    461461 
    462462        # Construct the a matrix and b vector that represent the problem 
     
    476476        self.chi2 = chi2 
    477477 
    478         inv_cov = numpy.zeros([nfunc, nfunc]) 
     478        inv_cov = np.zeros([nfunc, nfunc]) 
    479479        # Get the covariance matrix, defined as inv_cov = a_transposed * a 
    480480        self._get_invcov_matrix(nfunc, nr, a, inv_cov) 
     
    490490 
    491491        try: 
    492             cov = numpy.linalg.pinv(inv_cov) 
     492            cov = np.linalg.pinv(inv_cov) 
    493493            err = math.fabs(chi2 / float(npts - nfunc)) * cov 
    494494        except: 
     
    505505            self.background = c[0] 
    506506 
    507             err_0 = numpy.zeros([nfunc, nfunc]) 
    508             c_0 = numpy.zeros(nfunc) 
     507            err_0 = np.zeros([nfunc, nfunc]) 
     508            c_0 = np.zeros(nfunc) 
    509509 
    510510            for i in range(nfunc_0): 
     
    662662                                                   str(self.cov[i][i]))) 
    663663        file.write("<r>  <Pr>  <dPr>\n") 
    664         r = numpy.arange(0.0, self.d_max, self.d_max / npts) 
     664        r = np.arange(0.0, self.d_max, self.d_max / npts) 
    665665 
    666666        for r_i in r: 
     
    694694                        toks = line.split('=') 
    695695                        self.nfunc = int(toks[1]) 
    696                         self.out = numpy.zeros(self.nfunc) 
    697                         self.cov = numpy.zeros([self.nfunc, self.nfunc]) 
     696                        self.out = np.zeros(self.nfunc) 
     697                        self.cov = np.zeros([self.nfunc, self.nfunc]) 
    698698                    elif line.startswith('#alpha='): 
    699699                        toks = line.split('=') 
  • src/sas/sascalc/pr/num_term.py

    rb699768 r9a5097c  
    11import math 
    2 import numpy 
     2import numpy as np 
    33import copy 
    44import sys 
     
    152152def load(path): 
    153153    # Read the data from the data file 
    154     data_x = numpy.zeros(0) 
    155     data_y = numpy.zeros(0) 
    156     data_err = numpy.zeros(0) 
     154    data_x = np.zeros(0) 
     155    data_y = np.zeros(0) 
     156    data_err = np.zeros(0) 
    157157    scale = None 
    158158    min_err = 0.0 
     
    176176                    #err = 0 
    177177 
    178                 data_x = numpy.append(data_x, test_x) 
    179                 data_y = numpy.append(data_y, test_y) 
    180                 data_err = numpy.append(data_err, err) 
     178                data_x = np.append(data_x, test_x) 
     179                data_y = np.append(data_y, test_y) 
     180                data_err = np.append(data_err, err) 
    181181            except: 
    182182                logging.error(sys.exc_value) 
  • src/sas/sasgui/guiframe/dataFitting.py

    r68adf86 r9a5097c  
    33""" 
    44import copy 
    5 import numpy 
     5import numpy as np 
    66import math 
    77from sas.sascalc.data_util.uncertainty import Uncertainty 
     
    8181            result.dxw = None 
    8282        else: 
    83             result.dxw = numpy.zeros(len(self.x)) 
     83            result.dxw = np.zeros(len(self.x)) 
    8484        if self.dxl == None: 
    8585            result.dxl = None 
    8686        else: 
    87             result.dxl = numpy.zeros(len(self.x)) 
     87            result.dxl = np.zeros(len(self.x)) 
    8888 
    8989        for i in range(len(self.x)): 
     
    128128            result.dlam = None 
    129129        else: 
    130             result.dlam = numpy.zeros(tot_length) 
     130            result.dlam = np.zeros(tot_length) 
    131131        if self.dy == None or other.dy is None: 
    132132            result.dy = None 
    133133        else: 
    134             result.dy = numpy.zeros(tot_length) 
     134            result.dy = np.zeros(tot_length) 
    135135        if self.dx == None or other.dx is None: 
    136136            result.dx = None 
    137137        else: 
    138             result.dx = numpy.zeros(tot_length) 
     138            result.dx = np.zeros(tot_length) 
    139139        if self.dxw == None or other.dxw is None: 
    140140            result.dxw = None 
    141141        else: 
    142             result.dxw = numpy.zeros(tot_length) 
     142            result.dxw = np.zeros(tot_length) 
    143143        if self.dxl == None or other.dxl is None: 
    144144            result.dxl = None 
    145145        else: 
    146             result.dxl = numpy.zeros(tot_length) 
    147  
    148         result.x = numpy.append(self.x, other.x) 
     146            result.dxl = np.zeros(tot_length) 
     147 
     148        result.x = np.append(self.x, other.x) 
    149149        #argsorting 
    150         ind = numpy.argsort(result.x) 
     150        ind = np.argsort(result.x) 
    151151        result.x = result.x[ind] 
    152         result.y = numpy.append(self.y, other.y) 
     152        result.y = np.append(self.y, other.y) 
    153153        result.y = result.y[ind] 
    154         result.lam = numpy.append(self.lam, other.lam) 
     154        result.lam = np.append(self.lam, other.lam) 
    155155        result.lam = result.lam[ind] 
    156156        if result.dlam != None: 
    157             result.dlam = numpy.append(self.dlam, other.dlam) 
     157            result.dlam = np.append(self.dlam, other.dlam) 
    158158            result.dlam = result.dlam[ind] 
    159159        if result.dy != None: 
    160             result.dy = numpy.append(self.dy, other.dy) 
     160            result.dy = np.append(self.dy, other.dy) 
    161161            result.dy = result.dy[ind] 
    162162        if result.dx is not None: 
    163             result.dx = numpy.append(self.dx, other.dx) 
     163            result.dx = np.append(self.dx, other.dx) 
    164164            result.dx = result.dx[ind] 
    165165        if result.dxw is not None: 
    166             result.dxw = numpy.append(self.dxw, other.dxw) 
     166            result.dxw = np.append(self.dxw, other.dxw) 
    167167            result.dxw = result.dxw[ind] 
    168168        if result.dxl is not None: 
    169             result.dxl = numpy.append(self.dxl, other.dxl) 
     169            result.dxl = np.append(self.dxl, other.dxl) 
    170170            result.dxl = result.dxl[ind] 
    171171        return result 
     
    230230            result.dxw = None 
    231231        else: 
    232             result.dxw = numpy.zeros(len(self.x)) 
     232            result.dxw = np.zeros(len(self.x)) 
    233233        if self.dxl == None: 
    234234            result.dxl = None 
    235235        else: 
    236             result.dxl = numpy.zeros(len(self.x)) 
    237  
    238         for i in range(numpy.size(self.x)): 
     236            result.dxl = np.zeros(len(self.x)) 
     237 
     238        for i in range(np.size(self.x)): 
    239239            result.x[i] = self.x[i] 
    240240            if self.dx is not None and len(self.x) == len(self.dx): 
     
    282282            result.dlam = None 
    283283        else: 
    284             result.dlam = numpy.zeros(tot_length) 
     284            result.dlam = np.zeros(tot_length) 
    285285        if self.dy == None or other.dy is None: 
    286286            result.dy = None 
    287287        else: 
    288             result.dy = numpy.zeros(tot_length) 
     288            result.dy = np.zeros(tot_length) 
    289289        if self.dx == None or other.dx is None: 
    290290            result.dx = None 
    291291        else: 
    292             result.dx = numpy.zeros(tot_length) 
     292            result.dx = np.zeros(tot_length) 
    293293        if self.dxw == None or other.dxw is None: 
    294294            result.dxw = None 
    295295        else: 
    296             result.dxw = numpy.zeros(tot_length) 
     296            result.dxw = np.zeros(tot_length) 
    297297        if self.dxl == None or other.dxl is None: 
    298298            result.dxl = None 
    299299        else: 
    300             result.dxl = numpy.zeros(tot_length) 
    301         result.x = numpy.append(self.x, other.x) 
     300            result.dxl = np.zeros(tot_length) 
     301        result.x = np.append(self.x, other.x) 
    302302        #argsorting 
    303         ind = numpy.argsort(result.x) 
     303        ind = np.argsort(result.x) 
    304304        result.x = result.x[ind] 
    305         result.y = numpy.append(self.y, other.y) 
     305        result.y = np.append(self.y, other.y) 
    306306        result.y = result.y[ind] 
    307         result.lam = numpy.append(self.lam, other.lam) 
     307        result.lam = np.append(self.lam, other.lam) 
    308308        result.lam = result.lam[ind] 
    309309        if result.dy != None: 
    310             result.dy = numpy.append(self.dy, other.dy) 
     310            result.dy = np.append(self.dy, other.dy) 
    311311            result.dy = result.dy[ind] 
    312312        if result.dx is not None: 
    313             result.dx = numpy.append(self.dx, other.dx) 
     313            result.dx = np.append(self.dx, other.dx) 
    314314            result.dx = result.dx[ind] 
    315315        if result.dxw is not None: 
    316             result.dxw = numpy.append(self.dxw, other.dxw) 
     316            result.dxw = np.append(self.dxw, other.dxw) 
    317317            result.dxw = result.dxw[ind] 
    318318        if result.dxl is not None: 
    319             result.dxl = numpy.append(self.dxl, other.dxl) 
     319            result.dxl = np.append(self.dxl, other.dxl) 
    320320            result.dxl = result.dxl[ind] 
    321321        return result 
     
    409409            result.dqy_data = None 
    410410        else: 
    411             result.dqx_data = numpy.zeros(len(self.data)) 
    412             result.dqy_data = numpy.zeros(len(self.data)) 
    413         for i in range(numpy.size(self.data)): 
     411            result.dqx_data = np.zeros(len(self.data)) 
     412            result.dqy_data = np.zeros(len(self.data)) 
     413        for i in range(np.size(self.data)): 
    414414            result.data[i] = self.data[i] 
    415415            if self.err_data is not None and \ 
    416                 numpy.size(self.data) == numpy.size(self.err_data): 
     416                            np.size(self.data) == np.size(self.err_data): 
    417417                result.err_data[i] = self.err_data[i]     
    418418            if self.dqx_data is not None: 
     
    473473            result.dqy_data = None 
    474474        else: 
    475             result.dqx_data = numpy.zeros(len(self.data) + \ 
    476                                          numpy.size(other.data)) 
    477             result.dqy_data = numpy.zeros(len(self.data) + \ 
    478                                          numpy.size(other.data)) 
    479          
    480         result.data = numpy.append(self.data, other.data) 
    481         result.qx_data = numpy.append(self.qx_data, other.qx_data) 
    482         result.qy_data = numpy.append(self.qy_data, other.qy_data) 
    483         result.q_data = numpy.append(self.q_data, other.q_data) 
    484         result.mask = numpy.append(self.mask, other.mask) 
     475            result.dqx_data = np.zeros(len(self.data) + \ 
     476                                       np.size(other.data)) 
     477            result.dqy_data = np.zeros(len(self.data) + \ 
     478                                       np.size(other.data)) 
     479         
     480        result.data = np.append(self.data, other.data) 
     481        result.qx_data = np.append(self.qx_data, other.qx_data) 
     482        result.qy_data = np.append(self.qy_data, other.qy_data) 
     483        result.q_data = np.append(self.q_data, other.q_data) 
     484        result.mask = np.append(self.mask, other.mask) 
    485485        if result.err_data is not None: 
    486             result.err_data = numpy.append(self.err_data, other.err_data)  
     486            result.err_data = np.append(self.err_data, other.err_data) 
    487487        if self.dqx_data is not None: 
    488             result.dqx_data = numpy.append(self.dqx_data, other.dqx_data) 
     488            result.dqx_data = np.append(self.dqx_data, other.dqx_data) 
    489489        if self.dqy_data is not None: 
    490             result.dqy_data = numpy.append(self.dqy_data, other.dqy_data) 
     490            result.dqy_data = np.append(self.dqy_data, other.dqy_data) 
    491491 
    492492        return result 
  • src/sas/sasgui/guiframe/data_processor.py

    r468c253 r9a5097c  
    10911091            # When inputs are from an external file 
    10921092            return inputs, outputs 
    1093         inds = numpy.lexsort((to_be_sort, to_be_sort)) 
     1093        inds = np.lexsort((to_be_sort, to_be_sort)) 
    10941094        for key in outputs.keys(): 
    10951095            key_list = outputs[key] 
     
    13791379            return 
    13801380        if dy == None: 
    1381             dy = numpy.zeros(len(y)) 
     1381            dy = np.zeros(len(y)) 
    13821382        #plotting 
    13831383        new_plot = Data1D(x=x, y=y, dy=dy) 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter1D.py

    r29e872e r9a5097c  
    1414import sys 
    1515import math 
    16 import numpy 
     16import numpy as np 
    1717import logging 
    1818from sas.sasgui.plottools.PlotPanel import PlotPanel 
     
    288288        :Param value: float 
    289289        """ 
    290         idx = (numpy.abs(array - value)).argmin() 
     290        idx = (np.abs(array - value)).argmin() 
    291291        return int(idx)  # array.flat[idx] 
    292292 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter2D.py

    rb2b36932 r9a5097c  
    1414import sys 
    1515import math 
    16 import numpy 
     16import numpy as np 
    1717import logging 
    1818from sas.sasgui.plottools.PlotPanel import PlotPanel 
     
    567567        """ 
    568568        # Find the best number of bins 
    569         npt = math.sqrt(len(self.data2D.data[numpy.isfinite(self.data2D.data)])) 
     569        npt = math.sqrt(len(self.data2D.data[np.isfinite(self.data2D.data)])) 
    570570        npt = math.floor(npt) 
    571571        from sas.sascalc.dataloader.manipulations import CircularAverage 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/boxSlicer.py

    rd85c194 r9a5097c  
    11import wx 
    22import math 
    3 import numpy 
     3import numpy as np 
    44from sas.sasgui.guiframe.events import NewPlotEvent 
    55from sas.sasgui.guiframe.events import StatusEvent 
     
    358358        # # Reset x, y- coordinates if send as parameters 
    359359        if x != None: 
    360             self.x = numpy.sign(self.x) * math.fabs(x) 
     360            self.x = np.sign(self.x) * math.fabs(x) 
    361361        if y != None: 
    362             self.y = numpy.sign(self.y) * math.fabs(y) 
     362            self.y = np.sign(self.y) * math.fabs(y) 
    363363        # # Draw lines and markers 
    364364        self.inner_marker.set(xdata=[0], ydata=[self.y]) 
     
    465465        # # reset x, y -coordinates if given as parameters 
    466466        if x != None: 
    467             self.x = numpy.sign(self.x) * math.fabs(x) 
     467            self.x = np.sign(self.x) * math.fabs(x) 
    468468        if y != None: 
    469             self.y = numpy.sign(self.y) * math.fabs(y) 
     469            self.y = np.sign(self.y) * math.fabs(y) 
    470470        # # draw lines and markers 
    471471        self.inner_marker.set(xdata=[self.x], ydata=[0]) 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/masking.py

    rd85c194 r9a5097c  
    2424import math 
    2525import copy 
    26 import numpy 
     26import numpy as np 
    2727from sas.sasgui.plottools.PlotPanel import PlotPanel 
    2828from sas.sasgui.plottools.plottables import Graph 
     
    298298        self.subplot.set_ylim(self.data.ymin, self.data.ymax) 
    299299        self.subplot.set_xlim(self.data.xmin, self.data.xmax) 
    300         mask = numpy.ones(len(self.data.mask), dtype=bool) 
     300        mask = np.ones(len(self.data.mask), dtype=bool) 
    301301        self.data.mask = mask 
    302302        # update mask plot 
     
    343343            self.mask = mask 
    344344        # make temperary data to plot 
    345         temp_mask = numpy.zeros(len(mask)) 
     345        temp_mask = np.zeros(len(mask)) 
    346346        temp_data = copy.deepcopy(self.data) 
    347347        # temp_data default is None 
  • src/sas/sasgui/perspectives/calculator/data_operator.py

    r61780e3 r9a5097c  
    55import sys 
    66import time 
    7 import numpy 
     7import numpy as np 
    88from sas.sascalc.dataloader.data_info import Data1D 
    99from sas.sasgui.plottools.PlotPanel import PlotPanel 
     
    541541                    theory, _ = theory_list.values()[0] 
    542542                    dnames.append(theory.name) 
    543         ind = numpy.argsort(dnames) 
     543        ind = np.argsort(dnames) 
    544544        if len(ind) > 0: 
    545             val_list = numpy.array(self._data.values())[ind] 
     545            val_list = np.array(self._data.values())[ind] 
    546546            for datastate in val_list: 
    547547                data = datastate.data 
  • src/sas/sasgui/perspectives/calculator/gen_scatter_panel.py

    r0f7c930 r9a5097c  
    77import sys 
    88import os 
    9 import numpy 
     9import numpy as np 
    1010#import math 
    1111import wx.aui as aui 
     
    741741            marker = 'o' 
    742742            m_size = 3.5 
    743         sld_tot = (numpy.fabs(sld_mx) + numpy.fabs(sld_my) + \ 
    744                    numpy.fabs(sld_mz) + numpy.fabs(output.sld_n)) 
     743        sld_tot = (np.fabs(sld_mx) + np.fabs(sld_my) + \ 
     744                   np.fabs(sld_mz) + np.fabs(output.sld_n)) 
    745745        is_nonzero = sld_tot > 0.0 
    746746        is_zero = sld_tot == 0.0 
     
    757757            pix_symbol = output.pix_symbol[is_nonzero] 
    758758        # II. Plot selective points in color 
    759         other_color = numpy.ones(len(pix_symbol), dtype='bool') 
     759        other_color = np.ones(len(pix_symbol), dtype='bool') 
    760760        for key in color_dic.keys(): 
    761761            chosen_color = pix_symbol == key 
    762             if numpy.any(chosen_color): 
     762            if np.any(chosen_color): 
    763763                other_color = other_color & (chosen_color != True) 
    764764                color = color_dic[key] 
     
    767767                        markeredgecolor=color, markersize=m_size, label=key) 
    768768        # III. Plot All others         
    769         if numpy.any(other_color): 
     769        if np.any(other_color): 
    770770            a_name = '' 
    771771            if output.pix_type == 'atom': 
     
    795795                draw magnetic vectors w/arrow 
    796796                """ 
    797                 max_mx = max(numpy.fabs(sld_mx)) 
    798                 max_my = max(numpy.fabs(sld_my)) 
    799                 max_mz = max(numpy.fabs(sld_mz)) 
     797                max_mx = max(np.fabs(sld_mx)) 
     798                max_my = max(np.fabs(sld_my)) 
     799                max_mz = max(np.fabs(sld_mz)) 
    800800                max_m = max(max_mx, max_my, max_mz) 
    801801                try: 
     
    812812                        unit_z2 = sld_mz / max_m 
    813813                        # 0.8 is for avoiding the color becomes white=(1,1,1)) 
    814                         color_x = numpy.fabs(unit_x2 * 0.8) 
    815                         color_y = numpy.fabs(unit_y2 * 0.8) 
    816                         color_z = numpy.fabs(unit_z2 * 0.8) 
     814                        color_x = np.fabs(unit_x2 * 0.8) 
     815                        color_y = np.fabs(unit_y2 * 0.8) 
     816                        color_z = np.fabs(unit_z2 * 0.8) 
    817817                        x2 = pos_x + unit_x2 * max_step 
    818818                        y2 = pos_y + unit_y2 * max_step 
    819819                        z2 = pos_z + unit_z2 * max_step 
    820                         x_arrow = numpy.column_stack((pos_x, x2)) 
    821                         y_arrow = numpy.column_stack((pos_y, y2)) 
    822                         z_arrow = numpy.column_stack((pos_z, z2)) 
    823                         colors = numpy.column_stack((color_x, color_y, color_z)) 
     820                        x_arrow = np.column_stack((pos_x, x2)) 
     821                        y_arrow = np.column_stack((pos_y, y2)) 
     822                        z_arrow = np.column_stack((pos_z, z2)) 
     823                        colors = np.column_stack((color_x, color_y, color_z)) 
    824824                        arrows = Arrow3D(panel, x_arrow, z_arrow, y_arrow, 
    825825                                        colors, mutation_scale=10, lw=1, 
     
    880880            if self.is_avg or self.is_avg == None: 
    881881                self._create_default_1d_data() 
    882                 i_out = numpy.zeros(len(self.data.y)) 
     882                i_out = np.zeros(len(self.data.y)) 
    883883                inputs = [self.data.x, [], i_out] 
    884884            else: 
    885885                self._create_default_2d_data() 
    886                 i_out = numpy.zeros(len(self.data.data)) 
     886                i_out = np.zeros(len(self.data.data)) 
    887887                inputs = [self.data.qx_data, self.data.qy_data, i_out] 
    888888 
     
    989989        :Param input: input list [qx_data, qy_data, i_out] 
    990990        """ 
    991         out = numpy.empty(0) 
     991        out = np.empty(0) 
    992992        #s = time.time() 
    993993        for ind in range(len(input[0])): 
     
    998998                inputi = [input[0][ind:ind + 1], [], input[2][ind:ind + 1]] 
    999999                outi = self.model.run(inputi) 
    1000                 out = numpy.append(out, outi) 
     1000                out = np.append(out, outi) 
    10011001            else: 
    10021002                if ind % 50 == 0  and update != None: 
     
    10061006                          input[2][ind:ind + 1]] 
    10071007                outi = self.model.runXY(inputi) 
    1008                 out = numpy.append(out, outi) 
     1008                out = np.append(out, outi) 
    10091009        #print time.time() - s 
    10101010        if self.is_avg or self.is_avg == None: 
     
    10271027        self.npts_x = int(float(self.npt_ctl.GetValue())) 
    10281028        self.data = Data2D() 
    1029         qmax = self.qmax_x #/ numpy.sqrt(2) 
     1029        qmax = self.qmax_x #/ np.sqrt(2) 
    10301030        self.data.xaxis('\\rm{Q_{x}}', '\AA^{-1}') 
    10311031        self.data.yaxis('\\rm{Q_{y}}', '\AA^{-1}') 
     
    10481048        qstep = self.npts_x 
    10491049 
    1050         x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
    1051         y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True) 
     1050        x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
     1051        y = np.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True) 
    10521052        ## use data info instead 
    1053         new_x = numpy.tile(x, (len(y), 1)) 
    1054         new_y = numpy.tile(y, (len(x), 1)) 
     1053        new_x = np.tile(x, (len(y), 1)) 
     1054        new_y = np.tile(y, (len(x), 1)) 
    10551055        new_y = new_y.swapaxes(0, 1) 
    10561056        # all data reuire now in 1d array 
    10571057        qx_data = new_x.flatten() 
    10581058        qy_data = new_y.flatten() 
    1059         q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     1059        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    10601060        # set all True (standing for unmasked) as default 
    1061         mask = numpy.ones(len(qx_data), dtype=bool) 
     1061        mask = np.ones(len(qx_data), dtype=bool) 
    10621062        # store x and y bin centers in q space 
    10631063        x_bins = x 
    10641064        y_bins = y 
    10651065        self.data.source = Source() 
    1066         self.data.data = numpy.ones(len(mask)) 
    1067         self.data.err_data = numpy.ones(len(mask)) 
     1066        self.data.data = np.ones(len(mask)) 
     1067        self.data.err_data = np.ones(len(mask)) 
    10681068        self.data.qx_data = qx_data 
    10691069        self.data.qy_data = qy_data 
     
    10841084        :warning: This data is never plotted. 
    10851085                    residuals.x = data_copy.x[index] 
    1086             residuals.dy = numpy.ones(len(residuals.y)) 
     1086            residuals.dy = np.ones(len(residuals.y)) 
    10871087            residuals.dx = None 
    10881088            residuals.dxl = None 
     
    10911091        self.qmax_x = float(self.qmax_ctl.GetValue()) 
    10921092        self.npts_x = int(float(self.npt_ctl.GetValue())) 
    1093         qmax = self.qmax_x #/ numpy.sqrt(2) 
     1093        qmax = self.qmax_x #/ np.sqrt(2) 
    10941094        ## Default values 
    10951095        xmax = qmax 
    10961096        xmin = qmax * _Q1D_MIN 
    10971097        qstep = self.npts_x 
    1098         x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
     1098        x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
    10991099        # store x and y bin centers in q space 
    11001100        #self.data.source = Source() 
    1101         y = numpy.ones(len(x)) 
    1102         dy = numpy.zeros(len(x)) 
    1103         dx = numpy.zeros(len(x)) 
     1101        y = np.ones(len(x)) 
     1102        dy = np.zeros(len(x)) 
     1103        dx = np.zeros(len(x)) 
    11041104        self.data = Data1D(x=x, y=y) 
    11051105        self.data.dx = dx 
     
    11711171        state = None 
    11721172 
    1173         numpy.nan_to_num(image) 
     1173        np.nan_to_num(image) 
    11741174        new_plot = Data2D(image=image, err_image=data.err_data) 
    11751175        new_plot.name = model.name + '2d' 
     
    16401640            for key in sld_list.keys(): 
    16411641                if ctr_list[0] == key: 
    1642                     min_val = numpy.min(sld_list[key]) 
    1643                     max_val = numpy.max(sld_list[key]) 
    1644                     mean_val = numpy.mean(sld_list[key]) 
     1642                    min_val = np.min(sld_list[key]) 
     1643                    max_val = np.max(sld_list[key]) 
     1644                    mean_val = np.mean(sld_list[key]) 
    16451645                    enable = (min_val == max_val) and \ 
    16461646                             sld_data.pix_type == 'pixel' 
     
    17331733                    npts = -1 
    17341734                    break 
    1735                 if numpy.isfinite(n_val): 
     1735                if np.isfinite(n_val): 
    17361736                    npts *= int(n_val) 
    17371737            if npts > 0: 
     
    17701770                        ctl.Refresh() 
    17711771                        return 
    1772                     if numpy.isfinite(s_val): 
     1772                    if np.isfinite(s_val): 
    17731773                        s_size *= s_val 
    17741774                self.sld_data.set_pixel_volumes(s_size) 
     
    17871787        try: 
    17881788            sld_data = self.parent.get_sld_from_omf() 
    1789             #nop = (nop * numpy.pi) / 6 
     1789            #nop = (nop * np.pi) / 6 
    17901790            nop = len(sld_data.sld_n) 
    17911791        except: 
  • src/sas/sasgui/perspectives/fitting/basepage.py

    rb301db9 r9a5097c  
    55import os 
    66import wx 
    7 import numpy 
     7import numpy as np 
    88import time 
    99import copy 
     
    100100        self.graph_id = None 
    101101        # Q range for data set 
    102         self.qmin_data_set = numpy.inf 
     102        self.qmin_data_set = np.inf 
    103103        self.qmax_data_set = None 
    104104        self.npts_data_set = 0 
     
    278278 
    279279        """ 
    280         x = numpy.linspace(start=self.qmin_x, stop=self.qmax_x, 
     280        x = np.linspace(start=self.qmin_x, stop=self.qmax_x, 
    281281                           num=self.npts_x, endpoint=True) 
    282282        self.data = Data1D(x=x) 
     
    295295        """ 
    296296        if self.qmin_x >= 1.e-10: 
    297             qmin = numpy.log10(self.qmin_x) 
     297            qmin = np.log10(self.qmin_x) 
    298298        else: 
    299299            qmin = -10. 
    300300 
    301301        if self.qmax_x <= 1.e10: 
    302             qmax = numpy.log10(self.qmax_x) 
     302            qmax = np.log10(self.qmax_x) 
    303303        else: 
    304304            qmax = 10. 
    305305 
    306         x = numpy.logspace(start=qmin, stop=qmax, 
     306        x = np.logspace(start=qmin, stop=qmax, 
    307307                           num=self.npts_x, endpoint=True, base=10.0) 
    308308        self.data = Data1D(x=x) 
     
    341341        qstep = self.npts_x 
    342342 
    343         x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
    344         y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True) 
     343        x = np.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) 
     344        y = np.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True) 
    345345        # use data info instead 
    346         new_x = numpy.tile(x, (len(y), 1)) 
    347         new_y = numpy.tile(y, (len(x), 1)) 
     346        new_x = np.tile(x, (len(y), 1)) 
     347        new_y = np.tile(y, (len(x), 1)) 
    348348        new_y = new_y.swapaxes(0, 1) 
    349349        # all data reuire now in 1d array 
    350350        qx_data = new_x.flatten() 
    351351        qy_data = new_y.flatten() 
    352         q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     352        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    353353        # set all True (standing for unmasked) as default 
    354         mask = numpy.ones(len(qx_data), dtype=bool) 
     354        mask = np.ones(len(qx_data), dtype=bool) 
    355355        # store x and y bin centers in q space 
    356356        x_bins = x 
     
    358358 
    359359        self.data.source = Source() 
    360         self.data.data = numpy.ones(len(mask)) 
    361         self.data.err_data = numpy.ones(len(mask)) 
     360        self.data.data = np.ones(len(mask)) 
     361        self.data.err_data = np.ones(len(mask)) 
    362362        self.data.qx_data = qx_data 
    363363        self.data.qy_data = qy_data 
     
    783783                    # Skip non-data lines 
    784784                    logging.error(traceback.format_exc()) 
    785             return numpy.array(angles), numpy.array(weights) 
     785            return np.array(angles), np.array(weights) 
    786786        except: 
    787787            raise 
     
    21202120        for data in self.data_list: 
    21212121            # q value from qx and qy 
    2122             radius = numpy.sqrt(data.qx_data * data.qx_data + 
     2122            radius = np.sqrt(data.qx_data * data.qx_data + 
    21232123                                data.qy_data * data.qy_data) 
    21242124            # get unmasked index 
     
    21262126                         (radius <= float(self.qmax.GetValue())) 
    21272127            index_data = (index_data) & (data.mask) 
    2128             index_data = (index_data) & (numpy.isfinite(data.data)) 
     2128            index_data = (index_data) & (np.isfinite(data.data)) 
    21292129 
    21302130            if len(index_data[index_data]) < 10: 
     
    21612161            index_data = (float(self.qmin.GetValue()) <= radius) & \ 
    21622162                         (radius <= float(self.qmax.GetValue())) 
    2163             index_data = (index_data) & (numpy.isfinite(data.y)) 
     2163            index_data = (index_data) & (np.isfinite(data.y)) 
    21642164 
    21652165            if len(index_data[index_data]) < 5: 
     
    22332233 
    22342234                # Check that min is less than max 
    2235                 low = -numpy.inf if min_str == "" else float(min_str) 
    2236                 high = numpy.inf if max_str == "" else float(max_str) 
     2235                low = -np.inf if min_str == "" else float(min_str) 
     2236                high = np.inf if max_str == "" else float(max_str) 
    22372237                if high < low: 
    22382238                    min_ctrl.SetBackgroundColour("pink") 
     
    26542654            self.qmin_x = data_min 
    26552655            self.qmax_x = math.sqrt(x * x + y * y) 
    2656             # self.data.mask = numpy.ones(len(self.data.data),dtype=bool) 
     2656            # self.data.mask = np.ones(len(self.data.data),dtype=bool) 
    26572657            # check smearing 
    26582658            if not self.disable_smearer.GetValue(): 
     
    33663366 
    33673367            if value[1] == 'array': 
    3368                 pd_vals = numpy.array(value[2]) 
    3369                 pd_weights = numpy.array(value[3]) 
     3368                pd_vals = np.array(value[2]) 
     3369                pd_weights = np.array(value[3]) 
    33703370                if len(pd_vals) == 0 or len(pd_vals) != len(pd_weights): 
    33713371                    msg = ("bad array distribution parameters for %s" 
  • src/sas/sasgui/perspectives/fitting/fitpage.py

    rd85f1d8a r9a5097c  
    66import wx 
    77import wx.lib.newevent 
    8 import numpy 
     8import numpy as np 
    99import copy 
    1010import math 
     
    11151115            if item.GetValue(): 
    11161116                if button_list.index(item) == 0: 
    1117                     flag = 0  # dy = numpy.ones_like(dy_data) 
     1117                    flag = 0  # dy = np.ones_like(dy_data) 
    11181118                elif button_list.index(item) == 1: 
    11191119                    flag = 1  # dy = dy_data 
    11201120                elif button_list.index(item) == 2: 
    1121                     flag = 2  # dy = numpy.sqrt(numpy.abs(data)) 
     1121                    flag = 2  # dy = np.sqrt(np.abs(data)) 
    11221122                elif button_list.index(item) == 3: 
    1123                     flag = 3  # dy = numpy.abs(data) 
     1123                    flag = 3  # dy = np.abs(data) 
    11241124                break 
    11251125        return flag 
     
    14221422        key = event.GetKeyCode() 
    14231423        length = len(self.data.x) 
    1424         indx = (numpy.abs(self.data.x - x_data)).argmin() 
     1424        indx = (np.abs(self.data.x - x_data)).argmin() 
    14251425        # return array.flat[idx] 
    14261426        if key == wx.WXK_PAGEUP or key == wx.WXK_NUMPAD_PAGEUP: 
     
    14771477                    self.enable2D: 
    14781478                # set mask 
    1479                 radius = numpy.sqrt(self.data.qx_data * self.data.qx_data + 
     1479                radius = np.sqrt(self.data.qx_data * self.data.qx_data + 
    14801480                                    self.data.qy_data * self.data.qy_data) 
    14811481                index_data = ((self.qmin_x <= radius) & (radius <= self.qmax_x)) 
    14821482                index_data = (index_data) & (self.data.mask) 
    1483                 index_data = (index_data) & (numpy.isfinite(self.data.data)) 
     1483                index_data = (index_data) & (np.isfinite(self.data.data)) 
    14841484                if len(index_data[index_data]) < 10: 
    14851485                    msg = "Cannot Plot :No or too little npts in" 
     
    15981598                and data.dqx_data.any() != 0: 
    15991599                self.smear_type = "Pinhole2d" 
    1600                 self.dq_l = format_number(numpy.average(data.dqx_data)) 
    1601                 self.dq_r = format_number(numpy.average(data.dqy_data)) 
     1600                self.dq_l = format_number(np.average(data.dqx_data)) 
     1601                self.dq_r = format_number(np.average(data.dqy_data)) 
    16021602                return 
    16031603            else: 
    16041604                return 
    16051605        # check if it is pinhole smear and get min max if it is. 
    1606         if data.dx is not None and numpy.any(data.dx): 
     1606        if data.dx is not None and np.any(data.dx): 
    16071607            self.smear_type = "Pinhole" 
    16081608            self.dq_l = data.dx[0] 
     
    16121612        elif data.dxl is not None or data.dxw is not None: 
    16131613            self.smear_type = "Slit" 
    1614             if data.dxl is not None and numpy.all(data.dxl, 0): 
     1614            if data.dxl is not None and np.all(data.dxl, 0): 
    16151615                self.dq_l = data.dxl[0] 
    1616             if data.dxw is not None and numpy.all(data.dxw, 0): 
     1616            if data.dxw is not None and np.all(data.dxw, 0): 
    16171617                self.dq_r = data.dxw[0] 
    16181618        # return self.smear_type,self.dq_l,self.dq_r 
     
    19211921                self.default_mask = copy.deepcopy(self.data.mask) 
    19221922                if self.data.err_data is not None \ 
    1923                         and numpy.any(self.data.err_data): 
     1923                        and np.any(self.data.err_data): 
    19241924                    di_flag = True 
    19251925                if self.data.dqx_data is not None \ 
    1926                         and numpy.any(self.data.dqx_data): 
     1926                        and np.any(self.data.dqx_data): 
    19271927                    dq_flag = True 
    19281928            else: 
    19291929                self.slit_smearer.Enable(True) 
    19301930                self.pinhole_smearer.Enable(True) 
    1931                 if self.data.dy is not None and numpy.any(self.data.dy): 
     1931                if self.data.dy is not None and np.any(self.data.dy): 
    19321932                    di_flag = True 
    1933                 if self.data.dx is not None and numpy.any(self.data.dx): 
     1933                if self.data.dx is not None and np.any(self.data.dx): 
    19341934                    dq_flag = True 
    1935                 elif self.data.dxl is not None and numpy.any(self.data.dxl): 
     1935                elif self.data.dxl is not None and np.any(self.data.dxl): 
    19361936                    dq_flag = True 
    19371937 
     
    20672067        if self.data.__class__.__name__ == "Data2D" or \ 
    20682068                        self.enable2D: 
    2069             radius = numpy.sqrt(self.data.qx_data * self.data.qx_data + 
     2069            radius = np.sqrt(self.data.qx_data * self.data.qx_data + 
    20702070                                self.data.qy_data * self.data.qy_data) 
    20712071            index_data = (self.qmin_x <= radius) & (radius <= self.qmax_x) 
    20722072            index_data = (index_data) & (self.data.mask) 
    2073             index_data = (index_data) & (numpy.isfinite(self.data.data)) 
     2073            index_data = (index_data) & (np.isfinite(self.data.data)) 
    20742074            npts2fit = len(self.data.data[index_data]) 
    20752075        else: 
     
    21042104        # make sure stop button to fit button all the time 
    21052105        self._on_fit_complete() 
    2106         if out is None or not numpy.isfinite(chisqr): 
     2106        if out is None or not np.isfinite(chisqr): 
    21072107            raise ValueError, "Fit error occured..." 
    21082108 
     
    21152115 
    21162116        # Check if chi2 is finite 
    2117         if chisqr is not None and numpy.isfinite(chisqr): 
     2117        if chisqr is not None and np.isfinite(chisqr): 
    21182118            # format chi2 
    21192119            chi2 = format_number(chisqr, True) 
     
    21672167 
    21682168                        if cov[ind] is not None: 
    2169                             if numpy.isfinite(float(cov[ind])): 
     2169                            if np.isfinite(float(cov[ind])): 
    21702170                                val_err = format_number(cov[ind], True) 
    21712171                                item[4].SetForegroundColour(wx.BLACK) 
     
    22912291            self.smear_type = 'Pinhole2d' 
    22922292            len_data = len(data.data) 
    2293             data.dqx_data = numpy.zeros(len_data) 
    2294             data.dqy_data = numpy.zeros(len_data) 
     2293            data.dqx_data = np.zeros(len_data) 
     2294            data.dqy_data = np.zeros(len_data) 
    22952295        else: 
    22962296            self.smear_type = 'Pinhole' 
    22972297            len_data = len(data.x) 
    2298             data.dx = numpy.zeros(len_data) 
     2298            data.dx = np.zeros(len_data) 
    22992299            data.dxl = None 
    23002300            data.dxw = None 
     
    24692469        try: 
    24702470            self.dxl = float(self.smear_slit_height.GetValue()) 
    2471             data.dxl = self.dxl * numpy.ones(data_len) 
     2471            data.dxl = self.dxl * np.ones(data_len) 
    24722472            self.smear_slit_height.SetBackgroundColour(wx.WHITE) 
    24732473        except: 
    24742474            self.dxl = None 
    2475             data.dxl = numpy.zeros(data_len) 
     2475            data.dxl = np.zeros(data_len) 
    24762476            if self.smear_slit_height.GetValue().lstrip().rstrip() != "": 
    24772477                self.smear_slit_height.SetBackgroundColour("pink") 
     
    24822482            self.dxw = float(self.smear_slit_width.GetValue()) 
    24832483            self.smear_slit_width.SetBackgroundColour(wx.WHITE) 
    2484             data.dxw = self.dxw * numpy.ones(data_len) 
     2484            data.dxw = self.dxw * np.ones(data_len) 
    24852485        except: 
    24862486            self.dxw = None 
    2487             data.dxw = numpy.zeros(data_len) 
     2487            data.dxw = np.zeros(data_len) 
    24882488            if self.smear_slit_width.GetValue().lstrip().rstrip() != "": 
    24892489                self.smear_slit_width.SetBackgroundColour("pink") 
     
    26122612            if event is None: 
    26132613                output = "-" 
    2614             elif not numpy.isfinite(event.output): 
     2614            elif not np.isfinite(event.output): 
    26152615                output = "-" 
    26162616            else: 
  • src/sas/sasgui/perspectives/fitting/fitting.py

    rddbac66 r9a5097c  
    1616import wx 
    1717import logging 
    18 import numpy 
     18import numpy as np 
    1919import time 
    2020from copy import deepcopy 
     
    13321332                    new_theory = copy_data.data 
    13331333                    new_theory[res.index] = res.theory 
    1334                     new_theory[res.index == False] = numpy.nan 
     1334                    new_theory[res.index == False] = np.nan 
    13351335                    correct_result = True 
    13361336                #get all fittable parameters of the current model 
     
    13411341                        param_list.remove(param) 
    13421342                if not correct_result or res.fitness is None or \ 
    1343                     not numpy.isfinite(res.fitness) or \ 
    1344                     numpy.any(res.pvec == None) or not \ 
    1345                     numpy.all(numpy.isfinite(res.pvec)): 
     1343                    not np.isfinite(res.fitness) or \ 
     1344                        np.any(res.pvec == None) or not \ 
     1345                        np.all(np.isfinite(res.pvec)): 
    13461346                    data_name = str(None) 
    13471347                    if data is not None: 
     
    13521352                    msg += "Data %s and Model %s did not fit.\n" % (data_name, 
    13531353                                                                    model_name) 
    1354                     ERROR = numpy.NAN 
     1354                    ERROR = np.NAN 
    13551355                    cell = BatchCell() 
    13561356                    cell.label = res.fitness 
     
    13661366                            batch_inputs["error on %s" % str(param)].append(ERROR) 
    13671367                else: 
    1368                     # TODO: Why sometimes res.pvec comes with numpy.float64? 
     1368                    # TODO: Why sometimes res.pvec comes with np.float64? 
    13691369                    # probably from scipy lmfit 
    1370                     if res.pvec.__class__ == numpy.float64: 
     1370                    if res.pvec.__class__ == np.float64: 
    13711371                        res.pvec = [res.pvec] 
    13721372 
     
    15331533                fit_msg = res.mesg 
    15341534                if res.fitness is None or \ 
    1535                     not numpy.isfinite(res.fitness) or \ 
    1536                     numpy.any(res.pvec == None) or \ 
    1537                     not numpy.all(numpy.isfinite(res.pvec)): 
     1535                    not np.isfinite(res.fitness) or \ 
     1536                        np.any(res.pvec == None) or \ 
     1537                    not np.all(np.isfinite(res.pvec)): 
    15381538                    fit_msg += "\nFitting did not converge!!!" 
    15391539                    wx.CallAfter(self._update_fit_button, page_id) 
    15401540                else: 
    15411541                    #set the panel when fit result are float not list 
    1542                     if res.pvec.__class__ == numpy.float64: 
     1542                    if res.pvec.__class__ == np.float64: 
    15431543                        pvec = [res.pvec] 
    15441544                    else: 
    15451545                        pvec = res.pvec 
    1546                     if res.stderr.__class__ == numpy.float64: 
     1546                    if res.stderr.__class__ == np.float64: 
    15471547                        stderr = [res.stderr] 
    15481548                    else: 
     
    16921692        if dy is None: 
    16931693            new_plot.is_data = False 
    1694             new_plot.dy = numpy.zeros(len(y)) 
     1694            new_plot.dy = np.zeros(len(y)) 
    16951695            # If this is a theory curve, pick the proper symbol to make it a curve 
    16961696            new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM 
     
    17411741        """ 
    17421742        try: 
    1743             numpy.nan_to_num(y) 
     1743            np.nan_to_num(y) 
    17441744            new_plot = self.create_theory_1D(x, y, page_id, model, data, state, 
    17451745                                             data_description=model.name, 
     
    18261826        that can be plot. 
    18271827        """ 
    1828         numpy.nan_to_num(image) 
     1828        np.nan_to_num(image) 
    18291829        new_plot = Data2D(image=image, err_image=data.err_data) 
    18301830        new_plot.name = model.name + '2d' 
     
    20182018        if data_copy.__class__.__name__ == "Data2D": 
    20192019            if index == None: 
    2020                 index = numpy.ones(len(data_copy.data), dtype=bool) 
     2020                index = np.ones(len(data_copy.data), dtype=bool) 
    20212021            if weight != None: 
    20222022                data_copy.err_data = weight 
    20232023            # get rid of zero error points 
    20242024            index = index & (data_copy.err_data != 0) 
    2025             index = index & (numpy.isfinite(data_copy.data)) 
     2025            index = index & (np.isfinite(data_copy.data)) 
    20262026            fn = data_copy.data[index] 
    20272027            theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id) 
     
    20332033            # 1 d theory from model_thread is only in the range of index 
    20342034            if index == None: 
    2035                 index = numpy.ones(len(data_copy.y), dtype=bool) 
     2035                index = np.ones(len(data_copy.y), dtype=bool) 
    20362036            if weight != None: 
    20372037                data_copy.dy = weight 
    20382038            if data_copy.dy == None or data_copy.dy == []: 
    2039                 dy = numpy.ones(len(data_copy.y)) 
     2039                dy = np.ones(len(data_copy.y)) 
    20402040            else: 
    20412041                ## Set consistently w/AbstractFitengine: 
     
    20582058            return 
    20592059 
    2060         residuals = res[numpy.isfinite(res)] 
     2060        residuals = res[np.isfinite(res)] 
    20612061        # get chisqr only w/finite 
    2062         chisqr = numpy.average(residuals * residuals) 
     2062        chisqr = np.average(residuals * residuals) 
    20632063 
    20642064        self._plot_residuals(page_id=page_id, data=data_copy, 
     
    20972097            residuals.qy_data = data_copy.qy_data 
    20982098            residuals.q_data = data_copy.q_data 
    2099             residuals.err_data = numpy.ones(len(residuals.data)) 
     2099            residuals.err_data = np.ones(len(residuals.data)) 
    21002100            residuals.xmin = min(residuals.qx_data) 
    21012101            residuals.xmax = max(residuals.qx_data) 
     
    21112111            # 1 d theory from model_thread is only in the range of index 
    21122112            if data_copy.dy == None or data_copy.dy == []: 
    2113                 dy = numpy.ones(len(data_copy.y)) 
     2113                dy = np.ones(len(data_copy.y)) 
    21142114            else: 
    21152115                if weight == None: 
    2116                     dy = numpy.ones(len(data_copy.y)) 
     2116                    dy = np.ones(len(data_copy.y)) 
    21172117                ## Set consitently w/AbstractFitengine: 
    21182118                ## But this should be corrected later. 
     
    21332133                residuals.y = (fn - gn[index]) / en 
    21342134            residuals.x = data_copy.x[index] 
    2135             residuals.dy = numpy.ones(len(residuals.y)) 
     2135            residuals.dy = np.ones(len(residuals.y)) 
    21362136            residuals.dx = None 
    21372137            residuals.dxl = None 
  • src/sas/sasgui/perspectives/fitting/model_thread.py

    rc1c9929 r9a5097c  
    44 
    55import time 
    6 import numpy 
     6import numpy as np 
    77import math 
    88from sas.sascalc.data_util.calcthread import CalcThread 
     
    6868 
    6969        # Define matrix where data will be plotted 
    70         radius = numpy.sqrt((self.data.qx_data * self.data.qx_data) + \ 
     70        radius = np.sqrt((self.data.qx_data * self.data.qx_data) + \ 
    7171                    (self.data.qy_data * self.data.qy_data)) 
    7272 
     
    7575        index_model = (self.qmin <= radius) & (radius <= self.qmax) 
    7676        index_model = index_model & self.data.mask 
    77         index_model = index_model & numpy.isfinite(self.data.data) 
     77        index_model = index_model & np.isfinite(self.data.data) 
    7878 
    7979        if self.smearer is not None: 
     
    9191                self.data.qy_data[index_model] 
    9292            ]) 
    93         output = numpy.zeros(len(self.data.qx_data)) 
     93        output = np.zeros(len(self.data.qx_data)) 
    9494        # output default is None 
    9595        # This method is to distinguish between masked 
     
    163163        """ 
    164164        self.starttime = time.time() 
    165         output = numpy.zeros((len(self.data.x))) 
     165        output = np.zeros((len(self.data.x))) 
    166166        index = (self.qmin <= self.data.x) & (self.data.x <= self.qmax) 
    167167 
     
    175175                                                             self.qmax) 
    176176            mask = self.data.x[first_bin:last_bin+1] 
    177             unsmeared_output = numpy.zeros((len(self.data.x))) 
     177            unsmeared_output = np.zeros((len(self.data.x))) 
    178178            unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask) 
    179179            self.smearer.model = self.model 
     
    183183            # Check that the arrays are compatible. If we only have a model but no data, 
    184184            # the length of data.y will be zero. 
    185             if isinstance(self.data.y, numpy.ndarray) and output.shape == self.data.y.shape: 
    186                 unsmeared_data = numpy.zeros((len(self.data.x))) 
    187                 unsmeared_error = numpy.zeros((len(self.data.x))) 
     185            if isinstance(self.data.y, np.ndarray) and output.shape == self.data.y.shape: 
     186                unsmeared_data = np.zeros((len(self.data.x))) 
     187                unsmeared_error = np.zeros((len(self.data.x))) 
    188188                unsmeared_data[first_bin:last_bin+1] = self.data.y[first_bin:last_bin+1]\ 
    189189                                                        * unsmeared_output[first_bin:last_bin+1]\ 
     
    209209 
    210210        if p_model is not None and s_model is not None: 
    211             sq_values = numpy.zeros((len(self.data.x))) 
    212             pq_values = numpy.zeros((len(self.data.x))) 
     211            sq_values = np.zeros((len(self.data.x))) 
     212            pq_values = np.zeros((len(self.data.x))) 
    213213            sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
    214214            pq_values[index] = p_model.evalDistribution(self.data.x[index]) 
  • src/sas/sasgui/perspectives/fitting/pagestate.py

    rd5aff7f r9a5097c  
    1818import copy 
    1919import logging 
    20 import numpy 
     20import numpy as np 
    2121import traceback 
    2222 
     
    410410        for fittable, name, value, _, uncert, lower, upper, units in params: 
    411411            if not value: 
    412                 value = numpy.nan 
     412                value = np.nan 
    413413            if not uncert or uncert[1] == '' or uncert[1] == 'None': 
    414414                uncert[0] = False 
    415                 uncert[1] = numpy.nan 
     415                uncert[1] = np.nan 
    416416            if not upper or upper[1] == '' or upper[1] == 'None': 
    417417                upper[0] = False 
    418                 upper[1] = numpy.nan 
     418                upper[1] = np.nan 
    419419            if not lower or lower[1] == '' or lower[1] == 'None': 
    420420                lower[0] = False 
    421                 lower[1] = numpy.nan 
     421                lower[1] = np.nan 
    422422            if is_string: 
    423423                p[name] = str(value) 
     
    449449                lower = params.get(name + ".lower", '-inf') 
    450450                units = params.get(name + ".units") 
    451                 if std is not None and std is not numpy.nan: 
     451                if std is not None and std is not np.nan: 
    452452                    std = [True, str(std)] 
    453453                else: 
    454454                    std = [False, ''] 
    455                 if lower is not None and lower is not numpy.nan: 
     455                if lower is not None and lower is not np.nan: 
    456456                    lower = [True, str(lower)] 
    457457                else: 
    458458                    lower = [True, '-inf'] 
    459                 if upper is not None and upper is not numpy.nan: 
     459                if upper is not None and upper is not np.nan: 
    460460                    upper = [True, str(upper)] 
    461461                else: 
     
    11001100                                       % (line, tagname, name)) 
    11011101                                logging.error(msg + traceback.format_exc()) 
    1102                         dic[name] = numpy.array(value_list) 
     1102                        dic[name] = np.array(value_list) 
    11031103                    setattr(self, varname, dic) 
    11041104 
  • src/sas/sasgui/perspectives/fitting/utils.py

    rd85c194 r9a5097c  
    22Module contains functions frequently used in this package 
    33""" 
    4 import numpy 
     4import numpy as np 
    55 
    66 
     
    1919        data = data.y 
    2020    if flag == 0: 
    21         weight = numpy.ones_like(data) 
     21        weight = np.ones_like(data) 
    2222    elif flag == 1: 
    2323        weight = dy_data 
    2424    elif flag == 2: 
    25         weight = numpy.sqrt(numpy.abs(data)) 
     25        weight = np.sqrt(np.abs(data)) 
    2626    elif flag == 3: 
    27         weight = numpy.abs(data) 
     27        weight = np.abs(data) 
    2828    return weight 
  • src/sas/sasgui/perspectives/pr/explore_dialog.py

    rd85c194 r9a5097c  
    1919 
    2020import wx 
    21 import numpy 
     21import numpy as np 
    2222import logging 
    2323import sys 
     
    6565 
    6666        step = (self.max - self.min) / (self.npts - 1) 
    67         self.x = numpy.arange(self.min, self.max + step * 0.01, step) 
    68         dx = numpy.zeros(len(self.x)) 
    69         y = numpy.ones(len(self.x)) 
    70         dy = numpy.zeros(len(self.x)) 
     67        self.x = np.arange(self.min, self.max + step * 0.01, step) 
     68        dx = np.zeros(len(self.x)) 
     69        y = np.ones(len(self.x)) 
     70        dy = np.zeros(len(self.x)) 
    7171 
    7272        # Plot area 
  • src/sas/sasgui/perspectives/pr/pr.py

    ra69a967 r9a5097c  
    2121import time 
    2222import math 
    23 import numpy 
     23import numpy as np 
    2424import pylab 
    2525from sas.sasgui.guiframe.gui_manager import MDIFrame 
     
    207207        r = pylab.arange(0.01, d_max, d_max / 51.0) 
    208208        M = len(r) 
    209         y = numpy.zeros(M) 
    210         pr_err = numpy.zeros(M) 
     209        y = np.zeros(M) 
     210        pr_err = np.zeros(M) 
    211211 
    212212        total = 0.0 
     
    253253        """ 
    254254        # Show P(r) 
    255         y_true = numpy.zeros(len(x)) 
     255        y_true = np.zeros(len(x)) 
    256256 
    257257        sum_true = 0.0 
     
    307307 
    308308        x = pylab.arange(minq, maxq, maxq / 301.0) 
    309         y = numpy.zeros(len(x)) 
    310         err = numpy.zeros(len(x)) 
     309        y = np.zeros(len(x)) 
     310        err = np.zeros(len(x)) 
    311311        for i in range(len(x)): 
    312312            value = pr.iq(out, x[i]) 
     
    337337        if pr.slit_width > 0 or pr.slit_height > 0: 
    338338            x = pylab.arange(minq, maxq, maxq / 301.0) 
    339             y = numpy.zeros(len(x)) 
    340             err = numpy.zeros(len(x)) 
     339            y = np.zeros(len(x)) 
     340            err = np.zeros(len(x)) 
    341341            for i in range(len(x)): 
    342342                value = pr.iq_smeared(out, x[i]) 
     
    382382        x = pylab.arange(0.0, pr.d_max, pr.d_max / self._pr_npts) 
    383383 
    384         y = numpy.zeros(len(x)) 
    385         dy = numpy.zeros(len(x)) 
    386         y_true = numpy.zeros(len(x)) 
     384        y = np.zeros(len(x)) 
     385        dy = np.zeros(len(x)) 
     386        y_true = np.zeros(len(x)) 
    387387 
    388388        total = 0.0 
    389389        pmax = 0.0 
    390         cov2 = numpy.ascontiguousarray(cov) 
     390        cov2 = np.ascontiguousarray(cov) 
    391391 
    392392        for i in range(len(x)): 
     
    480480        """ 
    481481        # Read the data from the data file 
    482         data_x = numpy.zeros(0) 
    483         data_y = numpy.zeros(0) 
    484         data_err = numpy.zeros(0) 
     482        data_x = np.zeros(0) 
     483        data_y = np.zeros(0) 
     484        data_err = np.zeros(0) 
    485485        scale = None 
    486486        min_err = 0.0 
     
    504504                        #err = 0 
    505505 
    506                     data_x = numpy.append(data_x, x) 
    507                     data_y = numpy.append(data_y, y) 
    508                     data_err = numpy.append(data_err, err) 
     506                    data_x = np.append(data_x, x) 
     507                    data_y = np.append(data_y, y) 
     508                    data_err = np.append(data_err, err) 
    509509                except: 
    510510                    logging.error(sys.exc_value) 
     
    528528        """ 
    529529        # Read the data from the data file 
    530         data_x = numpy.zeros(0) 
    531         data_y = numpy.zeros(0) 
    532         data_err = numpy.zeros(0) 
     530        data_x = np.zeros(0) 
     531        data_y = np.zeros(0) 
     532        data_err = np.zeros(0) 
    533533        scale = None 
    534534        min_err = 0.0 
     
    555555                            #err = 0 
    556556 
    557                         data_x = numpy.append(data_x, x) 
    558                         data_y = numpy.append(data_y, y) 
    559                         data_err = numpy.append(data_err, err) 
     557                        data_x = np.append(data_x, x) 
     558                        data_y = np.append(data_y, y) 
     559                        data_err = np.append(data_err, err) 
    560560                    except: 
    561561                        logging.error(sys.exc_value) 
     
    640640        # Now replot the original added data 
    641641        for plot in self._added_plots: 
    642             self._added_plots[plot].y = numpy.copy(self._default_Iq[plot]) 
     642            self._added_plots[plot].y = np.copy(self._default_Iq[plot]) 
    643643            wx.PostEvent(self.parent, 
    644644                         NewPlotEvent(plot=self._added_plots[plot], 
     
    664664        # Now scale the added plots too 
    665665        for plot in self._added_plots: 
    666             total = numpy.sum(self._added_plots[plot].y) 
     666            total = np.sum(self._added_plots[plot].y) 
    667667            npts = len(self._added_plots[plot].x) 
    668668            total *= self._added_plots[plot].x[npts - 1] / npts 
     
    814814        # Save Pr invertor 
    815815        self.pr = pr 
    816         cov = numpy.ascontiguousarray(cov) 
     816        cov = np.ascontiguousarray(cov) 
    817817 
    818818        # Show result on control panel 
     
    982982        all_zeros = True 
    983983        if err == None: 
    984             err = numpy.zeros(len(pr.y)) 
     984            err = np.zeros(len(pr.y)) 
    985985        else: 
    986986            for i in range(len(err)): 
     
    10881088        # If we have not errors, add statistical errors 
    10891089        if y is not None: 
    1090             if err == None or numpy.all(err) == 0: 
    1091                 err = numpy.zeros(len(y)) 
     1090            if err == None or np.all(err) == 0: 
     1091                err = np.zeros(len(y)) 
    10921092                scale = None 
    10931093                min_err = 0.0 
  • src/sas/sasgui/perspectives/simulation/simulation.py

    rd85c194 r9a5097c  
    1010import wx 
    1111import os 
    12 import numpy 
     12import numpy as np 
    1313import time 
    1414import logging 
     
    4646    def compute(self): 
    4747        x = self.x 
    48         output = numpy.zeros(len(x)) 
    49         error = numpy.zeros(len(x)) 
     48        output = np.zeros(len(x)) 
     49        error = np.zeros(len(x)) 
    5050         
    5151        self.starttime = time.time() 
     
    123123        # Q-values for plotting simulated I(Q) 
    124124        step = (self.q_max-self.q_min)/(self.q_npts-1) 
    125         self.x = numpy.arange(self.q_min, self.q_max+step*0.01, step)         
     125        self.x = np.arange(self.q_min, self.q_max+step*0.01, step) 
    126126         
    127127        # Set the list of panels that are part of the simulation perspective 
     
    187187        # Q-values for plotting simulated I(Q) 
    188188        step = (self.q_max-self.q_min)/(self.q_npts-1) 
    189         self.x = numpy.arange(self.q_min, self.q_max+step*0.01, step)     
     189        self.x = np.arange(self.q_min, self.q_max+step*0.01, step) 
    190190          
    191191        # Compute the simulated I(Q) 
  • src/sas/sasgui/plottools/PlotPanel.py

    r198fa76 r9a5097c  
    2929DEFAULT_CMAP = pylab.cm.jet 
    3030import copy 
    31 import numpy 
     31import numpy as np 
    3232 
    3333from sas.sasgui.guiframe.events import StatusEvent 
     
    14521452                if  self.zmin_2D <= 0  and len(output[output > 0]) > 0: 
    14531453                    zmin_temp = self.zmin_2D 
    1454                     output[output > 0] = numpy.log10(output[output > 0]) 
     1454                    output[output > 0] = np.log10(output[output > 0]) 
    14551455                    #In log scale Negative values are not correct in general 
    1456                     #output[output<=0] = math.log(numpy.min(output[output>0])) 
     1456                    #output[output<=0] = math.log(np.min(output[output>0])) 
    14571457                elif self.zmin_2D <= 0: 
    14581458                    zmin_temp = self.zmin_2D 
    1459                     output[output > 0] = numpy.zeros(len(output)) 
     1459                    output[output > 0] = np.zeros(len(output)) 
    14601460                    output[output <= 0] = -32 
    14611461                else: 
    14621462                    zmin_temp = self.zmin_2D 
    1463                     output[output > 0] = numpy.log10(output[output > 0]) 
     1463                    output[output > 0] = np.log10(output[output > 0]) 
    14641464                    #In log scale Negative values are not correct in general 
    1465                     #output[output<=0] = math.log(numpy.min(output[output>0])) 
     1465                    #output[output<=0] = math.log(np.min(output[output>0])) 
    14661466            except: 
    14671467                #Too many problems in 2D plot with scale 
     
    14921492            X = self.x_bins[0:-1] 
    14931493            Y = self.y_bins[0:-1] 
    1494             X, Y = numpy.meshgrid(X, Y) 
     1494            X, Y = np.meshgrid(X, Y) 
    14951495 
    14961496            try: 
     
    15551555        # 1d array to use for weighting the data point averaging 
    15561556        #when they fall into a same bin. 
    1557         weights_data = numpy.ones([self.data.size]) 
     1557        weights_data = np.ones([self.data.size]) 
    15581558        # get histogram of ones w/len(data); this will provide 
    15591559        #the weights of data on each bins 
    1560         weights, xedges, yedges = numpy.histogram2d(x=self.qy_data, 
     1560        weights, xedges, yedges = np.histogram2d(x=self.qy_data, 
    15611561                                                    y=self.qx_data, 
    15621562                                                    bins=[self.y_bins, self.x_bins], 
    15631563                                                    weights=weights_data) 
    15641564        # get histogram of data, all points into a bin in a way of summing 
    1565         image, xedges, yedges = numpy.histogram2d(x=self.qy_data, 
     1565        image, xedges, yedges = np.histogram2d(x=self.qy_data, 
    15661566                                                  y=self.qx_data, 
    15671567                                                  bins=[self.y_bins, self.x_bins], 
     
    15811581        # do while loop until all vacant bins are filled up up 
    15821582        #to loop = max_loop 
    1583         while not(numpy.isfinite(image[weights == 0])).all(): 
     1583        while not(np.isfinite(image[weights == 0])).all(): 
    15841584            if loop >= max_loop:  # this protects never-ending loop 
    15851585                break 
     
    16301630 
    16311631        # store x and y bin centers in q space 
    1632         x_bins = numpy.linspace(xmin, xmax, npix_x) 
    1633         y_bins = numpy.linspace(ymin, ymax, npix_y) 
     1632        x_bins = np.linspace(xmin, xmax, npix_x) 
     1633        y_bins = np.linspace(ymin, ymax, npix_y) 
    16341634 
    16351635        #set x_bins and y_bins 
     
    16501650        """ 
    16511651        # No image matrix given 
    1652         if image == None or numpy.ndim(image) != 2 \ 
    1653                 or numpy.isfinite(image).all() \ 
     1652        if image == None or np.ndim(image) != 2 \ 
     1653                or np.isfinite(image).all() \ 
    16541654                or weights == None: 
    16551655            return image 
     
    16571657        len_y = len(image) 
    16581658        len_x = len(image[1]) 
    1659         temp_image = numpy.zeros([len_y, len_x]) 
    1660         weit = numpy.zeros([len_y, len_x]) 
     1659        temp_image = np.zeros([len_y, len_x]) 
     1660        weit = np.zeros([len_y, len_x]) 
    16611661        # do for-loop for all pixels 
    16621662        for n_y in range(len(image)): 
    16631663            for n_x in range(len(image[1])): 
    16641664                # find only null pixels 
    1665                 if weights[n_y][n_x] > 0 or numpy.isfinite(image[n_y][n_x]): 
     1665                if weights[n_y][n_x] > 0 or np.isfinite(image[n_y][n_x]): 
    16661666                    continue 
    16671667                else: 
    16681668                    # find 4 nearest neighbors 
    16691669                    # check where or not it is at the corner 
    1670                     if n_y != 0 and numpy.isfinite(image[n_y - 1][n_x]): 
     1670                    if n_y != 0 and np.isfinite(image[n_y - 1][n_x]): 
    16711671                        temp_image[n_y][n_x] += image[n_y - 1][n_x] 
    16721672                        weit[n_y][n_x] += 1 
    1673                     if n_x != 0 and numpy.isfinite(image[n_y][n_x - 1]): 
     1673                    if n_x != 0 and np.isfinite(image[n_y][n_x - 1]): 
    16741674                        temp_image[n_y][n_x] += image[n_y][n_x - 1] 
    16751675                        weit[n_y][n_x] += 1 
    1676                     if n_y != len_y - 1 and numpy.isfinite(image[n_y + 1][n_x]): 
     1676                    if n_y != len_y - 1 and np.isfinite(image[n_y + 1][n_x]): 
    16771677                        temp_image[n_y][n_x] += image[n_y + 1][n_x] 
    16781678                        weit[n_y][n_x] += 1 
    1679                     if n_x != len_x - 1 and numpy.isfinite(image[n_y][n_x + 1]): 
     1679                    if n_x != len_x - 1 and np.isfinite(image[n_y][n_x + 1]): 
    16801680                        temp_image[n_y][n_x] += image[n_y][n_x + 1] 
    16811681                        weit[n_y][n_x] += 1 
    16821682                    # go 4 next nearest neighbors when no non-zero 
    16831683                    # neighbor exists 
    1684                     if n_y != 0 and n_x != 0 and\ 
    1685                          numpy.isfinite(image[n_y - 1][n_x - 1]): 
     1684                    if n_y != 0 and n_x != 0 and \ 
     1685                            np.isfinite(image[n_y - 1][n_x - 1]): 
    16861686                        temp_image[n_y][n_x] += image[n_y - 1][n_x - 1] 
    16871687                        weit[n_y][n_x] += 1 
    16881688                    if n_y != len_y - 1 and n_x != 0 and \ 
    1689                         numpy.isfinite(image[n_y + 1][n_x - 1]): 
     1689                            np.isfinite(image[n_y + 1][n_x - 1]): 
    16901690                        temp_image[n_y][n_x] += image[n_y + 1][n_x - 1] 
    16911691                        weit[n_y][n_x] += 1 
    16921692                    if n_y != len_y and n_x != len_x - 1 and \ 
    1693                         numpy.isfinite(image[n_y - 1][n_x + 1]): 
     1693                            np.isfinite(image[n_y - 1][n_x + 1]): 
    16941694                        temp_image[n_y][n_x] += image[n_y - 1][n_x + 1] 
    16951695                        weit[n_y][n_x] += 1 
    16961696                    if n_y != len_y - 1 and n_x != len_x - 1 and \ 
    1697                         numpy.isfinite(image[n_y + 1][n_x + 1]): 
     1697                            np.isfinite(image[n_y + 1][n_x + 1]): 
    16981698                        temp_image[n_y][n_x] += image[n_y + 1][n_x + 1] 
    16991699                        weit[n_y][n_x] += 1 
  • src/sas/sasgui/plottools/fitDialog.py

    rdd5bf63 r9a5097c  
    22from plottables import Theory1D 
    33import math 
    4 import numpy 
     4import numpy as np 
    55import fittings 
    66import transform 
     
    482482 
    483483                if self.xLabel.lower() == "log10(x)": 
    484                     tempdy = numpy.asarray(tempdy) 
     484                    tempdy = np.asarray(tempdy) 
    485485                    tempdy[tempdy == 0] = 1 
    486486                    chisqr, out, cov = fittings.sasfit(self.model, 
     
    491491                                                       math.log10(xmax)) 
    492492                else: 
    493                     tempdy = numpy.asarray(tempdy) 
     493                    tempdy = np.asarray(tempdy) 
    494494                    tempdy[tempdy == 0] = 1 
    495495                    chisqr, out, cov = fittings.sasfit(self.model, 
     
    572572        if self.rg_on: 
    573573            if self.Rg_tctr.IsShown(): 
    574                 rg = numpy.sqrt(-3 * float(cstA)) 
     574                rg = np.sqrt(-3 * float(cstA)) 
    575575                value = format_number(rg) 
    576576                self.Rg_tctr.SetValue(value) 
    577577                if self.I0_tctr.IsShown(): 
    578                     val = numpy.exp(cstB) 
     578                    val = np.exp(cstB) 
    579579                    self.I0_tctr.SetValue(format_number(val)) 
    580580            if self.Rgerr_tctr.IsShown(): 
     
    585585                self.Rgerr_tctr.SetValue(value) 
    586586                if self.I0err_tctr.IsShown(): 
    587                     val = numpy.abs(numpy.exp(cstB) * errB) 
     587                    val = np.abs(np.exp(cstB) * errB) 
    588588                    self.I0err_tctr.SetValue(format_number(val)) 
    589589            if self.Diameter_tctr.IsShown(): 
    590                 rg = numpy.sqrt(-2 * float(cstA)) 
    591                 _diam = 4 * numpy.sqrt(-float(cstA)) 
     590                rg = np.sqrt(-2 * float(cstA)) 
     591                _diam = 4 * np.sqrt(-float(cstA)) 
    592592                value = format_number(_diam) 
    593593                self.Diameter_tctr.SetValue(value) 
  • src/sas/sasgui/plottools/plottables.py

    ra9f579c r9a5097c  
    4343# Support for ancient python versions 
    4444import copy 
    45 import numpy 
     45import numpy as np 
    4646import sys 
    4747import logging 
     
    706706                self.dy = None 
    707707            if not has_err_x: 
    708                 dx = numpy.zeros(len(x)) 
     708                dx = np.zeros(len(x)) 
    709709            if not has_err_y: 
    710                 dy = numpy.zeros(len(y)) 
     710                dy = np.zeros(len(y)) 
    711711            for i in range(len(x)): 
    712712                try: 
     
    796796        tempdy = [] 
    797797        if self.dx == None: 
    798             self.dx = numpy.zeros(len(self.x)) 
     798            self.dx = np.zeros(len(self.x)) 
    799799        if self.dy == None: 
    800             self.dy = numpy.zeros(len(self.y)) 
     800            self.dy = np.zeros(len(self.y)) 
    801801        if self.xLabel == "log10(x)": 
    802802            for i in range(len(self.x)): 
     
    826826        tempdy = [] 
    827827        if self.dx == None: 
    828             self.dx = numpy.zeros(len(self.x)) 
     828            self.dx = np.zeros(len(self.x)) 
    829829        if self.dy == None: 
    830             self.dy = numpy.zeros(len(self.y)) 
     830            self.dy = np.zeros(len(self.y)) 
    831831        if self.yLabel == "log10(y)": 
    832832            for i in range(len(self.x)): 
     
    859859        tempdy = [] 
    860860        if self.dx == None: 
    861             self.dx = numpy.zeros(len(self.x)) 
     861            self.dx = np.zeros(len(self.x)) 
    862862        if self.dy == None: 
    863             self.dy = numpy.zeros(len(self.y)) 
     863            self.dy = np.zeros(len(self.y)) 
    864864        if xmin != None and xmax != None: 
    865865            for i in range(len(self.x)): 
     
    12281228 
    12291229def sample_graph(): 
    1230     import numpy as nx 
     1230    import numpy as np 
    12311231 
    12321232    # Construct a simple graph 
    12331233    if False: 
    1234         x = nx.array([1, 2, 3, 4, 5, 6], 'd') 
    1235         y = nx.array([4, 5, 6, 5, 4, 5], 'd') 
    1236         dy = nx.array([0.2, 0.3, 0.1, 0.2, 0.9, 0.3]) 
     1234        x = np.array([1, 2, 3, 4, 5, 6], 'd') 
     1235        y = np.array([4, 5, 6, 5, 4, 5], 'd') 
     1236        dy = np.array([0.2, 0.3, 0.1, 0.2, 0.9, 0.3]) 
    12371237    else: 
    1238         x = nx.linspace(0, 1., 10000) 
    1239         y = nx.sin(2 * nx.pi * x * 2.8) 
    1240         dy = nx.sqrt(100 * nx.abs(y)) / 100 
     1238        x = np.linspace(0, 1., 10000) 
     1239        y = np.sin(2 * np.pi * x * 2.8) 
     1240        dy = np.sqrt(100 * np.abs(y)) / 100 
    12411241    data = Data1D(x, y, dy=dy) 
    12421242    data.xaxis('distance', 'm') 
  • test/pr_inversion/test/utest_invertor.py

    rb699768 r9a5097c  
    568568     
    569569def load(path = "sphere_60_q0_2.txt"): 
    570     import numpy, math, sys 
     570    import numpy as np 
     571    import math 
     572    import sys 
    571573    # Read the data from the data file 
    572     data_x   = numpy.zeros(0) 
    573     data_y   = numpy.zeros(0) 
    574     data_err = numpy.zeros(0) 
     574    data_x   = np.zeros(0) 
     575    data_y   = np.zeros(0) 
     576    data_err = np.zeros(0) 
    575577    scale    = None 
    576578    if not path == None: 
     
    589591                        scale = 0.15*math.sqrt(y) 
    590592                    err = scale*math.sqrt(y) 
    591                 data_x = numpy.append(data_x, x) 
    592                 data_y = numpy.append(data_y, y) 
    593                 data_err = numpy.append(data_err, err) 
     593                data_x = np.append(data_x, x) 
     594                data_y = np.append(data_y, y) 
     595                data_err = np.append(data_err, err) 
    594596            except: 
    595597                pass 
  • test/sascalculator/test/utest_sas_gen.py

    ref908db r9a5097c  
    88from sas.sascalc.calculator import sas_gen 
    99 
    10 import numpy 
    11   
    12 import os.path 
    1310 
    1411class sas_gen_test(unittest.TestCase): 
     
    5148        self.assertEqual(output.pos_z[0], 0.0) 
    5249 
     50 
    5351if __name__ == '__main__': 
    5452    unittest.main() 
    55     
     53 
  • test/sasdataloader/plugins/test_reader.py

    rb699768 r9a5097c  
    88copyright 2008, University of Tennessee 
    99""" 
    10 import numpy, os 
     10import os 
     11import numpy as np 
    1112from sas.sascalc.dataloader.data_info import Data1D 
    1213 
     
    4041                buff = input_f.read() 
    4142                lines = buff.split('\n') 
    42                 x  = numpy.zeros(0) 
    43                 y  = numpy.zeros(0) 
    44                 dy = numpy.zeros(0) 
     43                x  = np.zeros(0) 
     44                y  = np.zeros(0) 
     45                dy = np.zeros(0) 
    4546                output = Data1D(x, y, dy=dy) 
    4647                self.filename = output.filename = basename 
    4748            
    4849                for line in lines: 
    49                     x  = numpy.append(x,  float(line))  
     50                    x  = np.append(x,  float(line)) 
    5051                     
    5152                output.x = x 
  • test/sasdataloader/test/utest_abs_reader.py

    r5f26aa4 r9a5097c  
    44 
    55import unittest 
    6 import numpy, math 
     6import numpy as np 
    77from sas.sascalc.dataloader.loader import  Loader 
    88from sas.sascalc.dataloader.data_info import Data1D 
    99  
    10 import os.path 
    1110 
    1211class abs_reader(unittest.TestCase): 
     
    313312        from sas.sascalc.dataloader.readers.cansas_reader import Reader 
    314313        r = Reader() 
    315         x = numpy.ones(5) 
    316         y = numpy.ones(5) 
    317         dy = numpy.ones(5) 
     314        x = np.ones(5) 
     315        y = np.ones(5) 
     316        dy = np.ones(5) 
    318317         
    319318        filename = "write_test.xml" 
  • test/sasdataloader/test/utest_averaging.py

    rb699768 r9a5097c  
    11 
    22import unittest 
     3import math 
    34 
    45from sas.sascalc.dataloader.loader import  Loader 
    56from sas.sascalc.dataloader.manipulations import Ring, CircularAverage, SectorPhi, get_q,reader2D_converter 
    6   
    7 import os.path 
    8 import numpy, math 
     7 
     8import numpy as np 
    99import sas.sascalc.dataloader.data_info as data_info 
    1010 
     
    1818            should return the predefined height of the distribution (1.0). 
    1919        """ 
    20         x_0  = numpy.ones([100,100]) 
    21         dx_0 = numpy.ones([100,100]) 
     20        x_0  = np.ones([100,100]) 
     21        dx_0 = np.ones([100,100]) 
    2222         
    2323        self.data = data_info.Data2D(data=x_0, err_data=dx_0) 
     
    4242         
    4343        self.qstep = len(x_0) 
    44         x=  numpy.linspace(start= -1*self.qmax, 
     44        x=  np.linspace(start= -1*self.qmax, 
    4545                               stop= self.qmax, 
    4646                               num= self.qstep, 
    4747                               endpoint=True )   
    48         y = numpy.linspace(start= -1*self.qmax, 
     48        y = np.linspace(start= -1*self.qmax, 
    4949                               stop= self.qmax, 
    5050                               num= self.qstep, 
  • test/sasdataloader/test/utest_cansas.py

    r1686a333 r9a5097c  
    1515import pylint as pylint 
    1616im