Changeset 1580cc3 in sasview


Ignore:
Timestamp:
Nov 13, 2018 2:52:30 PM (4 weeks ago)
Author:
Paul Kienzle <pkienzle@…>
Branches:
ticket-1094-headless
Children:
ffbf35ee
Parents:
1dc134e6 (diff), f560e23 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into ticket-1094-headless

Files:
2 added
3 deleted
20 edited

Legend:

Unmodified
Added
Removed
  • docs/sphinx-docs/source/user/RELEASE.rst

    r9849f8a r67ed543  
    6060* An error in the be_polyelectrolyte model was identified and rectified, but  
    6161  the fix is yet to be validated. 
     62* (Added post-release) An error with the reporting of the scale parameter  
     63  from the spinodal model was rectified. 
    6264* A number of issues and inconsistencies with the creation of 
    6365  sum|multiply models have been rectified. 
     
    187189* Fixes #1010: Win64 build script not creating working executable 
    188190* Fixes #1011: sld_test failing on ubuntu 
    189 * Fixes #1012: ESS GUI not updating after fitting 
    190191* Fixes #1013: FileReaderBaseClass output[] not reset - same file loaded multiple times 
    191192* Fixes #1018: add Boltzmann distribution 
     
    233234* Fixes #1179: PDF Report should contain SasView Version Number 
    234235* Fixes #1183: Test from creating new model reset all parameters to default in all open FitPages 
     236* Fixes #1188: fitpage hangs if change model while magnetism is on 
     237* Fixes #1191: Correct erroneous Scale reported by Spinodal model 
    235238 
    236239**It is recommended that all users upgrade to this version, but your  
     
    868871  found and corrected, corrected versions will be uploaded to the 
    869872  marketplace. 
     873* (Added after Release 4.2.0) The scale parameter reported from the spinodal  
     874  model is the square root of the true value. 
    870875 
    8718763.1- All systems 
  • installers/license.txt

    r73c51df rc6a4d143  
    88Participating facilities include (in alphabetical order):  
    99the Australian National Science & Technology Centre for Neutron  
    10 Scattering, the Diamond Light Source, the European Spallation Source,  
    11 the Institut Laue Langevin, the ISIS Pulsed Neutron & Muon Source,  
    12 the National Institute of Standards & Technology Center for Neutron  
    13 Research, the Oak Ridge National Laboratory Neutron Sciences  
    14 Directorate, and the Technical University Delft Reactor Institute. 
     10Scattering, the Bundesanstalt fur Materialforschung und prufung, the  
     11Diamond Light Source, the European Spallation Source, the Institut  
     12Laue Langevin, the ISIS Pulsed Neutron & Muon Source, the National  
     13Institute of Standards & Technology Center for Neutron Research,  
     14the Oak Ridge National Laboratory Neutron Sciences Directorate,  
     15and the Technical University Delft Reactor Institute. 
    1516 
    1617SasView is distributed under a 'Three-clause' BSD licence which you  
  • run.py

    r3388337 r1580cc3  
    9595    try: 
    9696        import periodictable 
    97     except: 
     97    except ImportError: 
    9898        addpath(joinpath(root, '..', 'periodictable')) 
    9999 
    100100    try: 
    101101        import bumps 
    102     except: 
     102    except ImportError: 
    103103        addpath(joinpath(root, '..', 'bumps')) 
    104104 
    105105    try: 
    106106        import tinycc 
    107     except: 
     107    except ImportError: 
    108108        addpath(joinpath(root, '../tinycc/build/lib')) 
    109109 
     
    111111    #addpath(os.path.join(root, '..','wxPython-src-3.0.0.0','wxPython')) 
    112112 
     113<<<<<<< HEAD 
    113114    # Build project if the build directory does not already exist. 
    114115    # PAK: with "update" we can always build since it is fast 
    115116    if rebuild or not os.path.exists(build_path): 
     117======= 
     118    # Put the sas source tree on the path 
     119    addpath(joinpath(root, 'src')) 
     120 
     121    # Put sasmodels on the path 
     122    addpath(joinpath(root, '../sasmodels/')) 
     123 
     124    # Check if the C extensions are already built 
     125    try: 
     126        from sas.sascalc.pr import _pr_inversion 
     127        from sas.sascalc.calculator import _sld2i 
     128        from sas.sascalc.file_converter import _bsl_loader 
     129    except ImportError: 
     130        rebuild = True 
     131 
     132    # Build C extensions if necessary.  Do an inplace build to simplify path. 
     133    if rebuild: 
     134>>>>>>> master 
    116135        import subprocess 
    117         build_cmd = [sys.executable, "setup.py", "build", "update"] 
     136        build_cmd = [sys.executable, "setup.py", "build_ext", "--inplace", "update"] 
    118137        if os.name == 'nt': 
    119138            build_cmd.append('--compiler=tinycc') 
     
    122141        with cd(root): 
    123142            subprocess.call(build_cmd, shell=shell) 
    124  
    125     # Put the source trees on the path 
    126     addpath(joinpath(root, 'src')) 
    127  
    128     # sasmodels on the path 
    129     addpath(joinpath(root, '../sasmodels/')) 
    130  
    131     # The sas.models package Compiled Model files should be pulled in from the build directory even though 
    132     # the source is stored in src/sas/models. 
    133  
    134     # Compiled modules need to be pulled from the build directory. 
    135     # Some packages are not where they are needed, so load them explicitly. 
    136     import sas.sascalc.pr 
    137     sas.sascalc.pr.core = import_package('sas.sascalc.pr.core', 
    138                                          joinpath(build_path, 'sas', 'sascalc', 'pr', 'core')) 
    139  
    140     # Compiled modules need to be pulled from the build directory. 
    141     # Some packages are not where they are needed, so load them explicitly. 
    142     import sas.sascalc.file_converter 
    143     sas.sascalc.file_converter.core = import_package('sas.sascalc.file_converter.core', 
    144                                                      joinpath(build_path, 'sas', 'sascalc', 'file_converter', 'core')) 
    145  
    146     import sas.sascalc.calculator 
    147     sas.sascalc.calculator.core = import_package('sas.sascalc.calculator.core', 
    148                                                  joinpath(build_path, 'sas', 'sascalc', 'calculator', 'core')) 
    149  
    150     sys.path.append(build_path) 
    151143 
    152144    set_git_tag() 
  • setup.py

    rc16172d r952ea1f  
    1212import shutil 
    1313import sys 
    14 from distutils.command.build_ext import build_ext 
    15 from distutils.core import Command 
    1614 
    1715import numpy as np 
     16 
    1817from setuptools import Extension, setup 
     18from setuptools import Command 
     19from setuptools.command.build_ext import build_ext 
    1920 
    2021try: 
     
    2223except ImportError: 
    2324    pass 
     25 
     26# Convert "test" argument to "pytest" so 'python setup.py test' works 
     27sys.argv = [("pytest" if s == "test" else s) for s in sys.argv] 
    2428 
    2529# Manage version number ###################################### 
     
    246250# sas.sascalc.calculator 
    247251gen_dir = os.path.join("src", "sas", "sascalc", "calculator", "c_extensions") 
    248 package_dir["sas.sascalc.calculator.core"] = gen_dir 
    249252package_dir["sas.sascalc.calculator"] = os.path.join( 
    250253    "src", "sas", "sascalc", "calculator") 
    251 packages.extend(["sas.sascalc.calculator", "sas.sascalc.calculator.core"]) 
    252 ext_modules.append(Extension("sas.sascalc.calculator.core.sld2i", 
     254packages.append("sas.sascalc.calculator") 
     255ext_modules.append(Extension("sas.sascalc.calculator._sld2i", 
    253256                             sources=[ 
    254257                                 os.path.join(gen_dir, "sld2i_module.c"), 
     
    258261                             ], 
    259262                             include_dirs=[gen_dir], 
    260                              ) 
    261                    ) 
     263                             )) 
    262264 
    263265# sas.sascalc.pr 
    264266srcdir = os.path.join("src", "sas", "sascalc", "pr", "c_extensions") 
    265 package_dir["sas.sascalc.pr.core"] = srcdir 
    266267package_dir["sas.sascalc.pr"] = os.path.join("src", "sas", "sascalc", "pr") 
    267 packages.extend(["sas.sascalc.pr", "sas.sascalc.pr.core"]) 
    268 ext_modules.append(Extension("sas.sascalc.pr.core.pr_inversion", 
     268packages.append("sas.sascalc.pr") 
     269ext_modules.append(Extension("sas.sascalc.pr._pr_inversion", 
    269270                             sources=[os.path.join(srcdir, "Cinvertor.c"), 
    270271                                      os.path.join(srcdir, "invertor.c"), 
     
    276277# sas.sascalc.file_converter 
    277278mydir = os.path.join("src", "sas", "sascalc", "file_converter", "c_ext") 
    278 package_dir["sas.sascalc.file_converter.core"] = mydir 
    279279package_dir["sas.sascalc.file_converter"] = os.path.join( 
    280280    "src", "sas", "sascalc", "file_converter") 
    281 packages.extend(["sas.sascalc.file_converter", 
    282                  "sas.sascalc.file_converter.core"]) 
    283 ext_modules.append(Extension("sas.sascalc.file_converter.core.bsl_loader", 
     281packages.append("sas.sascalc.file_converter") 
     282ext_modules.append(Extension("sas.sascalc.file_converter._bsl_loader", 
    284283                             sources=[os.path.join(mydir, "bsl_loader.c")], 
    285284                             include_dirs=[np.get_include()], 
     
    443442    cmdclass={'build_ext': build_ext_subclass, 
    444443              'docs': BuildSphinxCommand, 
    445               'disable_openmp': DisableOpenMPCommand} 
     444              'disable_openmp': DisableOpenMPCommand}, 
     445    setup_requires=['pytest-runner'] if 'pytest' in sys.argv else [], 
     446    tests_require=['pytest'], 
    446447) 
  • src/sas/sascalc/calculator/c_extensions/sld2i_module.c

    ra1daf86 r7ba6470  
    22  SLD2I module to perform point and I calculations 
    33 */ 
     4#include <stdio.h> 
     5 
     6//#define Py_LIMITED_API 0x03020000 
    47#include <Python.h> 
    5 #include <stdio.h> 
     8 
    69#include "sld2i.h" 
    710 
     
    1316#endif 
    1417 
    15  
    16 // Utilities 
    17 #define INVECTOR(obj,buf,len)                                                                           \ 
    18     do { \ 
    19         int err = PyObject_AsReadBuffer(obj, (const void **)(&buf), &len); \ 
    20         if (err < 0) return NULL; \ 
    21         len /= sizeof(*buf); \ 
    22     } while (0) 
    23  
    24 #define OUTVECTOR(obj,buf,len) \ 
    25     do { \ 
    26         int err = PyObject_AsWriteBuffer(obj, (void **)(&buf), &len); \ 
    27         if (err < 0) return NULL; \ 
    28         len /= sizeof(*buf); \ 
    29     } while (0) 
    30  
     18// Vector binding glue 
     19#if (PY_VERSION_HEX > 0x03000000) && !defined(Py_LIMITED_API) 
     20  // Assuming that a view into a writable vector points to a  
     21  // non-changing pointer for the duration of the C call, capture  
     22  // the view pointer and immediately free the view. 
     23  #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 
     24    Py_buffer VEC_view; \ 
     25    int VEC_err = PyObject_GetBuffer(VEC_obj, &VEC_view, PyBUF_WRITABLE|PyBUF_FORMAT); \ 
     26    if (VEC_err < 0 || sizeof(*VEC_buf) != VEC_view.itemsize) return NULL; \ 
     27    VEC_buf = (typeof(VEC_buf))VEC_view.buf; \ 
     28    VEC_len = VEC_view.len/sizeof(*VEC_buf); \ 
     29    PyBuffer_Release(&VEC_view); \ 
     30  } while (0) 
     31#else 
     32  #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 
     33    int VEC_err = PyObject_AsWriteBuffer(VEC_obj, (void **)(&VEC_buf), &VEC_len); \ 
     34    if (VEC_err < 0) return NULL; \ 
     35    VEC_len /= sizeof(*VEC_buf); \ 
     36  } while (0) 
     37#endif 
    3138 
    3239/** 
     
    7380        //printf("new GenI\n"); 
    7481        if (!PyArg_ParseTuple(args, "iOOOOOOOOddd", &is_avg, &x_val_obj, &y_val_obj, &z_val_obj, &sldn_val_obj, &mx_val_obj, &my_val_obj, &mz_val_obj, &vol_pix_obj, &inspin, &outspin, &stheta)) return NULL; 
    75         INVECTOR(x_val_obj, x_val, n_x); 
    76         INVECTOR(y_val_obj, y_val, n_y); 
    77         INVECTOR(z_val_obj, z_val, n_z); 
    78         INVECTOR(sldn_val_obj, sldn_val, n_sld); 
    79         INVECTOR(mx_val_obj, mx_val, n_mx); 
    80         INVECTOR(my_val_obj, my_val, n_my); 
    81         INVECTOR(mz_val_obj, mz_val, n_mz); 
    82         INVECTOR(vol_pix_obj, vol_pix, n_vol_pix); 
     82        VECTOR(x_val_obj, x_val, n_x); 
     83        VECTOR(y_val_obj, y_val, n_y); 
     84        VECTOR(z_val_obj, z_val, n_z); 
     85        VECTOR(sldn_val_obj, sldn_val, n_sld); 
     86        VECTOR(mx_val_obj, mx_val, n_mx); 
     87        VECTOR(my_val_obj, my_val, n_my); 
     88        VECTOR(mz_val_obj, mz_val, n_mz); 
     89        VECTOR(vol_pix_obj, vol_pix, n_vol_pix); 
    8390        sld2i = PyMem_Malloc(sizeof(GenI)); 
    8491        //printf("sldi:%p\n", sld2i); 
     
    108115        if (!PyArg_ParseTuple(args, "OOOO",  &gen_obj, &qx_obj, &qy_obj, &I_out_obj)) return NULL; 
    109116        sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI"); 
    110         INVECTOR(qx_obj, qx, n_qx); 
    111         INVECTOR(qy_obj, qy, n_qy); 
    112         OUTVECTOR(I_out_obj, I_out, n_out); 
     117        VECTOR(qx_obj, qx, n_qx); 
     118        VECTOR(qy_obj, qy, n_qy); 
     119        VECTOR(I_out_obj, I_out, n_out); 
    113120        //printf("qx, qy, I_out: %d %d %d, %d %d %d\n", qx, qy, I_out, n_qx, n_qy, n_out); 
    114121 
     
    136143        if (!PyArg_ParseTuple(args, "OOO",  &gen_obj, &q_obj, &I_out_obj)) return NULL; 
    137144        sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI"); 
    138         INVECTOR(q_obj, q, n_q); 
    139         OUTVECTOR(I_out_obj, I_out, n_out); 
     145        VECTOR(q_obj, q, n_q); 
     146        VECTOR(I_out_obj, I_out, n_out); 
    140147 
    141148        // Sanity check 
     
    160167 
    161168#define MODULE_DOC "Sld2i C Library" 
    162 #define MODULE_NAME "sld2i" 
    163 #define MODULE_INIT2 initsld2i 
    164 #define MODULE_INIT3 PyInit_sld2i 
     169#define MODULE_NAME "_sld2i" 
     170#define MODULE_INIT2 init_sld2i 
     171#define MODULE_INIT3 PyInit__sld2i 
    165172#define MODULE_METHODS module_methods 
    166173 
  • src/sas/sascalc/calculator/sas_gen.py

    r144e032a r952ea1f  
    1414import numpy as np 
    1515 
    16 from .core import sld2i as mod 
     16from . import _sld2i 
    1717from .BaseComponent import BaseComponent 
    1818 
     
    145145            self.params['Up_frac_out'], 
    146146            self.params['Up_theta']) 
    147         model = mod.new_GenI(*args) 
     147        model = _sld2i.new_GenI(*args) 
    148148        if len(qy): 
    149149            qx, qy = _vec(qx), _vec(qy) 
    150150            I_out = np.empty_like(qx) 
    151151            #print("npoints", qx.shape, "npixels", pos_x.shape) 
    152             mod.genicomXY(model, qx, qy, I_out) 
     152            _sld2i.genicomXY(model, qx, qy, I_out) 
    153153            #print("I_out after", I_out) 
    154154        else: 
    155155            qx = _vec(qx) 
    156156            I_out = np.empty_like(qx) 
    157             mod.genicom(model, qx, I_out) 
     157            _sld2i.genicom(model, qx, I_out) 
    158158        vol_correction = self.data_total_volume / self.params['total_volume'] 
    159159        result = (self.params['scale'] * vol_correction * I_out 
     
    304304                z_dir2 *= z_dir2 
    305305                mask = (x_dir2 + y_dir2 + z_dir2) <= 1.0 
    306             except Exception: 
    307                 logger.error(sys.exc_value) 
     306            except Exception as exc: 
     307                logger.error(exc) 
    308308        self.output = MagSLD(self.pos_x[mask], self.pos_y[mask], 
    309309                             self.pos_z[mask], self.sld_n[mask], 
     
    600600                        y_lines.append(y_line) 
    601601                        z_lines.append(z_line) 
    602                 except Exception: 
    603                     logger.error(sys.exc_value) 
     602                except Exception as exc: 
     603                    logger.error(exc) 
    604604 
    605605            output = MagSLD(pos_x, pos_y, pos_z, sld_n, sld_mx, sld_my, sld_mz) 
     
    691691                            _vol_pix = float(toks[7]) 
    692692                            vol_pix = np.append(vol_pix, _vol_pix) 
    693                         except Exception: 
     693                        except Exception as exc: 
    694694                            vol_pix = None 
    695                     except Exception: 
     695                    except Exception as exc: 
    696696                        # Skip non-data lines 
    697                         logger.error(sys.exc_value) 
     697                        logger.error(exc) 
    698698            output = MagSLD(pos_x, pos_y, pos_z, sld_n, 
    699699                            sld_mx, sld_my, sld_mz) 
  • src/sas/sascalc/dataloader/file_reader_base_class.py

    r4a8d55c rfee520ec  
    276276                    dataset.xmax = np.max(dataset.qx_data) 
    277277                    dataset.ymin = np.min(dataset.qy_data) 
    278                     dataset.ymax = np.max(dataset.qx_data) 
     278                    dataset.ymax = np.max(dataset.qy_data) 
    279279 
    280280    def format_unit(self, unit=None): 
  • src/sas/sascalc/file_converter/bsl_loader.py

    rf00691d4 r952ea1f  
    1 from sas.sascalc.file_converter.core.bsl_loader import CLoader 
     1from sas.sascalc.file_converter._bsl_loader import CLoader 
    22from sas.sascalc.dataloader.data_info import Data2D 
    33from copy import deepcopy 
     
    6767                    'swap_bytes': int(metadata[3]) 
    6868                } 
    69             except: 
     69            except Exception: 
    7070                is_valid = False 
    7171                err_msg = "Invalid metadata in header file for {}" 
  • src/sas/sascalc/file_converter/c_ext/bsl_loader.c

    rd5aeaa3 r952ea1f  
     1#include <stdio.h> 
     2#include <stdlib.h> 
     3 
     4//#define Py_LIMITED_API 0x03020000 
    15#include <Python.h> 
     6#include <structmember.h> 
    27#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION 
    38#include <numpy/arrayobject.h> 
    4 #include <stdio.h> 
    5 #include <stdlib.h> 
    6 #include "structmember.h" 
     9 
    710#include "bsl_loader.h" 
    811 
     
    292295 
    293296#define MODULE_DOC "C module for loading bsl." 
    294 #define MODULE_NAME "bsl_loader" 
    295 #define MODULE_INIT2 initbsl_loader 
    296 #define MODULE_INIT3 PyInit_bsl_loader 
     297#define MODULE_NAME "_bsl_loader" 
     298#define MODULE_INIT2 init_bsl_loader 
     299#define MODULE_INIT3 PyInit__bsl_loader 
    297300#define MODULE_METHODS module_methods 
    298301 
  • src/sas/sascalc/pr/c_extensions/Cinvertor.c

    ra52f32f r7ba6470  
    55 * 
    66 */ 
    7 #include <Python.h> 
    8 #include "structmember.h" 
    97#include <stdio.h> 
    108#include <stdlib.h> 
     
    1210#include <time.h> 
    1311 
     12//#define Py_LIMITED_API 0x03050000 
     13#include <Python.h> 
     14#include <structmember.h> 
     15 
     16// Vector binding glue 
     17#if (PY_VERSION_HEX > 0x03000000) && !defined(Py_LIMITED_API) 
     18  // Assuming that a view into a writable vector points to a 
     19  // non-changing pointer for the duration of the C call, capture 
     20  // the view pointer and immediately free the view. 
     21  #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 
     22    Py_buffer VEC_view; \ 
     23    int VEC_err = PyObject_GetBuffer(VEC_obj, &VEC_view, PyBUF_WRITABLE|PyBUF_FORMAT); \ 
     24    if (VEC_err < 0 || sizeof(*VEC_buf) != VEC_view.itemsize) return NULL; \ 
     25    VEC_buf = (typeof(VEC_buf))VEC_view.buf; \ 
     26    VEC_len = VEC_view.len/sizeof(*VEC_buf); \ 
     27    PyBuffer_Release(&VEC_view); \ 
     28  } while (0) 
     29#else 
     30  #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 
     31    int VEC_err = PyObject_AsWriteBuffer(VEC_obj, (void **)(&VEC_buf), &VEC_len); \ 
     32    if (VEC_err < 0) return NULL; \ 
     33    VEC_len /= sizeof(*VEC_buf); \ 
     34  } while (0) 
     35#endif 
     36 
    1437#include "invertor.h" 
    15  
    1638 
    1739/// Error object for raised exceptions 
    1840PyObject * CinvertorError; 
    19  
    20 #define INVECTOR(obj,buf,len)                                                                           \ 
    21     do { \ 
    22         int err = PyObject_AsReadBuffer(obj, (const void **)(&buf), &len); \ 
    23         if (err < 0) return NULL; \ 
    24         len /= sizeof(*buf); \ 
    25     } while (0) 
    26  
    27 #define OUTVECTOR(obj,buf,len) \ 
    28     do { \ 
    29         int err = PyObject_AsWriteBuffer(obj, (void **)(&buf), &len); \ 
    30         if (err < 0) return NULL; \ 
    31         len /= sizeof(*buf); \ 
    32     } while (0) 
    33  
    3441 
    3542// Class definition 
     
    99106 
    100107        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    101         OUTVECTOR(data_obj,data,ndata); 
     108        VECTOR(data_obj,data,ndata); 
    102109 
    103110        free(self->params.x); 
     
    131138 
    132139        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    133         OUTVECTOR(data_obj, data, ndata); 
     140        VECTOR(data_obj, data, ndata); 
    134141 
    135142        // Check that the input array is large enough 
     
    164171 
    165172        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    166         OUTVECTOR(data_obj,data,ndata); 
     173        VECTOR(data_obj,data,ndata); 
    167174 
    168175        free(self->params.y); 
     
    196203 
    197204        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    198         OUTVECTOR(data_obj, data, ndata); 
     205        VECTOR(data_obj, data, ndata); 
    199206 
    200207        // Check that the input array is large enough 
     
    229236 
    230237        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    231         OUTVECTOR(data_obj,data,ndata); 
     238        VECTOR(data_obj,data,ndata); 
    232239 
    233240        free(self->params.err); 
     
    261268 
    262269        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    263         OUTVECTOR(data_obj, data, ndata); 
     270        VECTOR(data_obj, data, ndata); 
    264271 
    265272        // Check that the input array is large enough 
     
    517524        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    518525 
    519         OUTVECTOR(data_obj,pars,npars); 
     526        VECTOR(data_obj,pars,npars); 
    520527 
    521528    // PyList of residuals 
     
    568575        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    569576 
    570         OUTVECTOR(data_obj,pars,npars); 
     577        VECTOR(data_obj,pars,npars); 
    571578 
    572579        // Should create this list only once and refill it 
     
    609616 
    610617        if (!PyArg_ParseTuple(args, "Od", &data_obj, &q)) return NULL; 
    611         OUTVECTOR(data_obj,pars,npars); 
     618        VECTOR(data_obj,pars,npars); 
    612619 
    613620        iq_value = iq(pars, self->params.d_max, (int)npars, q); 
     
    634641 
    635642        if (!PyArg_ParseTuple(args, "Od", &data_obj, &q)) return NULL; 
    636         OUTVECTOR(data_obj,pars,npars); 
     643        VECTOR(data_obj,pars,npars); 
    637644 
    638645        iq_value = iq_smeared(pars, self->params.d_max, (int)npars, 
     
    659666 
    660667        if (!PyArg_ParseTuple(args, "Od", &data_obj, &r)) return NULL; 
    661         OUTVECTOR(data_obj,pars,npars); 
     668        VECTOR(data_obj,pars,npars); 
    662669 
    663670        pr_value = pr(pars, self->params.d_max, (int)npars, r); 
     
    686693 
    687694        if (!PyArg_ParseTuple(args, "OOd", &data_obj, &err_obj, &r)) return NULL; 
    688         OUTVECTOR(data_obj,pars,npars); 
     695        VECTOR(data_obj,pars,npars); 
    689696 
    690697        if (err_obj == Py_None) { 
     
    692699                pr_err_value = 0.0; 
    693700        } else { 
    694                 OUTVECTOR(err_obj,pars_err,npars2); 
     701                VECTOR(err_obj,pars_err,npars2); 
    695702                pr_err(pars, pars_err, self->params.d_max, (int)npars, r, &pr_value, &pr_err_value); 
    696703        } 
     
    726733 
    727734        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    728         OUTVECTOR(data_obj,pars,npars); 
     735        VECTOR(data_obj,pars,npars); 
    729736 
    730737        oscill = reg_term(pars, self->params.d_max, (int)npars, 100); 
     
    747754 
    748755        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    749         OUTVECTOR(data_obj,pars,npars); 
     756        VECTOR(data_obj,pars,npars); 
    750757 
    751758        count = npeaks(pars, self->params.d_max, (int)npars, 100); 
     
    768775 
    769776        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    770         OUTVECTOR(data_obj,pars,npars); 
     777        VECTOR(data_obj,pars,npars); 
    771778 
    772779        fraction = positive_integral(pars, self->params.d_max, (int)npars, 100); 
     
    792799 
    793800        if (!PyArg_ParseTuple(args, "OO", &data_obj, &err_obj)) return NULL; 
    794         OUTVECTOR(data_obj,pars,npars); 
    795         OUTVECTOR(err_obj,pars_err,npars2); 
     801        VECTOR(data_obj,pars,npars); 
     802        VECTOR(err_obj,pars_err,npars2); 
    796803 
    797804        fraction = positive_errors(pars, pars_err, self->params.d_max, (int)npars, 51); 
     
    813820 
    814821        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    815         OUTVECTOR(data_obj,pars,npars); 
     822        VECTOR(data_obj,pars,npars); 
    816823 
    817824        value = rg(pars, self->params.d_max, (int)npars, 101); 
     
    833840 
    834841        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    835         OUTVECTOR(data_obj,pars,npars); 
     842        VECTOR(data_obj,pars,npars); 
    836843 
    837844        value = 4.0*acos(-1.0)*int_pr(pars, self->params.d_max, (int)npars, 101); 
     
    874881 
    875882        if (!PyArg_ParseTuple(args, "iiOO", &nfunc, &nr, &a_obj, &b_obj)) return NULL; 
    876         OUTVECTOR(a_obj,a,n_a); 
    877         OUTVECTOR(b_obj,b,n_b); 
     883        VECTOR(a_obj,a,n_a); 
     884        VECTOR(b_obj,b,n_b); 
    878885 
    879886        assert(n_b>=nfunc); 
     
    947954 
    948955        if (!PyArg_ParseTuple(args, "iiOO", &nfunc, &nr, &a_obj, &cov_obj)) return NULL; 
    949         OUTVECTOR(a_obj,a,n_a); 
    950         OUTVECTOR(cov_obj,inv_cov,n_cov); 
     956        VECTOR(a_obj,a,n_a); 
     957        VECTOR(cov_obj,inv_cov,n_cov); 
    951958 
    952959        assert(n_cov>=nfunc*nfunc); 
     
    981988 
    982989        if (!PyArg_ParseTuple(args, "iiO", &nfunc, &nr, &a_obj)) return NULL; 
    983         OUTVECTOR(a_obj,a,n_a); 
     990        VECTOR(a_obj,a,n_a); 
    984991 
    985992        assert(n_a>=nfunc*(nr+self->params.npoints)); 
     
    11211128 
    11221129#define MODULE_DOC "C extension module for inversion to P(r)." 
    1123 #define MODULE_NAME "pr_inversion" 
    1124 #define MODULE_INIT2 initpr_inversion 
    1125 #define MODULE_INIT3 PyInit_pr_inversion 
     1130#define MODULE_NAME "_pr_inversion" 
     1131#define MODULE_INIT2 init_pr_inversion 
     1132#define MODULE_INIT3 PyInit__pr_inversion 
    11261133#define MODULE_METHODS module_methods 
    11271134 
  • src/sas/sascalc/pr/fit/BumpsFitting.py

    r9a5097c r3e6829d  
    22BumpsFitting module runs the bumps optimizer. 
    33""" 
     4from __future__ import division 
     5 
    46import os 
    57from datetime import timedelta, datetime 
     
    3436class Progress(object): 
    3537    def __init__(self, history, max_step, pars, dof): 
    36         remaining_time = int(history.time[0]*(float(max_step)/history.step[0]-1)) 
     38        remaining_time = int(history.time[0]*(max_step/history.step[0]-1)) 
    3739        # Depending on the time remaining, either display the expected 
    3840        # time of completion, or the amount of time remaining.  Use precision 
  • src/sas/sascalc/pr/fit/Loader.py

    r574adc7 r57e48ca  
     1""" 
     2class Loader  to load any kind of file 
     3""" 
     4 
    15from __future__ import print_function 
    26 
    3 # class Loader  to load any king of file 
    4 #import wx 
    5 #import string 
    67import numpy as np 
    78 
  • src/sas/sascalc/pr/invertor.py

    r2469df7 r57e48ca  
    66FIXME: The way the Invertor interacts with its C component should be cleaned up 
    77""" 
     8from __future__ import division 
    89 
    910import numpy as np 
     
    1718from numpy.linalg import lstsq 
    1819from scipy import optimize 
    19 from sas.sascalc.pr.core.pr_inversion import Cinvertor 
     20from sas.sascalc.pr._pr_inversion import Cinvertor 
    2021 
    2122logger = logging.getLogger(__name__) 
     
    7172        A[j][i] = (Fourier transformed base function for point j) 
    7273 
    73     We them choose a number of r-points, n_r, to evaluate the second 
     74    We then choose a number of r-points, n_r, to evaluate the second 
    7475    derivative of P(r) at. This is used as our regularization term. 
    7576    For a vector r of length n_r, the following n_r rows are set to :: 
     
    144145        x, y, err, d_max, q_min, q_max and alpha 
    145146        """ 
    146         if   name == 'x': 
     147        if name == 'x': 
    147148            if 0.0 in value: 
    148149                msg = "Invertor: one of your q-values is zero. " 
     
    268269            A[i][j] = (Fourier transformed base function for point j) 
    269270 
    270         We them choose a number of r-points, n_r, to evaluate the second 
     271        We then choose a number of r-points, n_r, to evaluate the second 
    271272        derivative of P(r) at. This is used as our regularization term. 
    272273        For a vector r of length n_r, the following n_r rows are set to :: 
     
    416417            A[i][j] = (Fourier transformed base function for point j) 
    417418 
    418         We them choose a number of r-points, n_r, to evaluate the second 
     419        We then choose a number of r-points, n_r, to evaluate the second 
    419420        derivative of P(r) at. This is used as our regularization term. 
    420421        For a vector r of length n_r, the following n_r rows are set to :: 
     
    473474 
    474475        # Perform the inversion (least square fit) 
    475         c, chi2, _, _ = lstsq(a, b) 
     476        c, chi2, _, _ = lstsq(a, b, rcond=-1) 
    476477        # Sanity check 
    477478        try: 
     
    496497        try: 
    497498            cov = np.linalg.pinv(inv_cov) 
    498             err = math.fabs(chi2 / float(npts - nfunc)) * cov 
    499         except: 
     499            err = math.fabs(chi2 / (npts - nfunc)) * cov 
     500        except Exception as exc: 
    500501            # We were not able to estimate the errors 
    501502            # Return an empty error matrix 
    502             logger.error(sys.exc_value) 
     503            logger.error(exc) 
    503504 
    504505        # Keep a copy of the last output 
     
    537538 
    538539        """ 
    539         from num_term import NTermEstimator 
     540        from .num_term import NTermEstimator 
    540541        estimator = NTermEstimator(self.clone()) 
    541542        try: 
    542543            return estimator.num_terms(isquit_func) 
    543         except: 
     544        except Exception as exc: 
    544545            # If we fail, estimate alpha and return the default 
    545546            # number of terms 
    546547            best_alpha, _, _ = self.estimate_alpha(self.nfunc) 
    547             logger.warning("Invertor.estimate_numterms: %s" % sys.exc_value) 
     548            logger.warning("Invertor.estimate_numterms: %s" % exc) 
    548549            return self.nfunc, best_alpha, "Could not estimate number of terms" 
    549550 
     
    631632                return best_alpha, message, elapsed 
    632633 
    633         except: 
    634             message = "Invertor.estimate_alpha: %s" % sys.exc_value 
     634        except Exception as exc: 
     635            message = "Invertor.estimate_alpha: %s" % exc 
    635636            return 0, message, elapsed 
    636637 
     
    748749                        self.cov[i][i] = float(toks2[1]) 
    749750 
    750             except: 
    751                 msg = "Invertor.from_file: corrupted file\n%s" % sys.exc_value 
     751            except Exception as exc: 
     752                msg = "Invertor.from_file: corrupted file\n%s" % exc 
    752753                raise RuntimeError(msg) 
    753754        else: 
  • src/sas/sascalc/pr/num_term.py

    r2469df7 r3e6829d  
    1 from __future__ import print_function 
     1from __future__ import print_function, division 
    22 
    33import math 
     
    5151        osc = self.sort_osc() 
    5252        dv = len(osc) 
    53         med = float(dv) / 2.0 
     53        med = 0.5*dv 
    5454        odd = self.is_odd(dv) 
    5555        medi = 0 
     
    140140            nts = self.compare_err() 
    141141            div = len(nts) 
    142             tem = float(div) / 2.0 
     142            tem = 0.5*div 
    143143            if self.is_odd(div): 
    144144                nt = nts[int(tem)] 
  • src/sas/sasgui/perspectives/fitting/basepage.py

    ra4a1ac9 r5323490  
    28842884            self.magnetic_on = True 
    28852885            button.SetLabel("Magnetic OFF") 
    2886             m_value = 1.0e-06 
     2886            m_value = 1 
    28872887            for key in self.model.magnetic_params: 
    28882888                if key.count('M0') > 0: 
    28892889                    self.model.setParam(key, m_value) 
    2890                     m_value += 0.5e-06 
     2890                    m_value += 0.5 
    28912891        else: 
    28922892            self.magnetic_on = False 
  • src/sas/sasgui/perspectives/fitting/gpu_options.py

    r388aefb r8e109f9  
    88''' 
    99 
     10import json 
     11import platform 
    1012import logging 
    1113import os 
    1214import sys 
     15 
    1316import wx 
     17 
     18try: 
     19    import pyopencl as cl 
     20except ImportError: 
     21    cl = None 
     22 
    1423import sasmodels 
     24import sasmodels.model_test 
     25import sasmodels.kernelcl 
     26 
    1527from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
    1628 
     
    169181        clinfo = [] 
    170182        platforms = [] 
    171         try: 
    172             import pyopencl as cl 
    173             platforms = cl.get_platforms() 
    174         except ImportError: 
     183 
     184        if cl is None: 
    175185            logger.warn("Unable to import the pyopencl package.  It may not " 
    176186                        "have been installed.  If you wish to use OpenCL, try " 
    177187                        "running pip install --user pyopencl") 
    178         except cl.LogicError as err: 
    179             logger.warn("Unable to fetch the OpenCL platforms.  This likely " 
    180                         "means that the opencl drivers for your system are " 
    181                         "not installed.") 
    182             logger.warn(err) 
     188        else: 
     189            try: 
     190                platforms = cl.get_platforms() 
     191            except cl.LogicError as err: 
     192                logger.warn("Unable to fetch the OpenCL platforms.  This likely " 
     193                            "means that the opencl drivers for your system are " 
     194                            "not installed.") 
     195                logger.warn(err) 
    183196 
    184197        p_index = 0 
     
    226239            if "SAS_OPENCL" in os.environ: 
    227240                del os.environ["SAS_OPENCL"] 
    228  
    229         #Sasmodels kernelcl doesn't exist when initiated with None 
    230         if 'sasmodels.kernelcl' in sys.modules: 
    231             sasmodels.kernelcl.ENV = None 
    232  
    233         reload(sasmodels.core) 
     241        sasmodels.kernelcl.reset_environment() 
    234242        event.Skip() 
    235243 
     
    247255        Run sasmodels check from here and report results from 
    248256        """ 
    249         import json 
    250         import platform 
    251         #import sasmodels 
    252  
    253257        #The same block of code as for OK but it is needed if we want to have 
    254258        #active response to Test button 
     
    261265            if "SAS_OPENCL" in os.environ: 
    262266                del os.environ["SAS_OPENCL"] 
    263  
    264         #Sasmodels kernelcl doesn't exist when initiated with None 
    265         if 'sasmodels.kernelcl' in sys.modules: 
    266             sasmodels.kernelcl.ENV = None 
    267  
    268  
    269         #Need to reload sasmodels.core module to account SAS_OPENCL = "None" 
    270         reload(sasmodels.core) 
    271  
    272  
    273         from sasmodels.model_test import model_tests 
     267        sasmodels.kernelcl.reset_environment() 
    274268 
    275269        try: 
    276             from sasmodels.kernelcl import environment 
    277             env = environment() 
     270            env = sasmodels.kernelcl.environment() 
    278271            clinfo = [(ctx.devices[0].platform.vendor, 
    279272                       ctx.devices[0].platform.version, 
     
    282275                       ctx.devices[0].version) 
    283276                      for ctx in env.context] 
    284         except ImportError: 
     277        except Exception: 
    285278            clinfo = None 
    286279 
    287280        failures = [] 
    288281        tests_completed = 0 
    289         for test in model_tests(): 
     282        for test in sasmodels.model_test.model_tests(): 
    290283            try: 
    291284                test() 
  • src/sas/sascalc/fit/BumpsFitting.py

    r1386b2f r0aeba4e  
    22BumpsFitting module runs the bumps optimizer. 
    33""" 
     4from __future__ import print_function 
     5 
    46import os 
    57from datetime import timedelta, datetime 
     
    911 
    1012from bumps import fitters 
     13 
    1114try: 
    1215    from bumps.options import FIT_CONFIG 
     16    # Preserve bumps default fitter in case someone wants it later 
     17    BUMPS_DEFAULT_FITTER = FIT_CONFIG.selected_id 
    1318    # Default bumps to use the Levenberg-Marquardt optimizer 
    1419    FIT_CONFIG.selected_id = fitters.LevenbergMarquardtFit.id 
     
    1722except ImportError: 
    1823    # CRUFT: Bumps changed its handling of fit options around 0.7.5.6 
     24    # Preserve bumps default fitter in case someone wants it later 
     25    BUMPS_DEFAULT_FITTER = fitters.FIT_DEFAULT 
    1926    # Default bumps to use the Levenberg-Marquardt optimizer 
    2027    fitters.FIT_DEFAULT = 'lm' 
     
    126133        if initial_values is not None: 
    127134            self._reset_pars(fitted, initial_values) 
     135        #print("constraints", constraints) 
    128136        self.constraints = dict(constraints) 
    129137        self.set_fitted(fitted) 
     
    222230    def _setup(self): 
    223231        exprs = {} 
    224         for M in self.models: 
    225             exprs.update((".".join((M.name, k)), v) for k, v in M.constraints.items()) 
     232        for model in self.models: 
     233            exprs.update((".".join((model.name, k)), v) 
     234                         for k, v in model.constraints.items()) 
    226235        if exprs: 
    227             symtab = dict((".".join((M.name, k)), p) 
    228                           for M in self.models 
    229                           for k, p in M.parameters().items()) 
     236            symtab = dict((".".join((model.name, k)), p) 
     237                          for model in self.models 
     238                          for k, p in model.parameters().items()) 
    230239            self.update = compile_constraints(symtab, exprs) 
    231240        else: 
  • src/sas/sascalc/fit/pagestate.py

    r863ac2c r1dc134e6  
    11""" 
    22Class that holds a fit page state 
     3 
     4Pagestate fields reflect the names of the gui controls from the sasview 3.x 
     5fit page, so they are somewhat difficult to interpret. 
     6 
     7Pagestate attributes are as follows: 
     8 
     9    # =>name: desc       indicates the attribute is derived 
     10    # name(xml): desc    indicates the attribute name differs from the xml tag 
     11 
     12    # SasView version which saved the file 
     13    version: (4, 1, 2) from <fitting_plug_in version="major.minor.point"> 
     14 
     15    # Session information 
     16    group_id: unique id for fit page in running system (int) 
     17    => data_group_id: unique id for data item in running system (None) 
     18 
     19    # Data file 
     20    data: contents of <SASdata> (Data1D or Data2D) 
     21    data_name: filename + [num] (latex_smeared.xml [1]) 
     22    data_id: filename + [num] + timestamp (latex_smeared.xml [1]1523303027.73) 
     23    file: filename + [date time] (latex_smeared.xml [Apr 09 15:45]) 
     24    name: ?? (None) 
     25    npts: number of points (float) 
     26    enable2D: True if data is 2D (or if model is 2D and no data) 
     27    is_data: True (pagestate will not save if there is no data attached) 
     28 
     29    # Data weighting 
     30    dI_didata: True if dy = data.dy 
     31    dI_idata: True if dy = data.y 
     32    dI_noweight: True if dy = 1 
     33    dI_sqrdata: True if dy = sqrt(data.y) 
     34 
     35    # Data selection 
     36    qmax: maximum q (float) 
     37    qmin: minimum q (float) 
     38    => qmax_x: ?? (None) 
     39    => qmin_x: ?? (None) 
     40 
     41    # Resolution smearing 
     42    enable_smearer: True if use data.dx 
     43    disable_smearer: True if no smearing 
     44    pinhole_smearer: True if custom pinhole smear 
     45    slit_smearer: True if custom slit smear 
     46    dq_l: 2D resolution <dQp> 
     47    dq_r: 2D resolution <dQs> 
     48    dx_old: True for 3.x version of custom pinhole, which used dx_min rather 
     49        than dx_percent, with dx_percent interpreted as 100 * dx_percent/q[0] 
     50    dx_percent: custom pinhole resolution percentage 
     51    dxl: slit height for custom slit resolution 
     52    dxw: slit width for custom slit resolution 
     53    smearer: repr() for active smearer (None on load) 
     54    smear_type: None (None on load) 
     55 
     56    # Model selection 
     57    categorycombobox: model category 
     58    formfactorcombobox: model name (could be "[plug-in] name") 
     59    structurecombobox: structure factor model name (string or None or "None") 
     60    multi_factor: multiplicity (integer or None) 
     61    magnetic_on: True if model is magnetic (only for 2D data for now) 
     62    => model: active model object (None on load) 
     63 
     64    # Model parameters 
     65    # Parameter is a tuple with the following structure.  The parentheses 
     66    # indicate xml attribute for the <parameter .../> tag: 
     67    #    fitted(selected_to_fit): True if parameter is fitted 
     68    #    name(name): display name for the parameter (string) 
     69    #    value(value): displayed parameter value (string) 
     70    #    => plusminus: '+/-' (constant string) 
     71    #    => uncertainty: tuple 
     72    #        (uncertainty_displayed): True if there is an uncertainty 
     73    #        (uncertainty_value): displayed uncertainty (string) 
     74    #    => lower: tuple 
     75    #        (minimum_displayed): True if there is a lower bound 
     76    #        (minimum_value): displayed lower bound (string) 
     77    #    => upper: tuple 
     78    #        (maximum_displayed): True if there is a upper bound 
     79    #        (maximum_value): displayed upper bound (string) 
     80    #    units(unit): displayed units 
     81    parameters: list of normal parameters 
     82    fixed_param: list of non-fitting parameters (nsigma, npts in dispersity) 
     83    fittable_param: list of fittable dispersity parameters (distribution width) 
     84    str_parameters: list of selection parameters (e.g, shell forms in spherical_sld) 
     85    orientation_params(orientation_parameters): list of orientation and 
     86        magnetic parameters (already included in parameters, so safe to ignore) 
     87    orientation_params_disp(dispersity_parameters): list of orientation 
     88        disperisty parameters (already included in fixed_param and 
     89        fittable_param so safe to ignore) 
     90 
     91    # Dispersity controls 
     92    enable_disp: True if dispersity parameters 
     93    disable_disp: True if no dispersity parameters 
     94    disp_obj_dict(disp_obj): {'parameter.width': 'dispersity distribution'} 
     95    values: {'parameter.width': [array distribution parameter values] } 
     96    weights: {'parameter.width': [array distribution parameter weights] } 
     97    => disp_box 0 
     98    => disp_cb_dict {} 
     99    => disp_list [] 
     100 
     101    # Simultaneous fitting 
     102 
     103    => images: None (initialized but unused?) 
     104    => reset: False (initialized but unused?) 
     105    => event_owner None 
     106    => m_name None 
     107    => manager None 
     108    => page_name 
     109    => param_toFit: [] 
     110    => process: list of process done on object [] (maybe managed by guiframe?) 
     111    => saved_states {} 
     112    => cb1: False (simfit cb1 is now stored in select_all) 
     113 
     114    tcChi 1.3463 
     115    theory_data None 
     116    timestamp 1523303103.74 
     117 
     118Constraint attributes are as follows: 
     119 
     120    constraint_dict {} 
     121    constraints_list 
     122        {'model_cbox': 'M2', 'param_cbox': 'scale', 'egal_txt': ' = ', 'constraint': 'M1.scale'} 
     123        {'model_cbox': 'M2', 'param_cbox': 'radius', 'egal_txt': ' = ', 'constraint': 'M1.radius'} 
     124        {'model_cbox': 'M2', 'param_cbox': 'radius.width', 'egal_txt': ' = ', 'constraint': 'M1.radius.width'} 
     125    fit_page_no None 
     126    model_list 
     127        {'fit_number': '393', 'checked': 'True', 'fit_page_source': 'M2', 'name': 'latex_smeared.xml   [1]1523535051.03', 'model_name': 'sphere'} 
     128        {'fit_number': '335', 'checked': 'True', 'fit_page_source': 'M1', 'name': 'latex_smeared.xml  1523535050.03', 'model_name': 'sphere'} 
     129    model_to_fit 
     130    no_constraint 0 
     131    select_all True 
     132 
     133 
    3134""" 
    4135# TODO: Refactor code so we don't need to use getattr/setattr 
     
    162293        self.theory_data = None 
    163294        # Is 2D 
    164         self.is_2D = False 
    165295        self.images = None 
    166296 
     
    557687        temp_parameters = [] 
    558688        temp_fittable_param = [] 
    559         if self.data.__class__.__name__ == "Data2D": 
    560             self.is_2D = True 
    561         else: 
    562             self.is_2D = False 
    563689        if self.data is not None: 
    564             if not self.is_2D: 
     690            is_2D = (self.data.__class__.__name__ == "Data2D") 
     691            if not is_2D: 
    565692                for item in self.parameters: 
    566693                    if item not in self.orientation_params: 
  • src/sas/sasgui/perspectives/fitting/fitpage.py

    rba1c145 r1dc134e6  
    5252        # draw sizer 
    5353        self._fill_data_sizer() 
    54         self.is_2D = None 
    5554        self.fit_started = False 
    5655        self.weightbt_string = None 
Note: See TracChangeset for help on using the changeset viewer.