Changeset 3a33740 in sasview


Ignore:
Timestamp:
Apr 4, 2017 4:18:58 PM (3 years ago)
Author:
GitHub <noreply@…>
Parents:
dd11014 (diff), 858a69d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Andrew Nelson <andyfaff@…> (04/04/17 16:18:58)
git-committer:
GitHub <noreply@…> (04/04/17 16:18:58)
Message:

Merge 858a69d6b7e6133a14b52100fcffc4fbf1666fdd into dd11014add466ed4ba0564fcf61e5880d53e6c8b

Files:
2 added
77 edited
1 moved

Legend:

Unmodified
Added
Removed
  • .travis.yml

    red8f27e7 rf28f33d5  
    22 
    33language: python 
    4 python: 
    5   - "2.7" 
     4 
     5# can eventually include OSX here. 
     6matrix: 
     7    include: 
     8        - os: linux 
     9          env: PY=2.7 
     10 
    611# whitelist 
    712branches: 
    813  only: 
    914    - master 
    10 # command to install dependencies 
    11 virtualenv: 
    12   system_site_packages: true 
     15 
     16addons: 
     17    apt: 
     18        packages: 
     19            - opencl-headers 
     20            - fglrx 
     21            - libblas-dev 
     22            - libatlas-dev 
     23            - libatlas-base-dev 
     24            - liblapack-dev 
     25            - gfortran 
     26            - libhdf5-serial-dev 
     27 
    1328before_install: 
    14   - 'if [ $TRAVIS_PYTHON_VERSION == "2.7" ]; then sudo apt-get update;sudo apt-get install python-matplotlib libhdf5-serial-dev python-h5py fglrx opencl-headers python-pyopencl gfortran libblas-dev liblapack-dev libatlas-dev; fi' 
     29    - echo $TRAVIS_OS_NAME 
     30    - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then 
     31          wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh; 
     32      fi 
     33    - bash miniconda.sh -b -p $HOME/miniconda 
     34    - export PATH="$HOME/miniconda/bin:$PATH" 
     35    - hash -r 
     36    - conda update --yes conda 
     37 
     38    # Useful for debugging any issues with conda 
     39    - conda info -a 
     40 
     41    # could install other dependencies, but they're locked to specific 
     42    # versions in build/requirements.txt 
     43    - conda install --yes python=$PY numpy scipy cython pylint wxpython 
     44    - sudo apt-get update; sudo apt-get install python-pyopencl 
    1545 
    1646install: 
    1747  - pip install -r build_tools/requirements.txt 
     48  - pip install matplotlib 
    1849 
    1950before_script: 
     
    2354   
    2455script: 
    25   - export WORKSPACE=/home/travis/build/SasView/ 
    26   - cd $WORKSPACE 
     56  - cd .. 
     57  # this should be the directory above the sasview directory, where we want to 
     58  # clone the sasmodels 
     59  - export WORKSPACE=$(pwd) 
    2760  - git clone --depth=50 --branch=master https://github.com/SasView/sasmodels.git sasmodels 
    28   - export PYTHONPATH=$WORKSPACE/sasview-install:$WORKSPACE/utils:$PYTHONPATH 
    29   - cd $WORKSPACE 
     61 
     62  # required for documentation 
     63  - git clone --depth=50 --branch=master https://github.com/bumps/bumps.git 
     64 
    3065  - ls -ltr 
    3166  - if [ ! -d "utils" ]; then mkdir utils; fi 
    3267  - /bin/sh -xe sasview/build_tools/travis_build.sh 
    33 #  - /bin/sh -xe sasview/build_tools/jenkins_linux_test.sh 
    3468  - export LC_ALL=en_US.UTF-8 
    3569  - export LANG=en_US.UTF-8 
  • build_tools/travis_build.sh

    r68e6ac8 r858a69d  
    1 # Simplified build for Travic CI 
     1# Simplified build for Travis CI 
    22# No documentation is built 
    33export PATH=$PATH:/usr/local/bin/ 
     
    3838cd $WORKSPACE/sasview 
    3939$PYTHON setup.py clean 
    40 $PYTHON setup.py build docs bdist_egg 
     40# $PYTHON setup.py build docs bdist_egg 
     41$PYTHON setup.py bdist_egg 
    4142 
    4243# INSTALL SASVIEW 
  • INSTALL.txt

    rd09f0ae1 r26c9b85  
    22================================ 
    33 
     4Note - at the current time sasview will only run in gui form under Python 2. 
    45 
    5 The build works in the usualy pythonic way: 
     6Before trying to install and run sasview you'll need to check what 
     7dependencies are required: 
     8 
     9$ python check_packages.py 
     10 
     11Many of these are available from PyPi, but some (e.g. h5py) may require more 
     12involvement to build and install. If you use the conda package manager then 
     13many of the pre-built dependencies are available there. This may be the easiest 
     14route if you are on windows. 
     15 
     16The build works in the pythonic way: 
    617 
    718$ python setup.py build      # will build the package underneath 'build/' 
    8 $ python setup.py install    # will install the package 
    9  
     19$ python setup.py install    # will install the package into site-packages 
    1020 
    1121 
     
    1424$ python run.py              # will run the code in place (building the C code once, if required) 
    1525 
     26On OSX or windows you may need to use: 
    1627 
    17  
    18 To check all dependencies are met: 
    19  
    20 $ python deps.py 
    21 $ python check_packages.py  
    22  
    23 Both tell you different parts of the story, unfortunately. 
    24  
     28$ pythonw run.py 
    2529 
    2630 
  • check_packages.py

    r131d94b rf433e6a  
    22Checking and reinstalling the external packages 
    33""" 
    4 import os 
     4from __future__ import print_function 
     5 
    56import sys 
    67 
     
    1415    sys.modules['Image'] = PIL.Image 
    1516 
     17if sys.version_info[0] > 2: 
     18    print("To use the sasview GUI you must use Python 2\n") 
    1619 
    1720common_required_package_list = { 
    18     'setuptools':{'version':'0.6c11','import_name':'setuptools','test':'__version__'}, 
    19     'pyparsing':{'version':'1.5.5','import_name':'pyparsing','test':'__version__'}, 
    20     'html5lib':{'version':'0.95','import_name':'html5lib','test':'__version__'}, 
    21     'reportlab':{'version':'2.5','import_name':'reportlab','test':'Version'}, 
    22     'h5py':{'version':'2.5','import_name':'h5py','test':'__version__'}, 
    23     'lxml':{'version':'2.3','import_name':'lxml.etree','test':'LXML_VERSION'}, 
    24     'PIL':{'version':'1.1.7','import_name':'Image','test':'VERSION'}, 
    25     'pylint':{'version':None,'import_name':'pylint','test':None}, 
    26     'periodictable':{'version':'1.3.0','import_name':'periodictable','test':'__version__'}, 
    27     'bumps':{'version':'0.7.5.9','import_name':'bumps','test':'__version__'}, 
    28     'numpy':{'version':'1.7.1','import_name':'numpy','test':'__version__'}, 
    29     'scipy':{'version':'0.18.0','import_name':'scipy','test':'__version__'}, 
    30     'wx':{'version':'2.8.12.1','import_name':'wx','test':'__version__'}, 
    31     'matplotlib':{'version':'1.1.0','import_name':'matplotlib','test':'__version__'}, 
    32     'xhtml2pdf':{'version':'3.0.33','import_name':'xhtml2pdf','test':'__version__'}, 
    33     'sphinx':{'version':'1.2.1','import_name':'sphinx','test':'__version__'}, 
    34     'unittest-xml-reporting':{'version':'1.10.0','import_name':'xmlrunner','test':'__version__'}, 
    35     'pyopencl':{'version':'2015.1','import_name':'pyopencl','test':'VERSION_TEXT'}, 
     21    'setuptools': {'version': '0.6c11', 'import_name': 'setuptools', 'test': '__version__'}, 
     22    'pyparsing': {'version': '1.5.5', 'import_name': 'pyparsing', 'test': '__version__'}, 
     23    'html5lib': {'version': '0.95', 'import_name': 'html5lib', 'test': '__version__'}, 
     24    'reportlab': {'version': '2.5', 'import_name': 'reportlab', 'test': 'Version'}, 
     25    'h5py': {'version': '2.5', 'import_name': 'h5py', 'test': '__version__'}, 
     26    'lxml': {'version': '2.3', 'import_name': 'lxml.etree', 'test': 'LXML_VERSION'}, 
     27    'PIL': {'version': '1.1.7', 'import_name': 'Image', 'test': 'VERSION'}, 
     28    'pylint': {'version': None, 'import_name': 'pylint', 'test': None}, 
     29    'periodictable': {'version': '1.3.0', 'import_name': 'periodictable', 'test': '__version__'}, 
     30    'bumps': {'version': '0.7.5.9', 'import_name': 'bumps', 'test': '__version__'}, 
     31    'numpy': {'version': '1.7.1', 'import_name': 'numpy', 'test': '__version__'}, 
     32    'scipy': {'version': '0.18.0', 'import_name': 'scipy', 'test': '__version__'}, 
     33    'wx': {'version': '2.8.12.1', 'import_name': 'wx', 'test': '__version__'}, 
     34    'matplotlib': {'version': '1.1.0', 'import_name': 'matplotlib', 'test': '__version__'}, 
     35    'xhtml2pdf': {'version': '3.0.33', 'import_name': 'xhtml2pdf', 'test': '__version__'}, 
     36    'sphinx': {'version': '1.2.1', 'import_name': 'sphinx', 'test': '__version__'}, 
     37    'unittest-xml-reporting': {'version': '1.10.0', 'import_name': 'xmlrunner', 'test': '__version__'}, 
     38    'pyopencl': {'version': '2015.1', 'import_name': 'pyopencl', 'test': 'VERSION_TEXT'}, 
    3639} 
    3740win_required_package_list = { 
    38     'comtypes':{'version':'0.6.2','import_name':'comtypes','test':'__version__'}, 
    39     'pywin':{'version':'217','import_name':'pywin','test':'__version__'}, 
    40     'py2exe':{'version':'0.6.9','import_name':'py2exe','test':'__version__'}, 
     41    'comtypes': {'version': '0.6.2', 'import_name': 'comtypes', 'test': '__version__'}, 
     42    'pywin': {'version': '217', 'import_name': 'pywin', 'test': '__version__'}, 
     43    'py2exe': {'version': '0.6.9', 'import_name': 'py2exe', 'test': '__version__'}, 
    4144} 
    4245mac_required_package_list = { 
    43     'py2app':{'version':None,'import_name':'py2app','test':'__version__'}, 
     46    'py2app': {'version': None, 'import_name': 'py2app', 'test': '__version__'}, 
    4447} 
    4548 
    4649deprecated_package_list = { 
    47     'pyPdf':{'version':'1.13','import_name':'pyPdf','test':'__version__'}, 
     50    'pyPdf': {'version': '1.13', 'import_name': 'pyPdf', 'test': '__version__'}, 
    4851} 
    4952 
    50 print "Checking Required Package Versions...." 
    51 print 
    52 print "Common Packages" 
    53 for package_name,test_vals in common_required_package_list.iteritems(): 
     53print("Checking Required Package Versions....\n") 
     54print("Common Packages") 
     55 
     56for package_name, test_vals in common_required_package_list.items(): 
    5457    try: 
    55         i = __import__(test_vals['import_name'],fromlist=['']) 
     58        i = __import__(test_vals['import_name'], fromlist=['']) 
    5659        if test_vals['test'] == None: 
    57             print "%s Installed (Unknown version)" % package_name 
     60            print("%s Installed (Unknown version)" % package_name) 
    5861        elif package_name == 'lxml': 
    59             verstring = str(getattr(i,'LXML_VERSION')) 
    60             print "%s Version Installed: %s"% (package_name,verstring.replace(', ','.').lstrip('(').rstrip(')')) 
     62            verstring = str(getattr(i, 'LXML_VERSION')) 
     63            print("%s Version Installed: %s"% (package_name, verstring.replace(', ', '.').lstrip('(').rstrip(')'))) 
    6164        else: 
    62             print "%s Version Installed: %s"% (package_name,getattr(i,test_vals['test'])) 
    63     except: 
    64         print '%s NOT INSTALLED'% package_name 
     65            print("%s Version Installed: %s"% (package_name, getattr(i, test_vals['test']))) 
     66    except ImportError: 
     67        print('%s NOT INSTALLED'% package_name) 
    6568 
    6669if sys.platform == 'win32': 
    67     print 
    68     print "Windows Specific Packages:" 
    69     for package_name,test_vals in win_required_package_list.iteritems(): 
     70    print("") 
     71    print("Windows Specific Packages:") 
     72    for package_name, test_vals in win_required_package_list.items(): 
    7073        try: 
    7174            if package_name == "pywin": 
    7275                import win32api 
    73                 fixed_file_info = win32api.GetFileVersionInfo(win32api.__file__,'\\') 
    74                 print "%s Version Installed: %s"% (package_name,fixed_file_info['FileVersionLS'] >> 16) 
     76                fixed_file_info = win32api.GetFileVersionInfo(win32api.__file__, '\\') 
     77                print("%s Version Installed: %s"% (package_name, fixed_file_info['FileVersionLS'] >> 16)) 
    7578            else: 
    76                 i = __import__(test_vals['import_name'],fromlist=['']) 
    77                 print "%s Version Installed: %s"% (package_name,getattr(i,test_vals['test'])) 
    78         except: 
    79             print '%s NOT INSTALLED'% package_name 
     79                i = __import__(test_vals['import_name'], fromlist=['']) 
     80                print("%s Version Installed: %s"% (package_name, getattr(i, test_vals['test']))) 
     81        except ImportError: 
     82            print('%s NOT INSTALLED'% package_name) 
    8083 
    8184if sys.platform == 'darwin': 
    82     print 
    83     print "MacOS Specific Packages:" 
    84     for package_name,test_vals in mac_required_package_list.iteritems(): 
     85    print("") 
     86    print("MacOS Specific Packages:") 
     87    for package_name, test_vals in mac_required_package_list.items(): 
    8588        try: 
    86             i = __import__(test_vals['import_name'],fromlist=['']) 
    87             print "%s Version Installed: %s"% (package_name,getattr(i,test_vals['test'])) 
    88         except: 
    89             print '%s NOT INSTALLED'% package_name 
     89            i = __import__(test_vals['import_name'], fromlist=['']) 
     90            print("%s Version Installed: %s"% (package_name, getattr(i, test_vals['test']))) 
     91        except ImportError: 
     92            print('%s NOT INSTALLED'% package_name) 
    9093 
    9194 
    92 print 
    93 print "Deprecated Packages" 
    94 print "You can remove these unless you need them for other reasons!" 
    95 for package_name,test_vals in deprecated_package_list.iteritems(): 
     95print("") 
     96print("Deprecated Packages") 
     97print("You can remove these unless you need them for other reasons!") 
     98for package_name, test_vals in deprecated_package_list.items(): 
    9699    try: 
    97         i = __import__(test_vals['import_name'],fromlist=['']) 
     100        i = __import__(test_vals['import_name'], fromlist=['']) 
    98101        if package_name == 'pyPdf': 
    99             #pyPdf doesn't have the version number internally 
    100             print 'pyPDF Installed (Version unknown)' 
     102            # pyPdf doesn't have the version number internally 
     103            print('pyPDF Installed (Version unknown)') 
    101104        else: 
    102             print "%s Version Installed: %s"% (package_name,getattr(i,test_vals['test'])) 
    103     except: 
    104         print '%s NOT INSTALLED'% package_name 
     105            print("%s Version Installed: %s"% (package_name, getattr(i, test_vals['test']))) 
     106    except ImportError: 
     107        print('%s NOT INSTALLED'% package_name) 
  • run.py

    r18e7309 r05a9d29  
    2020from os.path import abspath, dirname, join as joinpath 
    2121 
     22class TeeStream: 
     23    def __init__(self, filename): 
     24        self.logfile = open(filename, 'a') 
     25        self.console = sys.stderr 
     26    def write(self, buf): 
     27        self.logfile.write(buf) 
     28        self.console.write(buf) 
     29 
     30def tee_logging(): 
     31    import logging 
     32    stream = TeeStream(os.path.join(os.path.expanduser("~"), 'sasview.log')) 
     33    logging.basicConfig(level=logging.INFO, 
     34                        format='%(asctime)s %(levelname)s %(message)s', 
     35                        stream=stream) 
    2236 
    2337def addpath(path): 
     
    139153if __name__ == "__main__": 
    140154    prepare() 
     155    tee_logging() 
    141156    from sas.sasview.sasview import run 
    142157    run() 
  • sasview/README.txt

    r220b1e7 r9146ed9  
    441- Features 
    55=========== 
     6    - New in Version 4.1.0 
     7      ------------------ 
     8      This incremental release brings a series of new features and improvements, 
     9      and a host of bug fixes. Of particular note are: 
     10       
     11      - Correlation Function Analysis (Corfunc) 
     12        This performs a correlation function analysis of one-dimensional SAXS/SANS data,  
     13        or generates a model-independent volume fraction profile from the SANS from an  
     14        adsorbed polymer/surfactant layer. 
     15 
     16        A correlation function may be interpreted in terms of an imaginary rod moving  
     17        through the structure of the material. Γ1D(R) is the probability that a rod of  
     18        length R moving through the material has equal electron/neutron scattering  
     19        length density at either end. Hence a frequently occurring spacing within a  
     20        structure manifests itself as a peak. 
     21 
     22        A volume fraction profile \Phi(z) describes how the density of polymer  
     23        segments/surfactant molecules varies with distance from an (assumed locally flat) 
     24        interface. 
     25 
     26      - Fitting of SESANS Data 
     27        Data from Spin-Echo SANS measurements can now be loaded and fitted. The data will  
     28        be plotted against the correct axes and models will automatically perform a Hankel  
     29        transform in order to calculate SESANS from a SANS model. 
     30 
     31      - Documentation 
     32        The documentation has undergone significant checking and updating. 
     33 
     34      - Improvements 
     35        - Correlation function (corfunc) analysis of 1D SAS data added from CCP13 
     36        - File converter tool for multi-file single column data sets 
     37        - SESANS data loading and direct fitting using the Hankel transformation 
     38        - Saving and loading of simultaneous and constrained fits now supported 
     39        - Save states from SasView v3.x.y now loaded using sasmodel model names 
     40        - Saving and loading of projects with 2D fits now supported 
     41        - Loading a project removes all existing data, fits, and plots 
     42        - Structure factor and form factor can be plotted independently 
     43        - OpenCL is disabled by default and can be enabled through a fit menu 
     44        - Data and theory fields are now independently expandable 
     45      - Bug Fixes 
     46        - Fixes #667: Models computed multiple times on parameters changes 
     47        - Fixes #673: Custom models override built in models of same name 
     48        - Fixes #678: Hard crash when running complex models on GPU 
     49        - Fixes $774: Old style plugin models unloadable 
     50        - Fixes #789: stacked disk scale doesn't match cylinder model 
     51        - Fixes #792: core_shell_fractal uses wrong effective radius 
     52        - Fixes #800: Plot range reset on plot redraws 
     53        - Fixes #811 and #825: 2D smearing broken 
     54        - Fixes #815: Integer model parameter handling 
     55        - Fixes #824: Cannot apply sector averaging when no detector data present 
     56        - Fixes #830: Cansas HDF5 reader fully compliant with NXCanSAS v1.0 format 
     57        - Fixes #835: Fractal model breaks with negative Q values 
     58        - Fixes #843: Multilayer vesicle does not define effective radius 
     59        - Fixes #858: Hayter MSA S(Q) returns errors 
     60        - Numerous grammatical and contexual errors in documention 
     61 
     62 
    663    - New in Version 4.0.1 
    764      ------------------ 
     
    426483=============== 
    427484 
     485 
     486   4.1- All systems: 
     487      The conversion to sasmodels infrastructure is ongoing and should be 
     488      completed in the next release. In the meantime this leads to a few known 
     489      issues: 
     490        - The way that orientation is defined is being refactored to address 
     491        long standing issues and comments.  In release 4.1 however only models 
     492        with symmetry (e.g. a=b) have been converted to the new definitions. 
     493        The rest (a <> b <> c - e.g. parellelepiped) maintain the same 
     494        definition as before and will be converted in 4.2.  Note that 
     495        orientational distribution also makes much more sense in the new 
     496        framework.  The documentation should indicate which definition is being 
     497        used for a given model. 
     498        - The infrastructure currently handles internal conversion of old style 
     499        models so that user created models in previous versions should continue 
     500        to work for now. At some point in the future such support will go away. 
     501        Everyone is encouraged to convert to the new structure which should be 
     502        relatively straight forward and provides a number of benefits.  
     503        - In that vein, the distributed models and those generated by the new 
     504        plugin model editor are in the new format, however those generated by 
     505        sum|multiply models are the old style sum|multiply models. This should 
     506        also disappear in the near future  
     507        - The on the fly discovery of plugin models and changes thereto behave 
     508        inconsistently.  If a change to a plugin model does not seem to 
     509        register, the Load Plugin Models (under fitting -> Plugin Model 
     510        Operations) can be used.  However, after calling Load Plugin Models, the 
     511        active plugin will no longer be loaded (even though the GUI looks like 
     512        it is) unless it is a sum|multiply model which works properly.  All 
     513        others will need to be recalled from the model dropdown menu to reload 
     514        the model into the calculation engine.  While it might be annoying it 
     515        does not appear to prevent SasView from working.. 
     516        - The model code and documentation review is ongoing. At this time the 
     517        core shell parellelepiped is known to have the C shell effectively fixed 
     518        at 0 (noted in documentation) while the triaxial ellipsoid does not seem 
     519        to reproduce the limit of the oblate or prolate ellipsoid. If errors are 
     520        found and corrected, corrected versions will be uploaded to the 
     521        marketplace.  
     522    
    428523   3.1- All systems: 
    429524        - The documentation window may take a few seconds to load the first time 
  • sasview/local_config.py

    r73cbeec r1779e72  
    3333''' remember to:''' 
    3434_acknowledgement_preamble_bullet1 =\ 
    35 '''Acknowledge its use in your publications as suggested below;''' 
     35'''Acknowledge its use in your publications as :''' 
    3636_acknowledgement_preamble_bullet2 =\ 
    37 '''Reference SasView as : M. Doucet, et al. SasView Version 4.0, Zenodo''' +\ 
    38 ''', http://doi.org/10.5281/zenodo.159083;''' 
     37'''Reference SasView as:''' 
    3938_acknowledgement_preamble_bullet3 =\ 
    40 '''Reference the model you used if appropriate (see documentation for refs);''' 
     39'''Reference the model you used if appropriate (see documentation for refs)''' 
    4140_acknowledgement_preamble_bullet4 =\ 
    4241'''Send us your reference for our records: developers@sasview.org''' 
    4342_acknowledgement_publications = \ 
    44 '''This work benefited from the use of the SasView application, originally developed under NSF Award  
    45 DMR-0520547. SasView also contains code developed with funding from the EU Horizon 2020 programme  
    46 under the SINE2020 project Grant No 654000, and by Patrick O'Brien & Adam Washington.''' 
     43'''This work benefited from the use of the SasView application, originally developed under NSF Award DMR-0520547. SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project Grant No 654000.''' 
     44_acknowledgement_citation = \ 
     45'''M. Doucet et al. SasView Version 4.1, Zenodo, 10.5281/zenodo.438138''' 
    4746 
    4847_acknowledgement =  \ 
    49 '''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547, but is currently maintained  
    50 by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft. SasView also contains code developed with funding from the  
    51 EU Horizon 2020 programme under the SINE2020 project (Grant No 654000), and by Patrick O'Brien (pycrust) and Adam Washington (corfunc-py).''' 
     48'''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS, and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: https://github.com/orgs/SasView/people 
     49''' 
    5250 
    5351_homepage = "http://www.sasview.org" 
     
    7270_ansto_logo = os.path.join(icon_path, "ansto_logo.png") 
    7371_tudelft_logo = os.path.join(icon_path, "tudelft_logo.png") 
     72_dls_logo = os.path.join(icon_path, "dls_logo.png") 
    7473_nsf_logo = os.path.join(icon_path, "nsf_logo.png") 
    7574_danse_logo = os.path.join(icon_path, "danse_logo.png") 
     
    8584_ansto_url = "http://www.ansto.gov.au/" 
    8685_tudelft_url = "http://www.tnw.tudelft.nl/en/cooperation/facilities/reactor-instituut-delft/" 
     86_dls_url = "http://www.diamond.ac.uk/" 
    8787_danse_url = "http://www.cacr.caltech.edu/projects/danse/release/index.html" 
    8888_inst_url = "http://www.utk.edu" 
    8989_corner_image = os.path.join(icon_path, "angles_flat.png") 
    9090_welcome_image = os.path.join(icon_path, "SVwelcome.png") 
    91 _copyright = "(c) 2009 - 2016, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft" 
     91_copyright = "(c) 2009 - 2017, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft and DLS" 
    9292marketplace_url = "http://marketplace.sasview.org/" 
    9393 
  • setup.py

    r1e13b53 red2276f  
    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 
     
    315315                               'test/1d_data/*', 
    316316                               'test/2d_data/*', 
     317                               'test/convertible_files/*', 
     318                               'test/coordinate_data/*', 
     319                               'test/image_data/*', 
     320                               'test/media/*', 
     321                               'test/other_files/*', 
    317322                               'test/save_states/*', 
    318                                'test/upcoming_formats/*', 
    319                                  'default_categories.json'] 
     323                               'test/sesans_data/*' 
     324                               ] 
    320325packages.append("sas.sasview") 
    321326 
  • 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/calculator/slit_length_calculator.py

    rb699768 rbfba720  
    1616        # y data 
    1717        self.y = None 
    18         #default slit length 
     18        # default slit length 
    1919        self.slit_length = 0.0 
    2020 
     
    4242        """ 
    4343        # None data do nothing 
    44         if self.y == None or self.x == None: 
     44        if self.y is None or self.x is None: 
    4545            return 
    4646        # set local variable 
     
    5454        y_sum = 0.0 
    5555        y_max = 0.0 
    56         ind = 0.0 
     56        ind = 0 
    5757 
    5858        # sum 10 or more y values until getting max_y, 
     
    7070        # defaults 
    7171        y_half_d = 0.0 
    72         ind = 0.0 
     72        ind = 0 
    7373        # find indices where it crosses y = y_half. 
    7474        while True: 
     
    8181 
    8282        # y value and ind just before passed the spot of the half height 
    83         y_half_u = y[ind-1] 
     83        y_half_u = y[ind - 1] 
    8484 
    8585        # get corresponding x values 
    8686        x_half_d = x[ind] 
    87         x_half_u = x[ind-1] 
     87        x_half_u = x[ind - 1] 
    8888 
    8989        # calculate x at y = y_half using linear interpolation 
     
    9191            x_half = (x_half_d + x_half_u)/2.0 
    9292        else: 
    93             x_half = (x_half_u * (y_half - y_half_d)  \ 
    94                        + x_half_d * (y_half_u - y_half)) \ 
    95                         / (y_half_u - y_half_d) 
     93            x_half = ((x_half_u * (y_half - y_half_d) 
     94                       + x_half_d * (y_half_u - y_half)) 
     95                       / (y_half_u - y_half_d)) 
    9696 
    9797        # Our slit length is half width, so just give half beam value 
  • 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 rdd11014  
    8080 
    8181    """ 
    82     if data2d.data == None or data2d.x_bins == None or data2d.y_bins == None: 
     82    if data2d.data is None or data2d.x_bins is None or data2d.y_bins is None: 
    8383        raise ValueError, "Can't convert this data: data=None..." 
    8484    new_x = numpy.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
     
    9090    qy_data = new_y.flatten() 
    9191    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): 
     92    if data2d.err_data is None or numpy.any(data2d.err_data <= 0): 
    9393        new_err_data = numpy.sqrt(numpy.abs(new_data)) 
    9494    else: 
  • src/sas/sascalc/dataloader/readers/IgorReader.py

    rb699768 rdd11014  
    1313############################################################################# 
    1414import os 
    15 import numpy 
    16 import math 
    17 #import logging 
     15 
    1816from sas.sascalc.dataloader.data_info import Data2D 
    1917from sas.sascalc.dataloader.data_info import Detector 
    2018from sas.sascalc.dataloader.manipulations import reader2D_converter 
     19import numpy as np 
    2120 
    2221# Look for unit converter 
     
    4039        """ Read file """ 
    4140        if not os.path.isfile(filename): 
    42             raise ValueError, \ 
    43             "Specified file %s is not a regular file" % filename 
    44          
    45         # Read file 
    46         f = open(filename, 'r') 
    47         buf = f.read() 
    48          
    49         # Instantiate data object 
     41            raise ValueError("Specified file %s is not a regular " 
     42                             "file" % filename) 
     43         
    5044        output = Data2D() 
     45 
    5146        output.filename = os.path.basename(filename) 
    5247        detector = Detector() 
    53         if len(output.detector) > 0: 
    54             print str(output.detector[0]) 
     48        if len(output.detector): 
     49            print(str(output.detector[0])) 
    5550        output.detector.append(detector) 
    56                  
    57         # Get content 
    58         dataStarted = False 
    59          
    60         lines = buf.split('\n') 
    61         itot = 0 
    62         x = [] 
    63         y = [] 
    64          
    65         ncounts = 0 
    66          
    67         xmin = None 
    68         xmax = None 
    69         ymin = None 
    70         ymax = None 
    71          
    72         i_x = 0 
    73         i_y = -1 
    74         i_tot_row = 0 
    75          
    76         isInfo = False 
    77         isCenter = False 
    78         
    79         data_conv_q = None 
    80         data_conv_i = None 
    81          
    82         if has_converter == True and output.Q_unit != '1/A': 
     51 
     52        data_conv_q = data_conv_i = None 
     53         
     54        if has_converter and output.Q_unit != '1/A': 
    8355            data_conv_q = Converter('1/A') 
    8456            # Test it 
    8557            data_conv_q(1.0, output.Q_unit) 
    8658             
    87         if has_converter == True and output.I_unit != '1/cm': 
     59        if has_converter and output.I_unit != '1/cm': 
    8860            data_conv_i = Converter('1/cm') 
    8961            # Test it 
    9062            data_conv_i(1.0, output.I_unit) 
    91           
    92         for line in lines: 
    93              
    94             # Find setup info line 
    95             if isInfo: 
    96                 isInfo = False 
    97                 line_toks = line.split() 
    98                 # Wavelength in Angstrom 
    99                 try: 
    100                     wavelength = float(line_toks[1]) 
    101                 except: 
    102                     msg = "IgorReader: can't read this file, missing wavelength" 
    103                     raise ValueError, msg 
    104                  
    105             #Find # of bins in a row assuming the detector is square. 
    106             if dataStarted == True: 
    107                 try: 
    108                     value = float(line) 
    109                 except: 
    110                     # Found a non-float entry, skip it 
    111                     continue 
    112                  
    113                 # Get total bin number 
    114                  
    115             i_tot_row += 1 
    116         i_tot_row = math.ceil(math.sqrt(i_tot_row)) - 1 
    117         #print "i_tot", i_tot_row 
    118         size_x = i_tot_row  # 192#128 
    119         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]) 
    122       
    123         #Read Header and 2D data 
    124         for line in lines: 
    125             # Find setup info line 
    126             if isInfo: 
    127                 isInfo = False 
    128                 line_toks = line.split() 
    129                 # Wavelength in Angstrom 
    130                 try: 
    131                     wavelength = float(line_toks[1]) 
    132                 except: 
    133                     msg = "IgorReader: can't read this file, missing wavelength" 
    134                     raise ValueError, msg 
    135                 # Distance in meters 
    136                 try: 
    137                     distance = float(line_toks[3]) 
    138                 except: 
    139                     msg = "IgorReader: can't read this file, missing distance" 
    140                     raise ValueError, msg 
    141                  
    142                 # Distance in meters 
    143                 try: 
    144                     transmission = float(line_toks[4]) 
    145                 except: 
    146                     msg = "IgorReader: can't read this file, " 
    147                     msg += "missing transmission" 
    148                     raise ValueError, msg 
    149                                              
    150             if line.count("LAMBDA") > 0: 
    151                 isInfo = True 
    152                  
    153             # Find center info line 
    154             if isCenter: 
    155                 isCenter = False 
    156                 line_toks = line.split() 
    157                  
    158                 # Center in bin number: Must substrate 1 because 
    159                 #the index starts from 1 
    160                 center_x = float(line_toks[0]) - 1 
    161                 center_y = float(line_toks[1]) - 1 
    162  
    163             if line.count("BCENT") > 0: 
    164                 isCenter = True 
    165                  
    166             # Find data start 
    167             if line.count("***")>0: 
    168                 dataStarted = True 
    169                  
    170                 # Check that we have all the info 
    171                 if wavelength == None \ 
    172                     or distance == None \ 
    173                     or center_x == None \ 
    174                     or center_y == None: 
    175                     msg = "IgorReader:Missing information in data file" 
    176                     raise ValueError, msg 
    177                  
    178             if dataStarted == True: 
    179                 try: 
    180                     value = float(line) 
    181                 except: 
    182                     # Found a non-float entry, skip it 
    183                     continue 
    184                  
    185                 # Get bin number 
    186                 if math.fmod(itot, i_tot_row) == 0: 
    187                     i_x = 0 
    188                     i_y += 1 
    189                 else: 
    190                     i_x += 1 
    191                      
    192                 output.data[i_y][i_x] = value 
    193                 ncounts += 1 
    194                  
    195                 # Det 640 x 640 mm 
    196                 # Q = 4pi/lambda sin(theta/2) 
    197                 # Bin size is 0.5 cm  
    198                 #REmoved +1 from theta = (i_x-center_x+1)*0.5 / distance 
    199                 # / 100.0 and  
    200                 #REmoved +1 from theta = (i_y-center_y+1)*0.5 / 
    201                 # distance / 100.0 
    202                 #ToDo: Need  complete check if the following 
    203                 # covert process is consistent with fitting.py. 
    204                 theta = (i_x - center_x) * 0.5 / distance / 100.0 
    205                 qx = 4.0 * math.pi / wavelength * math.sin(theta/2.0) 
    206  
    207                 if has_converter == True and output.Q_unit != '1/A': 
    208                     qx = data_conv_q(qx, units=output.Q_unit) 
    209  
    210                 if xmin == None or qx < xmin: 
    211                     xmin = qx 
    212                 if xmax == None or qx > xmax: 
    213                     xmax = qx 
    214                  
    215                 theta = (i_y - center_y) * 0.5 / distance / 100.0 
    216                 qy = 4.0 * math.pi / wavelength * math.sin(theta / 2.0) 
    217  
    218                 if has_converter == True and output.Q_unit != '1/A': 
    219                     qy = data_conv_q(qy, units=output.Q_unit) 
    220                  
    221                 if ymin == None or qy < ymin: 
    222                     ymin = qy 
    223                 if ymax == None or qy > ymax: 
    224                     ymax = qy 
    225                  
    226                 if not qx in x: 
    227                     x.append(qx) 
    228                 if not qy in y: 
    229                     y.append(qy) 
    230                  
    231                 itot += 1 
    232                    
    233                    
     63 
     64        data_row = 0 
     65        wavelength = distance = center_x = center_y = None 
     66        dataStarted = isInfo = isCenter = False 
     67 
     68        with open(filename, 'r') as f: 
     69            for line in f: 
     70                data_row += 1 
     71                # Find setup info line 
     72                if isInfo: 
     73                    isInfo = False 
     74                    line_toks = line.split() 
     75                    # Wavelength in Angstrom 
     76                    try: 
     77                        wavelength = float(line_toks[1]) 
     78                    except ValueError: 
     79                        msg = "IgorReader: can't read this file, missing wavelength" 
     80                        raise ValueError(msg) 
     81                    # Distance in meters 
     82                    try: 
     83                        distance = float(line_toks[3]) 
     84                    except ValueError: 
     85                        msg = "IgorReader: can't read this file, missing distance" 
     86                        raise ValueError(msg) 
     87 
     88                    # Distance in meters 
     89                    try: 
     90                        transmission = float(line_toks[4]) 
     91                    except: 
     92                        msg = "IgorReader: can't read this file, " 
     93                        msg += "missing transmission" 
     94                        raise ValueError(msg) 
     95 
     96                if line.count("LAMBDA"): 
     97                    isInfo = True 
     98 
     99                # Find center info line 
     100                if isCenter: 
     101                    isCenter = False 
     102                    line_toks = line.split() 
     103 
     104                    # Center in bin number: Must subtract 1 because 
     105                    # the index starts from 1 
     106                    center_x = float(line_toks[0]) - 1 
     107                    center_y = float(line_toks[1]) - 1 
     108 
     109                if line.count("BCENT"): 
     110                    isCenter = True 
     111 
     112                # Find data start 
     113                if line.count("***"): 
     114                    # now have to continue to blank line 
     115                    dataStarted = True 
     116 
     117                    # Check that we have all the info 
     118                    if (wavelength is None 
     119                            or distance is None 
     120                            or center_x is None 
     121                            or center_y is None): 
     122                        msg = "IgorReader:Missing information in data file" 
     123                        raise ValueError(msg) 
     124 
     125                if dataStarted: 
     126                    if len(line.rstrip()): 
     127                        continue 
     128                    else: 
     129                        break 
     130 
     131        # The data is loaded in row major order (last index changing most 
     132        # rapidly). However, the original data is in column major order (first 
     133        # index changing most rapidly). The swap to column major order is done 
     134        # in reader2D_converter at the end of this method. 
     135        data = np.loadtxt(filename, skiprows=data_row) 
     136        size_x = size_y = int(np.rint(np.sqrt(data.size))) 
     137        output.data = np.reshape(data, (size_x, size_y)) 
     138        output.err_data = np.zeros_like(output.data) 
     139 
     140        # Det 640 x 640 mm 
     141        # Q = 4 * pi/lambda * sin(theta/2) 
     142        # Bin size is 0.5 cm 
     143        # Removed +1 from theta = (i_x - center_x + 1)*0.5 / distance 
     144        # / 100.0 and 
     145        # Removed +1 from theta = (i_y - center_y + 1)*0.5 / 
     146        # distance / 100.0 
     147        # ToDo: Need  complete check if the following 
     148        # convert process is consistent with fitting.py. 
     149 
     150        # calculate qx, qy bin centers of each pixel in the image 
     151        theta = (np.arange(size_x) - center_x) * 0.5 / distance / 100. 
     152        qx = 4 * np.pi / wavelength * np.sin(theta/2) 
     153 
     154        theta = (np.arange(size_y) - center_y) * 0.5 / distance / 100. 
     155        qy = 4 * np.pi / wavelength * np.sin(theta/2) 
     156 
     157        if has_converter and output.Q_unit != '1/A': 
     158            qx = data_conv_q(qx, units=output.Q_unit) 
     159            qy = data_conv_q(qx, units=output.Q_unit) 
     160 
     161        xmax = np.max(qx) 
     162        xmin = np.min(qx) 
     163        ymax = np.max(qy) 
     164        ymin = np.min(qy) 
     165 
     166        # calculate edge offset in q. 
    234167        theta = 0.25 / distance / 100.0 
    235         xstep = 4.0 * math.pi / wavelength * math.sin(theta / 2.0) 
     168        xstep = 4.0 * np.pi / wavelength * np.sin(theta / 2.0) 
    236169         
    237170        theta = 0.25 / distance / 100.0 
    238         ystep = 4.0 * math.pi/ wavelength * math.sin(theta / 2.0) 
     171        ystep = 4.0 * np.pi/ wavelength * np.sin(theta / 2.0) 
    239172         
    240173        # Store all data ###################################### 
    241174        # Store wavelength 
    242         if has_converter == True and output.source.wavelength_unit != 'A': 
     175        if has_converter and output.source.wavelength_unit != 'A': 
    243176            conv = Converter('A') 
    244177            wavelength = conv(wavelength, units=output.source.wavelength_unit) 
     
    246179 
    247180        # Store distance 
    248         if has_converter == True and detector.distance_unit != 'm': 
     181        if has_converter and detector.distance_unit != 'm': 
    249182            conv = Converter('m') 
    250183            distance = conv(distance, units=detector.distance_unit) 
     
    254187        output.sample.transmission = transmission 
    255188         
    256         # Store pixel size 
     189        # Store pixel size (mm) 
    257190        pixel = 5.0 
    258         if has_converter == True and detector.pixel_size_unit != 'mm': 
     191        if has_converter and detector.pixel_size_unit != 'mm': 
    259192            conv = Converter('mm') 
    260193            pixel = conv(pixel, units=detector.pixel_size_unit) 
     
    267200         
    268201        # Store limits of the image (2D array) 
    269         xmin = xmin - xstep / 2.0 
    270         xmax = xmax + xstep / 2.0 
    271         ymin = ymin - ystep / 2.0 
    272         ymax = ymax + ystep / 2.0 
    273         if has_converter == True and output.Q_unit != '1/A': 
     202        xmin -= xstep / 2.0 
     203        xmax += xstep / 2.0 
     204        ymin -= ystep / 2.0 
     205        ymax += ystep / 2.0 
     206        if has_converter and output.Q_unit != '1/A': 
    274207            xmin = data_conv_q(xmin, units=output.Q_unit) 
    275208            xmax = data_conv_q(xmax, units=output.Q_unit) 
     
    282215         
    283216        # Store x and y axis bin centers 
    284         output.x_bins = x 
    285         output.y_bins = y 
     217        output.x_bins = qx.tolist() 
     218        output.y_bins = qy.tolist() 
    286219         
    287220        # Units 
  • 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/cansas_reader.py

    rc221349 r8434365  
    930930            self._write_data(datainfo, entry_node) 
    931931        # Transmission Spectrum Info 
    932         self._write_trans_spectrum(datainfo, entry_node) 
     932        # TODO: fix the writer to linearize all data, including T_spectrum 
     933        # self._write_trans_spectrum(datainfo, entry_node) 
    933934        # Sample info 
    934935        self._write_sample_info(datainfo, entry_node) 
  • src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

    rbbd0f37 rc94280c  
    99import sys 
    1010 
    11 from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D, Data1D, Data2D, DataInfo, Process, Aperture 
    12 from sas.sascalc.dataloader.data_info import Collimation, TransmissionSpectrum, Detector 
     11from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D,\ 
     12    Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \ 
     13    TransmissionSpectrum, Detector 
    1314from sas.sascalc.dataloader.data_info import combine_data_info_with_plottable 
    14  
    1515 
    1616 
    1717class Reader(): 
    1818    """ 
    19     A class for reading in CanSAS v2.0 data files. The existing iteration opens Mantid generated HDF5 formatted files 
    20     with file extension .h5/.H5. Any number of data sets may be present within the file and any dimensionality of data 
    21     may be used. Currently 1D and 2D SAS data sets are supported, but future implementations will include 1D and 2D 
    22     SESANS data. 
    23  
    24     Any number of SASdata sets may be present in a SASentry and the data within can be either 1D I(Q) or 2D I(Qx, Qy). 
     19    A class for reading in CanSAS v2.0 data files. The existing iteration opens 
     20    Mantid generated HDF5 formatted files with file extension .h5/.H5. Any 
     21    number of data sets may be present within the file and any dimensionality 
     22    of data may be used. Currently 1D and 2D SAS data sets are supported, but 
     23    future implementations will include 1D and 2D SESANS data. 
     24 
     25    Any number of SASdata sets may be present in a SASentry and the data within 
     26    can be either 1D I(Q) or 2D I(Qx, Qy). 
    2527 
    2628    Also supports reading NXcanSAS formatted HDF5 files 
     
    3032    """ 
    3133 
    32     ## CanSAS version 
     34    # CanSAS version 
    3335    cansas_version = 2.0 
    34     ## Logged warnings or messages 
     36    # Logged warnings or messages 
    3537    logging = None 
    36     ## List of errors for the current data set 
     38    # List of errors for the current data set 
    3739    errors = None 
    38     ## Raw file contents to be processed 
     40    # Raw file contents to be processed 
    3941    raw_data = None 
    40     ## Data info currently being read in 
     42    # Data info currently being read in 
    4143    current_datainfo = None 
    42     ## SASdata set currently being read in 
     44    # SASdata set currently being read in 
    4345    current_dataset = None 
    44     ## List of plottable1D objects that should be linked to the current_datainfo 
     46    # List of plottable1D objects that should be linked to the current_datainfo 
    4547    data1d = None 
    46     ## List of plottable2D objects that should be linked to the current_datainfo 
     48    # List of plottable2D objects that should be linked to the current_datainfo 
    4749    data2d = None 
    48     ## Data type name 
     50    # Data type name 
    4951    type_name = "CanSAS 2.0" 
    50     ## Wildcards 
     52    # Wildcards 
    5153    type = ["CanSAS 2.0 HDF5 Files (*.h5)|*.h5"] 
    52     ## List of allowed extensions 
     54    # List of allowed extensions 
    5355    ext = ['.h5', '.H5'] 
    54     ## Flag to bypass extension check 
    55     allow_all = False 
    56     ## List of files to return 
     56    # Flag to bypass extension check 
     57    allow_all = True 
     58    # List of files to return 
    5759    output = None 
    5860 
     
    6466        :return: List of Data1D/2D objects and/or a list of errors. 
    6567        """ 
    66         ## Reinitialize the class when loading a new data file to reset all class variables 
     68        # Reinitialize when loading a new data file to reset all class variables 
    6769        self.reset_class_variables() 
    68         ## Check that the file exists 
     70        # Check that the file exists 
    6971        if os.path.isfile(filename): 
    7072            basename = os.path.basename(filename) 
     
    7274            # If the file type is not allowed, return empty list 
    7375            if extension in self.ext or self.allow_all: 
    74                 ## Load the data file 
     76                # Load the data file 
    7577                self.raw_data = h5py.File(filename, 'r') 
    76                 ## Read in all child elements of top level SASroot 
     78                # Read in all child elements of top level SASroot 
    7779                self.read_children(self.raw_data, []) 
    78                 ## Add the last data set to the list of outputs 
     80                # Add the last data set to the list of outputs 
    7981                self.add_data_set() 
    80                 ## Close the data file 
     82                # Close the data file 
    8183                self.raw_data.close() 
    82         ## Return data set(s) 
     84        # Return data set(s) 
    8385        return self.output 
    8486 
     
    110112        """ 
    111113 
    112         ## Loop through each element of the parent and process accordingly 
     114        # Loop through each element of the parent and process accordingly 
    113115        for key in data.keys(): 
    114             ## Get all information for the current key 
     116            # Get all information for the current key 
    115117            value = data.get(key) 
    116118            if value.attrs.get(u'canSAS_class') is not None: 
     
    126128                self.parent_class = class_name 
    127129                parent_list.append(key) 
    128                 ## If this is a new sasentry, store the current data sets and create a fresh Data1D/2D object 
     130                # If a new sasentry, store the current data sets and create 
     131                # a fresh Data1D/2D object 
    129132                if class_prog.match(u'SASentry'): 
    130133                    self.add_data_set(key) 
    131134                elif class_prog.match(u'SASdata'): 
    132135                    self._initialize_new_data_set(parent_list) 
    133                 ## Recursion step to access data within the group 
     136                # Recursion step to access data within the group 
    134137                self.read_children(value, parent_list) 
    135138                self.add_intermediate() 
     
    137140 
    138141            elif isinstance(value, h5py.Dataset): 
    139                 ## If this is a dataset, store the data appropriately 
     142                # If this is a dataset, store the data appropriately 
    140143                data_set = data[key][:] 
    141144                unit = self._get_unit(value) 
    142145 
    143                 ## I and Q Data 
     146                # I and Q Data 
    144147                if key == u'I': 
    145                     if type(self.current_dataset) is plottable_2D: 
     148                    if isinstance(self.current_dataset, plottable_2D): 
    146149                        self.current_dataset.data = data_set 
    147150                        self.current_dataset.zaxis("Intensity", unit) 
     
    151154                    continue 
    152155                elif key == u'Idev': 
    153                     if type(self.current_dataset) is plottable_2D: 
     156                    if isinstance(self.current_dataset, plottable_2D): 
    154157                        self.current_dataset.err_data = data_set.flatten() 
    155158                    else: 
     
    158161                elif key == u'Q': 
    159162                    self.current_dataset.xaxis("Q", unit) 
    160                     if type(self.current_dataset) is plottable_2D: 
     163                    if isinstance(self.current_dataset, plottable_2D): 
    161164                        self.current_dataset.q = data_set.flatten() 
    162165                    else: 
     
    166169                    self.current_dataset.dx = data_set.flatten() 
    167170                    continue 
     171                elif key == u'dQw': 
     172                    self.current_dataset.dxw = data_set.flatten() 
     173                    continue 
     174                elif key == u'dQl': 
     175                    self.current_dataset.dxl = data_set.flatten() 
     176                    continue 
    168177                elif key == u'Qy': 
    169178                    self.current_dataset.yaxis("Q_y", unit) 
     
    183192                    self.current_dataset.mask = data_set.flatten() 
    184193                    continue 
     194                # Transmission Spectrum 
     195                elif (key == u'T' 
     196                      and self.parent_class == u'SAStransmission_spectrum'): 
     197                    self.trans_spectrum.transmission = data_set.flatten() 
     198                    continue 
     199                elif (key == u'Tdev' 
     200                      and self.parent_class == u'SAStransmission_spectrum'): 
     201                    self.trans_spectrum.transmission_deviation = \ 
     202                        data_set.flatten() 
     203                    continue 
     204                elif (key == u'lambda' 
     205                      and self.parent_class == u'SAStransmission_spectrum'): 
     206                    self.trans_spectrum.wavelength = data_set.flatten() 
     207                    continue 
    185208 
    186209                for data_point in data_set: 
    187                     ## Top Level Meta Data 
     210                    # Top Level Meta Data 
    188211                    if key == u'definition': 
    189212                        self.current_datainfo.meta_data['reader'] = data_point 
     
    201224                        self.current_datainfo.notes.append(data_point) 
    202225 
    203                     ## Sample Information 
    204                     elif key == u'Title' and self.parent_class == u'SASsample': # CanSAS 2.0 format 
     226                    # Sample Information 
     227                    # CanSAS 2.0 format 
     228                    elif key == u'Title' and self.parent_class == u'SASsample': 
    205229                        self.current_datainfo.sample.name = data_point 
    206                     elif key == u'ID' and self.parent_class == u'SASsample': # NXcanSAS format 
     230                    # NXcanSAS format 
     231                    elif key == u'name' and self.parent_class == u'SASsample': 
    207232                        self.current_datainfo.sample.name = data_point 
    208                     elif key == u'thickness' and self.parent_class == u'SASsample': 
     233                    # NXcanSAS format 
     234                    elif key == u'ID' and self.parent_class == u'SASsample': 
     235                        self.current_datainfo.sample.name = data_point 
     236                    elif (key == u'thickness' 
     237                          and self.parent_class == u'SASsample'): 
    209238                        self.current_datainfo.sample.thickness = data_point 
    210                     elif key == u'temperature' and self.parent_class == u'SASsample': 
     239                    elif (key == u'temperature' 
     240                          and self.parent_class == u'SASsample'): 
    211241                        self.current_datainfo.sample.temperature = data_point 
    212                     elif key == u'transmission' and self.parent_class == u'SASsample': 
     242                    elif (key == u'transmission' 
     243                          and self.parent_class == u'SASsample'): 
    213244                        self.current_datainfo.sample.transmission = data_point 
    214                     elif key == u'x_position' and self.parent_class == u'SASsample': 
     245                    elif (key == u'x_position' 
     246                          and self.parent_class == u'SASsample'): 
    215247                        self.current_datainfo.sample.position.x = data_point 
    216                     elif key == u'y_position' and self.parent_class == u'SASsample': 
     248                    elif (key == u'y_position' 
     249                          and self.parent_class == u'SASsample'): 
    217250                        self.current_datainfo.sample.position.y = data_point 
    218                     elif key == u'polar_angle' and self.parent_class == u'SASsample': 
     251                    elif key == u'pitch' and self.parent_class == u'SASsample': 
    219252                        self.current_datainfo.sample.orientation.x = data_point 
    220                     elif key == u'azimuthal_angle' and self.parent_class == u'SASsample': 
     253                    elif key == u'yaw' and self.parent_class == u'SASsample': 
     254                        self.current_datainfo.sample.orientation.y = data_point 
     255                    elif key == u'roll' and self.parent_class == u'SASsample': 
    221256                        self.current_datainfo.sample.orientation.z = data_point 
    222                     elif key == u'details' and self.parent_class == u'SASsample': 
     257                    elif (key == u'details' 
     258                          and self.parent_class == u'SASsample'): 
    223259                        self.current_datainfo.sample.details.append(data_point) 
    224260 
    225                     ## Instrumental Information 
    226                     elif key == u'name' and self.parent_class == u'SASinstrument': 
     261                    # Instrumental Information 
     262                    elif (key == u'name' 
     263                          and self.parent_class == u'SASinstrument'): 
    227264                        self.current_datainfo.instrument = data_point 
    228265                    elif key == u'name' and self.parent_class == u'SASdetector': 
     
    231268                        self.detector.distance = float(data_point) 
    232269                        self.detector.distance_unit = unit 
    233                     elif key == u'slit_length' and self.parent_class == u'SASdetector': 
     270                    elif (key == u'slit_length' 
     271                          and self.parent_class == u'SASdetector'): 
    234272                        self.detector.slit_length = float(data_point) 
    235273                        self.detector.slit_length_unit = unit 
    236                     elif key == u'x_position' and self.parent_class == u'SASdetector': 
     274                    elif (key == u'x_position' 
     275                          and self.parent_class == u'SASdetector'): 
    237276                        self.detector.offset.x = float(data_point) 
    238277                        self.detector.offset_unit = unit 
    239                     elif key == u'y_position' and self.parent_class == u'SASdetector': 
     278                    elif (key == u'y_position' 
     279                          and self.parent_class == u'SASdetector'): 
    240280                        self.detector.offset.y = float(data_point) 
    241281                        self.detector.offset_unit = unit 
    242                     elif key == u'polar_angle' and self.parent_class == u'SASdetector': 
     282                    elif (key == u'pitch' 
     283                          and self.parent_class == u'SASdetector'): 
    243284                        self.detector.orientation.x = float(data_point) 
    244285                        self.detector.orientation_unit = unit 
    245                     elif key == u'azimuthal_angle' and self.parent_class == u'SASdetector': 
     286                    elif key == u'roll' and self.parent_class == u'SASdetector': 
    246287                        self.detector.orientation.z = float(data_point) 
    247288                        self.detector.orientation_unit = unit 
    248                     elif key == u'beam_center_x' and self.parent_class == u'SASdetector': 
     289                    elif key == u'yaw' and self.parent_class == u'SASdetector': 
     290                        self.detector.orientation.y = float(data_point) 
     291                        self.detector.orientation_unit = unit 
     292                    elif (key == u'beam_center_x' 
     293                          and self.parent_class == u'SASdetector'): 
    249294                        self.detector.beam_center.x = float(data_point) 
    250295                        self.detector.beam_center_unit = unit 
    251                     elif key == u'beam_center_y' and self.parent_class == u'SASdetector': 
     296                    elif (key == u'beam_center_y' 
     297                          and self.parent_class == u'SASdetector'): 
    252298                        self.detector.beam_center.y = float(data_point) 
    253299                        self.detector.beam_center_unit = unit 
    254                     elif key == u'x_pixel_size' and self.parent_class == u'SASdetector': 
     300                    elif (key == u'x_pixel_size' 
     301                          and self.parent_class == u'SASdetector'): 
    255302                        self.detector.pixel_size.x = float(data_point) 
    256303                        self.detector.pixel_size_unit = unit 
    257                     elif key == u'y_pixel_size' and self.parent_class == u'SASdetector': 
     304                    elif (key == u'y_pixel_size' 
     305                          and self.parent_class == u'SASdetector'): 
    258306                        self.detector.pixel_size.y = float(data_point) 
    259307                        self.detector.pixel_size_unit = unit 
    260                     elif key == u'SSD' and self.parent_class == u'SAScollimation': 
     308                    elif (key == u'distance' 
     309                          and self.parent_class == u'SAScollimation'): 
    261310                        self.collimation.length = data_point 
    262311                        self.collimation.length_unit = unit 
    263                     elif key == u'name' and self.parent_class == u'SAScollimation': 
     312                    elif (key == u'name' 
     313                          and self.parent_class == u'SAScollimation'): 
    264314                        self.collimation.name = data_point 
    265  
    266                     ## Process Information 
    267                     elif key == u'name' and self.parent_class == u'SASprocess': 
     315                    elif (key == u'shape' 
     316                          and self.parent_class == u'SASaperture'): 
     317                        self.aperture.shape = data_point 
     318                    elif (key == u'x_gap' 
     319                          and self.parent_class == u'SASaperture'): 
     320                        self.aperture.size.x = data_point 
     321                    elif (key == u'y_gap' 
     322                          and self.parent_class == u'SASaperture'): 
     323                        self.aperture.size.y = data_point 
     324 
     325                    # Process Information 
     326                    elif (key == u'Title' 
     327                          and self.parent_class == u'SASprocess'): # CanSAS 2.0 
    268328                        self.process.name = data_point 
    269                     elif key == u'Title' and self.parent_class == u'SASprocess': # CanSAS 2.0 format 
     329                    elif (key == u'name' 
     330                          and self.parent_class == u'SASprocess'): # NXcanSAS 
    270331                        self.process.name = data_point 
    271                     elif key == u'name' and self.parent_class == u'SASprocess': # NXcanSAS format 
    272                         self.process.name = data_point 
    273                     elif key == u'description' and self.parent_class == u'SASprocess': 
     332                    elif (key == u'description' 
     333                          and self.parent_class == u'SASprocess'): 
    274334                        self.process.description = data_point 
    275335                    elif key == u'date' and self.parent_class == u'SASprocess': 
    276336                        self.process.date = data_point 
     337                    elif key == u'term' and self.parent_class == u'SASprocess': 
     338                        self.process.term = data_point 
    277339                    elif self.parent_class == u'SASprocess': 
    278340                        self.process.notes.append(data_point) 
    279341 
    280                     ## Transmission Spectrum 
    281                     elif key == u'T' and self.parent_class == u'SAStransmission_spectrum': 
    282                         self.trans_spectrum.transmission.append(data_point) 
    283                     elif key == u'Tdev' and self.parent_class == u'SAStransmission_spectrum': 
    284                         self.trans_spectrum.transmission_deviation.append(data_point) 
    285                     elif key == u'lambda' and self.parent_class == u'SAStransmission_spectrum': 
    286                         self.trans_spectrum.wavelength.append(data_point) 
    287  
    288                     ## Source 
    289                     elif key == u'wavelength' and self.parent_class == u'SASdata': 
     342                    # Source 
     343                    elif (key == u'wavelength' 
     344                          and self.parent_class == u'SASdata'): 
    290345                        self.current_datainfo.source.wavelength = data_point 
    291346                        self.current_datainfo.source.wavelength_unit = unit 
    292                     elif key == u'incident_wavelength' and self.parent_class == u'SASsource': 
     347                    elif (key == u'incident_wavelength' 
     348                          and self.parent_class == 'SASsource'): 
    293349                        self.current_datainfo.source.wavelength = data_point 
    294350                        self.current_datainfo.source.wavelength_unit = unit 
    295                     elif key == u'wavelength_max' and self.parent_class == u'SASsource': 
     351                    elif (key == u'wavelength_max' 
     352                          and self.parent_class == u'SASsource'): 
    296353                        self.current_datainfo.source.wavelength_max = data_point 
    297354                        self.current_datainfo.source.wavelength_max_unit = unit 
    298                     elif key == u'wavelength_min' and self.parent_class == u'SASsource': 
     355                    elif (key == u'wavelength_min' 
     356                          and self.parent_class == u'SASsource'): 
    299357                        self.current_datainfo.source.wavelength_min = data_point 
    300358                        self.current_datainfo.source.wavelength_min_unit = unit 
    301                     elif key == u'wavelength_spread' and self.parent_class == u'SASsource': 
    302                         self.current_datainfo.source.wavelength_spread = data_point 
    303                         self.current_datainfo.source.wavelength_spread_unit = unit 
    304                     elif key == u'beam_size_x' and self.parent_class == u'SASsource': 
     359                    elif (key == u'incident_wavelength_spread' 
     360                          and self.parent_class == u'SASsource'): 
     361                        self.current_datainfo.source.wavelength_spread = \ 
     362                            data_point 
     363                        self.current_datainfo.source.wavelength_spread_unit = \ 
     364                            unit 
     365                    elif (key == u'beam_size_x' 
     366                          and self.parent_class == u'SASsource'): 
    305367                        self.current_datainfo.source.beam_size.x = data_point 
    306368                        self.current_datainfo.source.beam_size_unit = unit 
    307                     elif key == u'beam_size_y' and self.parent_class == u'SASsource': 
     369                    elif (key == u'beam_size_y' 
     370                          and self.parent_class == u'SASsource'): 
    308371                        self.current_datainfo.source.beam_size.y = data_point 
    309372                        self.current_datainfo.source.beam_size_unit = unit 
    310                     elif key == u'beam_shape' and self.parent_class == u'SASsource': 
     373                    elif (key == u'beam_shape' 
     374                          and self.parent_class == u'SASsource'): 
    311375                        self.current_datainfo.source.beam_shape = data_point 
    312                     elif key == u'radiation' and self.parent_class == u'SASsource': 
     376                    elif (key == u'radiation' 
     377                          and self.parent_class == u'SASsource'): 
    313378                        self.current_datainfo.source.radiation = data_point 
    314                     elif key == u'transmission' and self.parent_class == u'SASdata': 
     379                    elif (key == u'transmission' 
     380                          and self.parent_class == u'SASdata'): 
    315381                        self.current_datainfo.sample.transmission = data_point 
    316382 
    317                     ## Everything else goes in meta_data 
     383                    # Everything else goes in meta_data 
    318384                    else: 
    319                         new_key = self._create_unique_key(self.current_datainfo.meta_data, key) 
     385                        new_key = self._create_unique_key( 
     386                            self.current_datainfo.meta_data, key) 
    320387                        self.current_datainfo.meta_data[new_key] = data_point 
    321388 
    322389            else: 
    323                 ## I don't know if this reachable code 
     390                # I don't know if this reachable code 
    324391                self.errors.add("ShouldNeverHappenException") 
    325392 
    326393    def add_intermediate(self): 
    327394        """ 
    328         This method stores any intermediate objects within the final data set after fully reading the set. 
    329  
    330         :param parent: The NXclass name for the h5py Group object that just finished being processed 
     395        This method stores any intermediate objects within the final data set 
     396        after fully reading the set. 
     397 
     398        :param parent: The NXclass name for the h5py Group object that just 
     399                       finished being processed 
    331400        """ 
    332401 
     
    347416            self.aperture = Aperture() 
    348417        elif self.parent_class == u'SASdata': 
    349             if type(self.current_dataset) is plottable_2D: 
     418            if isinstance(self.current_dataset, plottable_2D): 
    350419                self.data2d.append(self.current_dataset) 
    351             elif type(self.current_dataset) is plottable_1D: 
     420            elif isinstance(self.current_dataset, plottable_1D): 
    352421                self.data1d.append(self.current_dataset) 
    353422 
    354423    def final_data_cleanup(self): 
    355424        """ 
    356         Does some final cleanup and formatting on self.current_datainfo and all data1D and data2D objects and then 
    357         combines the data and info into Data1D and Data2D objects 
    358         """ 
    359  
    360         ## Type cast data arrays to float64 
     425        Does some final cleanup and formatting on self.current_datainfo and 
     426        all data1D and data2D objects and then combines the data and info into 
     427        Data1D and Data2D objects 
     428        """ 
     429 
     430        # Type cast data arrays to float64 
    361431        if len(self.current_datainfo.trans_spectrum) > 0: 
    362432            spectrum_list = [] 
     
    364434                spectrum.transmission = np.delete(spectrum.transmission, [0]) 
    365435                spectrum.transmission = spectrum.transmission.astype(np.float64) 
    366                 spectrum.transmission_deviation = np.delete(spectrum.transmission_deviation, [0]) 
    367                 spectrum.transmission_deviation = spectrum.transmission_deviation.astype(np.float64) 
     436                spectrum.transmission_deviation = np.delete( 
     437                    spectrum.transmission_deviation, [0]) 
     438                spectrum.transmission_deviation = \ 
     439                    spectrum.transmission_deviation.astype(np.float64) 
    368440                spectrum.wavelength = np.delete(spectrum.wavelength, [0]) 
    369441                spectrum.wavelength = spectrum.wavelength.astype(np.float64) 
     
    372444            self.current_datainfo.trans_spectrum = spectrum_list 
    373445 
    374         ## Append errors to dataset and reset class errors 
     446        # Append errors to dataset and reset class errors 
    375447        self.current_datainfo.errors = self.errors 
    376448        self.errors.clear() 
    377449 
    378         ## Combine all plottables with datainfo and append each to output 
    379         ## Type cast data arrays to float64 and find min/max as appropriate 
     450        # Combine all plottables with datainfo and append each to output 
     451        # Type cast data arrays to float64 and find min/max as appropriate 
    380452        for dataset in self.data2d: 
    381453            dataset.data = dataset.data.astype(np.float64) 
     
    397469            zeros = np.ones(dataset.data.size, dtype=bool) 
    398470            try: 
    399                 for i in range (0, dataset.mask.size - 1): 
     471                for i in range(0, dataset.mask.size - 1): 
    400472                    zeros[i] = dataset.mask[i] 
    401473            except: 
    402474                self.errors.add(sys.exc_value) 
    403475            dataset.mask = zeros 
    404             ## Calculate the actual Q matrix 
     476            # Calculate the actual Q matrix 
    405477            try: 
    406478                if dataset.q_data.size <= 1: 
    407                     dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data + dataset.qy_data * dataset.qy_data) 
     479                    dataset.q_data = np.sqrt(dataset.qx_data 
     480                                             * dataset.qx_data 
     481                                             + dataset.qy_data 
     482                                             * dataset.qy_data) 
    408483            except: 
    409484                dataset.q_data = None 
     
    415490                dataset.data = dataset.data.flatten() 
    416491 
    417             final_dataset = combine_data_info_with_plottable(dataset, self.current_datainfo) 
     492            final_dataset = combine_data_info_with_plottable( 
     493                dataset, self.current_datainfo) 
    418494            self.output.append(final_dataset) 
    419495 
     
    435511            if dataset.dy is not None: 
    436512                dataset.dy = dataset.dy.astype(np.float64) 
    437             final_dataset = combine_data_info_with_plottable(dataset, self.current_datainfo) 
     513            final_dataset = combine_data_info_with_plottable( 
     514                dataset, self.current_datainfo) 
    438515            self.output.append(final_dataset) 
    439516 
    440517    def add_data_set(self, key=""): 
    441518        """ 
    442         Adds the current_dataset to the list of outputs after preforming final processing on the data and then calls a 
    443         private method to generate a new data set. 
     519        Adds the current_dataset to the list of outputs after preforming final 
     520        processing on the data and then calls a private method to generate a 
     521        new data set. 
    444522 
    445523        :param key: NeXus group name for current tree level 
     
    453531 
    454532 
    455     def _initialize_new_data_set(self, parent_list = None): 
    456         """ 
    457         A private class method to generate a new 1D or 2D data object based on the type of data within the set. 
    458         Outside methods should call add_data_set() to be sure any existing data is stored properly. 
     533    def _initialize_new_data_set(self, parent_list=None): 
     534        """ 
     535        A private class method to generate a new 1D or 2D data object based on 
     536        the type of data within the set. Outside methods should call 
     537        add_data_set() to be sure any existing data is stored properly. 
    459538 
    460539        :param parent_list: List of names of parent elements 
     
    473552    def _find_intermediate(self, parent_list, basename=""): 
    474553        """ 
    475         A private class used to find an entry by either using a direct key or knowing the approximate basename. 
    476  
    477         :param parent_list: List of parents to the current level in the HDF5 file 
     554        A private class used to find an entry by either using a direct key or 
     555        knowing the approximate basename. 
     556 
     557        :param parent_list: List of parents nodes in the HDF5 file 
    478558        :param basename: Approximate name of an entry to search for 
    479559        :return: 
     
    486566            top = top.get(parent) 
    487567        for key in top.keys(): 
    488             if (key_prog.match(key)): 
     568            if key_prog.match(key): 
    489569                entry = True 
    490570                break 
     
    516596        """ 
    517597        unit = value.attrs.get(u'units') 
    518         if unit == None: 
     598        if unit is None: 
    519599            unit = value.attrs.get(u'unit') 
    520         ## Convert the unit formats 
     600        # Convert the unit formats 
    521601        if unit == "1/A": 
    522602            unit = "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

    r345e7e4 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 
    354         errors = [str(exc), traceback.traceback.format_exc()] 
     353        best, fbest = None, np.NaN 
     354        errors = [str(exc), traceback.format_exc()] 
    355355    finally: 
    356356        mapper.stop_mapper(fitdriver.mapper) 
     
    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/aboutbox.py

    r49e000b r1779e72  
    118118        self.bitmap_button_ansto = wx.BitmapButton(self, -1, wx.NullBitmap) 
    119119        self.bitmap_button_tudelft = wx.BitmapButton(self, -1, wx.NullBitmap) 
     120        self.bitmap_button_dls = wx.BitmapButton(self, -1, wx.NullBitmap) 
    120121         
    121122        self.static_line_3 = wx.StaticLine(self, -1) 
     
    137138        self.Bind(wx.EVT_BUTTON, self.onAnstoLogo, self.bitmap_button_ansto) 
    138139        self.Bind(wx.EVT_BUTTON, self.onTudelftLogo, self.bitmap_button_tudelft) 
     140        self.Bind(wx.EVT_BUTTON, self.onDlsLogo, self.bitmap_button_dls) 
    139141        # end wxGlade 
    140142        # fill in acknowledgements 
     
    229231        logo = wx.Bitmap(image) 
    230232        self.bitmap_button_tudelft.SetBitmapLabel(logo) 
     233         
     234        image = file_dir + "/images/dls_logo.png" 
     235        if os.path.isfile(config._dls_logo): 
     236            image = config._dls_logo 
     237        logo = wx.Bitmap(image) 
     238        self.bitmap_button_dls.SetBitmapLabel(logo) 
    231239                 
    232240        # resize dialog window to fit version number nicely 
     
    260268        self.bitmap_button_ansto.SetSize(self.bitmap_button_ansto.GetBestSize()) 
    261269        self.bitmap_button_tudelft.SetSize(self.bitmap_button_tudelft.GetBestSize()) 
     270        self.bitmap_button_dls.SetSize(self.bitmap_button_dls.GetBestSize()) 
    262271        # end wxGlade 
    263272 
     
    325334        sizer_logos.Add(self.bitmap_button_tudelft, 0,  
    326335                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
     336        sizer_logos.Add(self.bitmap_button_dls, 0,  
     337                        wx.LEFT|wx.ADJUST_MINSIZE, 2) 
    327338                 
    328339        sizer_logos.Add((10, 50), 0, wx.ADJUST_MINSIZE, 0) 
     
    423434        event.Skip() 
    424435 
     436    def onDlsLogo(self, event): 
     437        """ 
     438        """  
     439        # wxGlade: DialogAbout.<event_handler> 
     440        launchBrowser(config._dls_url) 
     441        event.Skip() 
     442 
    425443# end of class DialogAbout 
    426444 
  • src/sas/sasgui/guiframe/acknowledgebox.py

    rc1fdf84 r74c8cd0  
    1111import wx.richtext 
    1212import wx.lib.hyperlink 
     13from wx.lib.expando import ExpandoTextCtrl 
    1314import random 
    1415import os.path 
     
    3637    Shows the current method for acknowledging SasView in 
    3738    scholarly publications. 
    38  
    3939    """ 
    4040 
     
    4444        wx.Dialog.__init__(self, *args, **kwds) 
    4545 
    46         self.ack = wx.TextCtrl(self, style=wx.TE_LEFT|wx.TE_MULTILINE|wx.TE_BESTWRAP|wx.TE_READONLY|wx.TE_NO_VSCROLL) 
     46        self.ack = ExpandoTextCtrl(self, style=wx.TE_LEFT|wx.TE_MULTILINE|wx.TE_BESTWRAP|wx.TE_READONLY|wx.TE_NO_VSCROLL) 
    4747        self.ack.SetValue(config._acknowledgement_publications) 
    48         self.ack.SetMinSize((-1, 55)) 
     48        #self.ack.SetMinSize((-1, 55)) 
     49        self.citation = ExpandoTextCtrl(self, style=wx.TE_LEFT|wx.TE_MULTILINE|wx.TE_BESTWRAP|wx.TE_READONLY|wx.TE_NO_VSCROLL) 
     50        self.citation.SetValue(config._acknowledgement_citation) 
    4951        self.preamble = wx.StaticText(self, -1, config._acknowledgement_preamble) 
    5052        items = [config._acknowledgement_preamble_bullet1, 
     
    5254                 config._acknowledgement_preamble_bullet3, 
    5355                 config._acknowledgement_preamble_bullet4] 
    54         self.list1 = wx.StaticText(self, -1, "\t(1) " + items[0]) 
    55         self.list2 = wx.StaticText(self, -1, "\t(2) " + items[1]) 
    56         self.list3 = wx.StaticText(self, -1, "\t(3) " + items[2]) 
    57         self.list4 = wx.StaticText(self, -1, "\t(4) " + items[3]) 
     56        self.list1 = wx.StaticText(self, -1, "(1) " + items[0]) 
     57        self.list2 = wx.StaticText(self, -1, "(2) " + items[1]) 
     58        self.list3 = wx.StaticText(self, -1, "(3) " + items[2]) 
     59        self.list4 = wx.StaticText(self, -1, "(4) " + items[3]) 
    5860        self.static_line = wx.StaticLine(self, 0) 
    5961        self.__set_properties() 
     
    6971        self.SetTitle("Acknowledging SasView") 
    7072        #Increased size of box from (525, 225), SMK, 04/10/16 
    71         self.SetSize((600, 300)) 
     73        self.SetClientSize((600, 320)) 
    7274        # end wxGlade 
    7375 
     
    8183        sizer_titles.Add(self.preamble, 0, wx.ALL|wx.EXPAND, 5) 
    8284        sizer_titles.Add(self.list1, 0, wx.ALL|wx.EXPAND, 5) 
     85        sizer_titles.Add(self.ack, 0, wx.ALL|wx.EXPAND, 5) 
    8386        sizer_titles.Add(self.list2, 0, wx.ALL|wx.EXPAND, 5) 
     87        sizer_titles.Add(self.citation, 0, wx.ALL|wx.EXPAND, 5) 
    8488        sizer_titles.Add(self.list3, 0, wx.ALL|wx.EXPAND, 5) 
     89        #sizer_titles.Add(self.static_line, 0, wx.ALL|wx.EXPAND, 0) 
    8590        sizer_titles.Add(self.list4, 0, wx.ALL|wx.EXPAND, 5) 
    86         sizer_titles.Add(self.static_line, 0, wx.ALL|wx.EXPAND, 0) 
    87         sizer_titles.Add(self.ack, 0, wx.ALL|wx.EXPAND, 5) 
    8891        sizer_main.Add(sizer_titles, -1, wx.ALL|wx.EXPAND, 5) 
    8992        self.SetAutoLayout(True) 
     
    9194        self.Layout() 
    9295        self.Centre() 
     96        #self.SetClientSize(sizer_main.GetSize()) 
    9397        # end wxGlade 
    9498 
  • src/sas/sasgui/guiframe/config.py

    rd85c194 r1779e72  
    11""" 
    2 Application settings 
     2    Application settings 
    33""" 
     4import time 
    45import os 
    5 import time 
    66from sas.sasgui.guiframe.gui_style import GUIFRAME 
     7import sas.sasview 
     8import logging 
     9 
    710# Version of the application 
    8 __appname__ = "DummyView" 
    9 __version__ = '0.0.0' 
    10 __build__ = '1' 
     11__appname__ = "SasView" 
     12__version__ = sas.sasview.__version__ 
     13__build__ = sas.sasview.__build__ 
    1114__download_page__ = 'https://github.com/SasView/sasview/releases' 
    1215__update_URL__ = 'http://www.sasview.org/latestversion.json' 
    1316 
    14  
    1517# Debug message flag 
    16 __EVT_DEBUG__ = True 
     18__EVT_DEBUG__ = False 
    1719 
    1820# Flag for automated testing 
     
    2931_acknowledgement_preamble =\ 
    3032'''To ensure the long term support and development of this software please''' +\ 
    31 ''' remember to do the following.''' 
     33''' remember to:''' 
    3234_acknowledgement_preamble_bullet1 =\ 
    33 '''Acknowledge its use in your publications as suggested below''' 
     35'''Acknowledge its use in your publications as :''' 
    3436_acknowledgement_preamble_bullet2 =\ 
    35 '''Reference the following website: http://www.sasview.org''' 
     37'''Reference SasView as:''' 
    3638_acknowledgement_preamble_bullet3 =\ 
    3739'''Reference the model you used if appropriate (see documentation for refs)''' 
     
    3941'''Send us your reference for our records: developers@sasview.org''' 
    4042_acknowledgement_publications = \ 
    41 '''This work benefited from the use of the SasView application, originally 
    42 developed under NSF award DMR-0520547. 
     43'''This work benefited from the use of the SasView application, originally developed under NSF Award DMR-0520547. SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project Grant No 654000.''' 
     44_acknowledgement_citation = \ 
     45'''M. Doucet et al. SasView Version 4.1, Zenodo, 10.5281/zenodo.438138''' 
     46 
     47_acknowledgement =  \ 
     48'''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS, and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: https://github.com/orgs/SasView/people 
    4349''' 
    44 _acknowledgement =  \ 
    45 '''This work originally developed as part of the DANSE project funded by the NSF 
    46 under grant DMR-0520547, and currently maintained by NIST, UMD, ORNL, ISIS, ESS 
    47 and ILL. 
    4850 
    49 ''' 
    5051_homepage = "http://www.sasview.org" 
    51 _download = "http://sourceforge.net/projects/sasview/files/" 
     52_download = __download_page__ 
    5253_authors = [] 
    5354_paper = "http://sourceforge.net/p/sasview/tickets/" 
    5455_license = "mailto:help@sasview.org" 
    55 _nsf_logo = "images/nsf_logo.png" 
    56 _danse_logo = "images/danse_logo.png" 
    57 _inst_logo = "images/utlogo.gif" 
    58 _nist_logo = "images/nist_logo.png" 
    59 _umd_logo = "images/umd_logo.png" 
    60 _sns_logo = "images/sns_logo.png" 
    61 _isis_logo = "images/isis_logo.png" 
    62 _ess_logo = "images/ess_logo.png" 
    63 _ill_logo = "images/ill_logo.png" 
     56 
     57 
     58icon_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "images")) 
     59logging.info("icon path: %s" % icon_path) 
     60media_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "media")) 
     61test_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "test")) 
     62 
     63_nist_logo = os.path.join(icon_path, "nist_logo.png") 
     64_umd_logo = os.path.join(icon_path, "umd_logo.png") 
     65_sns_logo = os.path.join(icon_path, "sns_logo.png") 
     66_ornl_logo = os.path.join(icon_path, "ornl_logo.png") 
     67_isis_logo = os.path.join(icon_path, "isis_logo.png") 
     68_ess_logo = os.path.join(icon_path, "ess_logo.png") 
     69_ill_logo = os.path.join(icon_path, "ill_logo.png") 
     70_ansto_logo = os.path.join(icon_path, "ansto_logo.png") 
     71_tudelft_logo = os.path.join(icon_path, "tudelft_logo.png") 
     72_nsf_logo = os.path.join(icon_path, "nsf_logo.png") 
     73_danse_logo = os.path.join(icon_path, "danse_logo.png") 
     74_inst_logo = os.path.join(icon_path, "utlogo.gif") 
    6475_nist_url = "http://www.nist.gov/" 
    6576_umd_url = "http://www.umd.edu/" 
    6677_sns_url = "http://neutrons.ornl.gov/" 
     78_ornl_url = "http://neutrons.ornl.gov/" 
    6779_nsf_url = "http://www.nsf.gov" 
    68 _danse_url = "http://www.cacr.caltech.edu/projects/danse/release/index.html" 
    69 _inst_url = "http://www.utk.edu" 
    7080_isis_url = "http://www.isis.stfc.ac.uk/" 
    7181_ess_url = "http://ess-scandinavia.eu/" 
    7282_ill_url = "http://www.ill.eu/" 
    73 _corner_image = "images/angles_flat.png" 
    74 _welcome_image = "images/SVwelcome.png" 
    75 _copyright = "(c) 2008, University of Tennessee" 
    76 #edit the lists below of file state your plugin can read 
    77 #for sasview this how you can edit these lists 
    78 #PLUGIN_STATE_EXTENSIONS = ['.prv','.fitv', '.inv'] 
    79 #APPLICATION_STATE_EXTENSION = '.svs' 
    80 #PLUGINS_WLIST = ['P(r) files (*.prv)|*.prv', 
    81 #                  'Fitting files (*.fitv)|*.fitv', 
    82 #                  'Invariant files (*.inv)|*.inv'] 
    83 #APPLICATION_WLIST = 'SasView files (*.svs)|*.svs' 
    84 APPLICATION_WLIST = '' 
    85 APPLICATION_STATE_EXTENSION = None 
    86 PLUGINS_WLIST = [] 
    87 PLUGIN_STATE_EXTENSIONS = [] 
    88 SPLASH_SCREEN_PATH = "images/danse_logo.png" 
    89 DEFAULT_STYLE = GUIFRAME.SINGLE_APPLICATION 
    90 SPLASH_SCREEN_WIDTH = 500 
    91 SPLASH_SCREEN_HEIGHT = 300 
    92 WELCOME_PANEL_ON = False 
    93 TUTORIAL_PATH = None 
    94 SS_MAX_DISPLAY_TIME = 1500 
    95 PLOPANEL_WIDTH = 350 
    96 PLOPANEL_HEIGTH = 350 
    97 GUIFRAME_WIDTH = 1000 
    98 GUIFRAME_HEIGHT = 800 
    99 CONTROL_WIDTH = -1 
    100 CONTROL_HEIGHT = -1 
    101 SetupIconFile_win = os.path.join("images", "ball.ico") 
    102 SetupIconFile_mac = os.path.join("images", "ball.icns") 
    103 DefaultGroupName = "DANSE" 
    104 OutputBaseFilename = "setupGuiFrame" 
     83_ansto_url = "http://www.ansto.gov.au/" 
     84_tudelft_url = "http://www.tnw.tudelft.nl/en/cooperation/facilities/reactor-instituut-delft/" 
     85_dls_url = "http://www.diamond.ac.uk/" 
     86_danse_url = "http://www.cacr.caltech.edu/projects/danse/release/index.html" 
     87_inst_url = "http://www.utk.edu" 
     88_corner_image = os.path.join(icon_path, "angles_flat.png") 
     89_welcome_image = os.path.join(icon_path, "SVwelcome.png") 
     90_copyright = "(c) 2009 - 2017, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, and DLS" 
     91marketplace_url = "http://marketplace.sasview.org/" 
     92 
     93#edit the list of file state your plugin can read 
     94APPLICATION_WLIST = 'SasView files (*.svs)|*.svs' 
     95APPLICATION_STATE_EXTENSION = '.svs' 
     96GUIFRAME_WIDTH = 1150 
     97GUIFRAME_HEIGHT = 840 
     98PLUGIN_STATE_EXTENSIONS = ['.fitv', '.inv', '.prv', '.crf'] 
     99PLUGINS_WLIST = ['Fitting files (*.fitv)|*.fitv', 
     100                 'Invariant files (*.inv)|*.inv', 
     101                 'P(r) files (*.prv)|*.prv', 
     102                 'Corfunc files (*.crf)|*.crf'] 
     103PLOPANEL_WIDTH = 415 
     104PLOPANEL_HEIGTH = 370 
    105105DATAPANEL_WIDTH = 235 
    106106DATAPANEL_HEIGHT = 700 
     107SPLASH_SCREEN_PATH = os.path.join(icon_path, "SVwelcome_mini.png") 
     108TUTORIAL_PATH = os.path.join(media_path, "Tutorial.pdf") 
     109DEFAULT_STYLE = GUIFRAME.MULTIPLE_APPLICATIONS|GUIFRAME.MANAGER_ON\ 
     110                    |GUIFRAME.CALCULATOR_ON|GUIFRAME.TOOLBAR_ON 
     111SPLASH_SCREEN_WIDTH = 512 
     112SPLASH_SCREEN_HEIGHT = 366 
     113SS_MAX_DISPLAY_TIME = 2000 
     114WELCOME_PANEL_ON = True 
     115WELCOME_PANEL_SHOW = False 
     116CLEANUP_PLOT = False 
     117# OPEN and SAVE project menu 
     118OPEN_SAVE_PROJECT_MENU = True 
     119#VIEW MENU 
     120VIEW_MENU = True 
     121#EDIT MENU 
     122EDIT_MENU = True 
     123 
     124SetupIconFile_win = os.path.join(icon_path, "ball.ico") 
     125SetupIconFile_mac = os.path.join(icon_path, "ball.icns") 
     126DefaultGroupName = "." 
     127OutputBaseFilename = "setupSasView" 
     128 
    107129FIXED_PANEL = True 
    108130DATALOADER_SHOW = True 
     
    113135# set a default perspective 
    114136DEFAULT_PERSPECTIVE = 'None' 
    115 # OPEN and SAVE project menu 
    116 OPEN_SAVE_PROJECT_MENU = True 
    117 CLEANUP_PLOT = False 
    118 # OPEN and SAVE project menu 
    119 OPEN_SAVE_PROJECT_MENU = False 
    120 #VIEW MENU 
    121 VIEW_MENU = False 
    122 #EDIT MENU 
    123 EDIT_MENU = False 
    124 import wx.lib.newevent 
    125 (StatusBarEvent, EVT_STATUS) = wx.lib.newevent.NewEvent() 
     137 
     138# Time out for updating sasview 
     139UPDATE_TIMEOUT = 2 
     140 
     141#OpenCL option 
     142SAS_OPENCL = None 
    126143 
    127144def printEVT(message): 
    128     """ 
    129     :TODO - need method documentation 
    130     """ 
    131145    if __EVT_DEBUG__: 
     146        """ 
     147        :TODO - Need method doc string 
     148        """ 
    132149        print "%g:  %s" % (time.clock(), message) 
    133      
     150 
    134151        if __EVT_DEBUG_2_FILE__: 
    135152            out = open(__EVT_DEBUG_FILENAME__, 'a') 
    136153            out.write("%10g:  %s\n" % (time.clock(), message)) 
    137154            out.close() 
    138              
  • 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) 
     54