Changeset 7af652d in sasview for src/sas


Ignore:
Timestamp:
Mar 5, 2019 4:26:14 PM (6 years ago)
Author:
GitHub <noreply@…>
Branches:
master, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1249
Children:
1342f6a
Parents:
dbfd307 (diff), 8c9e65c (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:
Paul Kienzle <pkienzle@…> (03/05/19 16:26:14)
git-committer:
GitHub <noreply@…> (03/05/19 16:26:14)
Message:

Merge branch 'master' into py37-sascalc

Location:
src/sas
Files:
4 added
5 deleted
35 edited

Legend:

Unmodified
Added
Removed

  • src/sas/_config.py

    rb963b20 r93b34cc  
    8686def setup_custom_config(app_dir, user_dir): 
    8787    path = make_custom_config_path(user_dir) 
     88    #logger.info("custom config path %s", path) 
    8889    if not os.path.isfile(path): 
    8990        try: 
    … …  
    9495            logger.error("Could not copy default custom config.") 
    9596 
     97    custom_config = load_custom_config(path) 
     98 
    9699    #Adding SAS_OPENCL if it doesn't exist in the config file 
    97100    # - to support backcompability 
    98     if not "SAS_OPENCL" in open(path).read(): 
     101    if not hasattr(custom_config, "SAS_OPENCL"): 
     102        custom_config.SAS_OPENCL = None 
    99103        try: 
    100             open(config_file, "a+").write("SAS_OPENCL = \"None\"\n") 
     104            open(path, "a+").write("SAS_OPENCL = \"None\"\n") 
    101105        except Exception: 
    102106            logger.error("Could not update custom config with SAS_OPENCL.") 
    103107 
    104     custom_config = load_custom_config(path) 
    105108    return custom_config 
    106  
    107109 
    108110def load_custom_config(path): 

  • 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/corfunc/transform_thread.py

    ra859f99 ref74a8b  
    4545            # gamma3(R) = 1/R int_{0}^{R} gamma1(x) dx 
    4646            # trapz uses the trapezium rule to calculate the integral 
    47             mask = xs <= 200.0 # Only calculate gamma3 up to x=200 (as this is all that's plotted) 
     47            mask = xs <= 1000.0 # Only calculate gamma3 up to x=1000 (as this is all that's plotted) 
    4848            # gamma3 = [trapz(gamma1[:n], xs[:n])/xs[n-1] for n in range(2, len(xs[mask]) + 1)]j 
    4949            # gamma3.insert(0, 1.0) # Gamma_3(0) is defined as 1 
    … …  
    7979 
    8080        transform1 = Data1D(xs, gamma1) 
    81         transform3 = Data1D(xs[xs <= 200], gamma3) 
     81        transform3 = Data1D(xs[xs <= 1000], gamma3) 
    8282        idf = Data1D(xs, idf) 
    8383 

  • src/sas/sascalc/data_util/nxsunit.py

    re090ba90 r8c9e65c  
    135135    sld = { '10^-6 Angstrom^-2': 1e-6, 'Angstrom^-2': 1 } 
    136136    Q = { 'invA': 1, 'invAng': 1, 'invAngstroms': 1, '1/A': 1, 
     137          '1/Angstrom': 1, '1/angstrom': 1, 'A^{-1}': 1, 'cm^{-1}': 1e-8, 
    137138          '10^-3 Angstrom^-1': 1e-3, '1/cm': 1e-8, '1/m': 1e-10, 
    138           'nm^-1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 } 
     139          'nm^{-1}': 1, 'nm^-1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 } 
    139140 
    140141    _caret_optional(sld) 
    … …  
    156157    # units for that particular dimension. 
    157158    # Note: don't have support for dimensionless units. 
    158     unknown = {None:1, '???':1, '': 1, 'a.u.': 1} 
     159    unknown = {None:1, '???':1, '': 1, 'a.u.': 1, 'Counts': 1, 'counts': 1} 
    159160 
    160161    def __init__(self, name): 

  • src/sas/sascalc/dataloader/data_info.py

    re090ba90 r8c9e65c  
    957957        _str += "Data:\n" 
    958958        _str += "   Type:         %s\n" % self.__class__.__name__ 
    959         _str += "   X- & Y-axis:  %s\t[%s]\n" % (self._yaxis, self._yunit) 
     959        _str += "   X-axis:       %s\t[%s]\n" % (self._xaxis, self._xunit) 
     960        _str += "   Y-axis:       %s\t[%s]\n" % (self._yaxis, self._yunit) 
    960961        _str += "   Z-axis:       %s\t[%s]\n" % (self._zaxis, self._zunit) 
    961962        _str += "   Length:       %g \n" % (len(self.data)) 
    … …  
    986987                           qx_data=qx_data, qy_data=qy_data, 
    987988                           q_data=q_data, mask=mask) 
     989 
     990        clone._xaxis = self._xaxis 
     991        clone._yaxis = self._yaxis 
     992        clone._zaxis = self._zaxis 
     993        clone._xunit = self._xunit 
     994        clone._yunit = self._yunit 
     995        clone._zunit = self._zunit 
     996        clone.x_bins = self.x_bins 
     997        clone.y_bins = self.y_bins 
    988998 
    989999        clone.title = self.title 
    … …  
    11561166def combine_data_info_with_plottable(data, datainfo): 
    11571167    """ 
    1158     A function that combines the DataInfo data in self.current_datainto with a plottable_1D or 2D data object. 
     1168    A function that combines the DataInfo data in self.current_datainto with a 
     1169    plottable_1D or 2D data object. 
    11591170 
    11601171    :param data: A plottable_1D or plottable_2D data object 
    … …  
    11741185        final_dataset.yaxis(data._yaxis, data._yunit) 
    11751186    elif isinstance(data, plottable_2D): 
    1176         final_dataset = Data2D(data.data, data.err_data, data.qx_data, data.qy_data, data.q_data, 
    1177                                data.mask, data.dqx_data, data.dqy_data) 
     1187        final_dataset = Data2D(data.data, data.err_data, data.qx_data, 
     1188                               data.qy_data, data.q_data, data.mask, 
     1189                               data.dqx_data, data.dqy_data) 
    11781190        final_dataset.xaxis(data._xaxis, data._xunit) 
    11791191        final_dataset.yaxis(data._yaxis, data._yunit) 
    11801192        final_dataset.zaxis(data._zaxis, data._zunit) 
    1181         if len(data.data.shape) == 2: 
    1182             n_rows, n_cols = data.data.shape 
    1183             final_dataset.y_bins = data.qy_data[0::int(n_cols)] 
    1184             final_dataset.x_bins = data.qx_data[:int(n_cols)] 
     1193        final_dataset.y_bins = data.y_bins 
     1194        final_dataset.x_bins = data.x_bins 
    11851195    else: 
    1186         return_string = "Should Never Happen: _combine_data_info_with_plottable input is not a plottable1d or " + \ 
    1187                         "plottable2d data object" 
     1196        return_string = ("Should Never Happen: _combine_data_info_with_plottabl" 
     1197                         "e input is not a plottable1d or plottable2d data " 
     1198                         "object") 
    11881199        return return_string 
    11891200 

  • src/sas/sascalc/dataloader/file_reader_base_class.py

    r4a8d55c rc222c27  
    1616from .data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\ 
    1717    combine_data_info_with_plottable 
     18from sas.sascalc.data_util.nxsunit import Converter 
    1819 
    1920logger = logging.getLogger(__name__) 
    … …  
    3738                       "SasView cannot guarantee the accuracy of the data.") 
    3839 
     40 
    3941class FileReader(object): 
    4042    # String to describe the type of data this reader can load 
    … …  
    4547    ext = ['.txt'] 
    4648    # Deprecated extensions 
    47     deprecated_extensions = ['.asc', '.nxs'] 
     49    deprecated_extensions = ['.asc'] 
    4850    # Bypass extension check and try to load anyway 
    4951    allow_all = False 
    … …  
    98100                    if len(self.output) > 0: 
    99101                        # Sort the data that's been loaded 
    100                         self.sort_one_d_data() 
    101                         self.sort_two_d_data() 
     102                        self.convert_data_units() 
     103                        self.sort_data() 
    102104        else: 
    103105            msg = "Unable to find file at: {}\n".format(filepath) 
    … …  
    140142        Returns the entire file as a string. 
    141143        """ 
    142         #return self.f_open.read() 
    143144        return decode(self.f_open.read()) 
    144145 
    … …  
    166167        self.output.append(data_obj) 
    167168 
    168     def sort_one_d_data(self): 
     169    def sort_data(self): 
    169170        """ 
    170171        Sort 1D data along the X axis for consistency 
    … …  
    174175                # Normalize the units for 
    175176                data.x_unit = self.format_unit(data.x_unit) 
     177                data._xunit = data.x_unit 
    176178                data.y_unit = self.format_unit(data.y_unit) 
     179                data._yunit = data.y_unit 
    177180                # Sort data by increasing x and remove 1st point 
    178181                ind = np.lexsort((data.y, data.x)) 
    … …  
    203206                    data.ymin = np.min(data.y) 
    204207                    data.ymax = np.max(data.y) 
     208            elif isinstance(data, Data2D): 
     209                # Normalize the units for 
     210                data.Q_unit = self.format_unit(data.Q_unit) 
     211                data.I_unit = self.format_unit(data.I_unit) 
     212                data._xunit = data.Q_unit 
     213                data._yunit = data.Q_unit 
     214                data._zunit = data.I_unit 
     215                data.data = data.data.astype(np.float64) 
     216                data.qx_data = data.qx_data.astype(np.float64) 
     217                data.xmin = np.min(data.qx_data) 
     218                data.xmax = np.max(data.qx_data) 
     219                data.qy_data = data.qy_data.astype(np.float64) 
     220                data.ymin = np.min(data.qy_data) 
     221                data.ymax = np.max(data.qy_data) 
     222                data.q_data = np.sqrt(data.qx_data * data.qx_data 
     223                                         + data.qy_data * data.qy_data) 
     224                if data.err_data is not None: 
     225                    data.err_data = data.err_data.astype(np.float64) 
     226                if data.dqx_data is not None: 
     227                    data.dqx_data = data.dqx_data.astype(np.float64) 
     228                if data.dqy_data is not None: 
     229                    data.dqy_data = data.dqy_data.astype(np.float64) 
     230                if data.mask is not None: 
     231                    data.mask = data.mask.astype(dtype=bool) 
     232 
     233                if len(data.data.shape) == 2: 
     234                    n_rows, n_cols = data.data.shape 
     235                    data.y_bins = data.qy_data[0::int(n_cols)] 
     236                    data.x_bins = data.qx_data[:int(n_cols)] 
     237                    data.data = data.data.flatten() 
     238                data = self._remove_nans_in_data(data) 
     239                if len(data.data) > 0: 
     240                    data.xmin = np.min(data.qx_data) 
     241                    data.xmax = np.max(data.qx_data) 
     242                    data.ymin = np.min(data.qy_data) 
     243                    data.ymax = np.max(data.qy_data) 
    205244 
    206245    @staticmethod 
    … …  
    242281        return data 
    243282 
    244     def sort_two_d_data(self): 
    245         for dataset in self.output: 
    246             if isinstance(dataset, Data2D): 
    247                 # Normalize the units for 
    248                 dataset.x_unit = self.format_unit(dataset.Q_unit) 
    249                 dataset.y_unit = self.format_unit(dataset.I_unit) 
    250                 dataset.data = dataset.data.astype(np.float64) 
    251                 dataset.qx_data = dataset.qx_data.astype(np.float64) 
    252                 dataset.xmin = np.min(dataset.qx_data) 
    253                 dataset.xmax = np.max(dataset.qx_data) 
    254                 dataset.qy_data = dataset.qy_data.astype(np.float64) 
    255                 dataset.ymin = np.min(dataset.qy_data) 
    256                 dataset.ymax = np.max(dataset.qy_data) 
    257                 dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data 
    258                                          + dataset.qy_data * dataset.qy_data) 
    259                 if dataset.err_data is not None: 
    260                     dataset.err_data = dataset.err_data.astype(np.float64) 
    261                 if dataset.dqx_data is not None: 
    262                     dataset.dqx_data = dataset.dqx_data.astype(np.float64) 
    263                 if dataset.dqy_data is not None: 
    264                     dataset.dqy_data = dataset.dqy_data.astype(np.float64) 
    265                 if dataset.mask is not None: 
    266                     dataset.mask = dataset.mask.astype(dtype=bool) 
    267  
    268                 if len(dataset.data.shape) == 2: 
    269                     n_rows, n_cols = dataset.data.shape 
    270                     dataset.y_bins = dataset.qy_data[0::int(n_cols)] 
    271                     dataset.x_bins = dataset.qx_data[:int(n_cols)] 
    272                 dataset.data = dataset.data.flatten() 
    273                 dataset = self._remove_nans_in_data(dataset) 
    274                 if len(dataset.data) > 0: 
    275                     dataset.xmin = np.min(dataset.qx_data) 
    276                     dataset.xmax = np.max(dataset.qx_data) 
    277                     dataset.ymin = np.min(dataset.qy_data) 
    278                     dataset.ymax = np.max(dataset.qx_data) 
     283    @staticmethod 
     284    def set_default_1d_units(data): 
     285        """ 
     286        Set the x and y axes to the default 1D units 
     287        :param data: 1D data set 
     288        :return: 
     289        """ 
     290        data.xaxis(r"\rm{Q}", '1/A') 
     291        data.yaxis(r"\rm{Intensity}", "1/cm") 
     292        return data 
     293 
     294    @staticmethod 
     295    def set_default_2d_units(data): 
     296        """ 
     297        Set the x and y axes to the default 2D units 
     298        :param data: 2D data set 
     299        :return: 
     300        """ 
     301        data.xaxis("\\rm{Q_{x}}", '1/A') 
     302        data.yaxis("\\rm{Q_{y}}", '1/A') 
     303        data.zaxis("\\rm{Intensity}", "1/cm") 
     304        return data 
     305 
     306    def convert_data_units(self, default_q_unit="1/A"): 
     307        """ 
     308        Converts al; data to the sasview default of units of A^{-1} for Q and 
     309        cm^{-1} for I. 
     310        :param default_q_unit: The default Q unit used by Sasview 
     311        """ 
     312        convert_q = True 
     313        new_output = [] 
     314        for data in self.output: 
     315            if data.isSesans: 
     316                new_output.append(data) 
     317                continue 
     318            try: 
     319                file_x_unit = data._xunit 
     320                data_conv_x = Converter(file_x_unit) 
     321            except KeyError: 
     322                logger.info("Unrecognized Q units in data file. No data " 
     323                            "conversion attempted") 
     324                convert_q = False 
     325            try: 
     326 
     327                if isinstance(data, Data1D): 
     328                        if convert_q: 
     329                            data.x = data_conv_x(data.x, units=default_q_unit) 
     330                            data._xunit = default_q_unit 
     331                            data.x_unit = default_q_unit 
     332                            if data.dx is not None: 
     333                                data.dx = data_conv_x(data.dx, 
     334                                                      units=default_q_unit) 
     335                            if data.dxl is not None: 
     336                                data.dxl = data_conv_x(data.dxl, 
     337                                                       units=default_q_unit) 
     338                            if data.dxw is not None: 
     339                                data.dxw = data_conv_x(data.dxw, 
     340                                                       units=default_q_unit) 
     341                elif isinstance(data, Data2D): 
     342                    if convert_q: 
     343                        data.qx_data = data_conv_x(data.qx_data, 
     344                                                   units=default_q_unit) 
     345                        if data.dqx_data is not None: 
     346                            data.dqx_data = data_conv_x(data.dqx_data, 
     347                                                        units=default_q_unit) 
     348                        try: 
     349                            file_y_unit = data._yunit 
     350                            data_conv_y = Converter(file_y_unit) 
     351                            data.qy_data = data_conv_y(data.qy_data, 
     352                                                       units=default_q_unit) 
     353                            if data.dqy_data is not None: 
     354                                data.dqy_data = data_conv_y(data.dqy_data, 
     355                                                            units=default_q_unit) 
     356                        except KeyError: 
     357                            logger.info("Unrecognized Qy units in data file. No" 
     358                                        " data conversion attempted") 
     359            except KeyError: 
     360                message = "Unable to convert Q units from {0} to 1/A." 
     361                message.format(default_q_unit) 
     362                data.errors.append(message) 
     363            new_output.append(data) 
     364        self.output = new_output 
    279365 
    280366    def format_unit(self, unit=None): 
    … …  
    367453                    self.current_dataset.qy_data)) 
    368454            if has_error_dy: 
    369                 self.current_dataset.err_data = self.current_dataset.err_data[x != 0] 
     455                self.current_dataset.err_data = self.current_dataset.err_data[ 
     456                    x != 0] 
    370457            if has_error_dqx: 
    371                 self.current_dataset.dqx_data = self.current_dataset.dqx_data[x != 0] 
     458                self.current_dataset.dqx_data = self.current_dataset.dqx_data[ 
     459                    x != 0] 
    372460            if has_error_dqy: 
    373                 self.current_dataset.dqy_data = self.current_dataset.dqy_data[x != 0] 
     461                self.current_dataset.dqy_data = self.current_dataset.dqy_data[ 
     462                    x != 0] 
    374463            if has_mask: 
    375464                self.current_dataset.mask = self.current_dataset.mask[x != 0] 

  • src/sas/sascalc/dataloader/loader.py

    re090ba90 r8c9e65c  
    367367            try: 
    368368                return fn(path, data) 
    369             except Exception: 
    370                 pass  # give other loaders a chance to succeed 
    371         # If we get here it is because all loaders failed 
    372         raise  # reraises last exception 
     369            except Exception as exc: 
     370                msg = "Saving file {} using the {} writer failed.\n".format( 
     371                    path, type(fn).__name__) 
     372                msg += str(exc) 
     373                logger.exception(msg)  # give other loaders a chance to succeed 
    373374 
    374375 

  • src/sas/sascalc/dataloader/readers/abs_reader.py

    rbd5c3b1 rd96744de  
    4848        detector = Detector() 
    4949        data_line = 0 
     50        x_index = 4 
    5051        self.reset_data_list(len(lines)) 
    5152        self.current_datainfo.detector.append(detector) 
    … …  
    6364        for line in lines: 
    6465            # Information line 1 
     66            if line.find(".bt5") > 0: 
     67                x_index = 0 
    6568            if is_info: 
    6669                is_info = False 
    … …  
    171174 
    172175                try: 
    173                     _x = float(toks[4]) 
     176                    _x = float(toks[x_index]) 
    174177                    _y = float(toks[1]) 
    175178                    _dy = float(toks[2]) 
    … …  
    225228            raise ValueError("ascii_reader: could not load file") 
    226229 
     230        self.current_dataset = self.set_default_1d_units(self.current_dataset) 
    227231        if data_conv_q is not None: 
    228232            self.current_dataset.xaxis("\\rm{Q}", base_q_unit) 
    229         else: 
    230             self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}') 
    231233        if data_conv_i is not None: 
    232234            self.current_dataset.yaxis("\\rm{Intensity}", base_i_unit) 
    233         else: 
    234             self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}") 
    235235 
    236236        # Store loading process information 

  • src/sas/sascalc/dataloader/readers/ascii_reader.py

    r9e6aeaf r3bab401  
    157157 
    158158        self.remove_empty_q_values() 
    159         self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}') 
    160         self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}") 
     159        self.current_dataset = self.set_default_1d_units(self.current_dataset) 
    161160 
    162161        # Store loading process information 

  • src/sas/sascalc/dataloader/readers/associations.py

    re090ba90 r8c9e65c  
    2323    ".ses": "sesans_reader", 
    2424    ".h5": "cansas_reader_HDF5", 
     25    ".nxs": "cansas_reader_HDF5", 
    2526    ".txt": "ascii_reader", 
    2627    ".dat": "red2d_reader", 

  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    re090ba90 r8c9e65c  
    812812            node.append(point) 
    813813            self.write_node(point, "Q", datainfo.x[i], 
    814                             {'unit': datainfo.x_unit}) 
     814                            {'unit': datainfo._xunit}) 
    815815            if len(datainfo.y) >= i: 
    816816                self.write_node(point, "I", datainfo.y[i], 
    817                                 {'unit': datainfo.y_unit}) 
     817                                {'unit': datainfo._yunit}) 
    818818            if datainfo.dy is not None and len(datainfo.dy) > i: 
    819819                self.write_node(point, "Idev", datainfo.dy[i], 
    820                                 {'unit': datainfo.y_unit}) 
     820                                {'unit': datainfo._yunit}) 
    821821            if datainfo.dx is not None and len(datainfo.dx) > i: 
    822822                self.write_node(point, "Qdev", datainfo.dx[i], 
    823                                 {'unit': datainfo.x_unit}) 
     823                                {'unit': datainfo._xunit}) 
    824824            if datainfo.dxw is not None and len(datainfo.dxw) > i: 
    825825                self.write_node(point, "dQw", datainfo.dxw[i], 
    826                                 {'unit': datainfo.x_unit}) 
     826                                {'unit': datainfo._xunit}) 
    827827            if datainfo.dxl is not None and len(datainfo.dxl) > i: 
    828828                self.write_node(point, "dQl", datainfo.dxl[i], 
    829                                 {'unit': datainfo.x_unit}) 
     829                                {'unit': datainfo._xunit}) 
    830830        if datainfo.isSesans: 
    831831            sesans_attrib = {'x_axis': datainfo._xaxis, 

  • src/sas/sascalc/dataloader/readers/danse_reader.py

    r2469df7 rfc51d06  
    180180        detector.beam_center.y = center_y * pixel 
    181181 
    182  
    183         self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
    184         self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
    185         self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}") 
    186  
     182        self.current_dataset = self.set_default_2d_units(self.current_dataset) 
    187183        self.current_dataset.x_bins = x_vals 
    188184        self.current_dataset.y_bins = y_vals 

  • src/sas/sascalc/dataloader/readers/red2d_reader.py

    rc8321cfc r058f6c3  
    317317 
    318318        # Units of axes 
    319         self.current_dataset.xaxis(r"\rm{Q_{x}}", 'A^{-1}') 
    320         self.current_dataset.yaxis(r"\rm{Q_{y}}", 'A^{-1}') 
    321         self.current_dataset.zaxis(r"\rm{Intensity}", "cm^{-1}") 
     319        self.current_dataset = self.set_default_2d_units(self.current_dataset) 
    322320 
    323321        # Store loading process information 

  • 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/file_converter/nxcansas_writer.py

    r574adc7 r109afbd  
    88import os 
    99 
    10 from sas.sascalc.dataloader.readers.cansas_reader_HDF5 import Reader as Cansas2Reader 
     10from sas.sascalc.dataloader.readers.cansas_reader_HDF5 import Reader 
    1111from sas.sascalc.dataloader.data_info import Data1D, Data2D 
    1212 
    13 class NXcanSASWriter(Cansas2Reader): 
     13class NXcanSASWriter(Reader): 
    1414    """ 
    1515    A class for writing in NXcanSAS data files. Any number of data sets may be 
    … …  
    8787                    entry[names[2]].attrs['units'] = units 
    8888 
    89         valid_data = all([issubclass(d.__class__, (Data1D, Data2D)) for d in dataset]) 
     89        valid_data = all([isinstance(d, (Data1D, Data2D)) for d in dataset]) 
    9090        if not valid_data: 
    91             raise ValueError("All entries of dataset must be Data1D or Data2D objects") 
     91            raise ValueError("All entries of dataset must be Data1D or Data2D" 
     92                             "objects") 
    9293 
    9394        # Get run name and number from first Data object 
    … …  
    109110        sasentry.attrs['version'] = '1.0' 
    110111 
    111         i = 1 
    112  
    113         for data_obj in dataset: 
    114             data_entry = sasentry.create_group("sasdata{0:0=2d}".format(i)) 
     112        for i, data_obj in enumerate(dataset): 
     113            data_entry = sasentry.create_group("sasdata{0:0=2d}".format(i+1)) 
    115114            data_entry.attrs['canSAS_class'] = 'SASdata' 
    116115            if isinstance(data_obj, Data1D): 
    … …  
    118117            elif isinstance(data_obj, Data2D): 
    119118                self._write_2d_data(data_obj, data_entry) 
    120             i += 1 
    121119 
    122120        data_info = dataset[0] 
    … …  
    148146                sample_entry.create_dataset('details', data=details) 
    149147 
    150         # Instrumment metadata 
     148        # Instrument metadata 
    151149        instrument_entry = sasentry.create_group('sasinstrument') 
    152150        instrument_entry.attrs['canSAS_class'] = 'SASinstrument' 
    … …  
    176174            units=data_info.source.beam_size_unit, write_fn=_write_h5_float) 
    177175 
    178  
    179176        # Collimation metadata 
    180177        if len(data_info.collimation) > 0: 
    181             i = 1 
    182             for coll_info in data_info.collimation: 
     178            for i, coll_info in enumerate(data_info.collimation): 
    183179                collimation_entry = instrument_entry.create_group( 
    184                     'sascollimation{0:0=2d}'.format(i)) 
     180                    'sascollimation{0:0=2d}'.format(i + 1)) 
    185181                collimation_entry.attrs['canSAS_class'] = 'SAScollimation' 
    186182                if coll_info.length is not None: 
    187183                    _write_h5_float(collimation_entry, coll_info.length, 'SDD') 
    188                     collimation_entry['SDD'].attrs['units'] = coll_info.length_unit 
     184                    collimation_entry['SDD'].attrs['units'] =\ 
     185                        coll_info.length_unit 
    189186                if coll_info.name is not None: 
    190187                    collimation_entry['name'] = _h5_string(coll_info.name) 
    191188        else: 
    192             # Create a blank one - at least 1 set of collimation metadata 
    193             # required by format 
    194             collimation_entry = instrument_entry.create_group('sascollimation01') 
     189            # Create a blank one - at least 1 collimation required by format 
     190            instrument_entry.create_group('sascollimation01') 
    195191 
    196192        # Detector metadata 
    197193        if len(data_info.detector) > 0: 
    198194            i = 1 
    199             for det_info in data_info.detector: 
     195            for i, det_info in enumerate(data_info.detector): 
    200196                detector_entry = instrument_entry.create_group( 
    201                     'sasdetector{0:0=2d}'.format(i)) 
     197                    'sasdetector{0:0=2d}'.format(i + 1)) 
    202198                detector_entry.attrs['canSAS_class'] = 'SASdetector' 
    203199                if det_info.distance is not None: 
    204200                    _write_h5_float(detector_entry, det_info.distance, 'SDD') 
    205                     detector_entry['SDD'].attrs['units'] = det_info.distance_unit 
     201                    detector_entry['SDD'].attrs['units'] =\ 
     202                        det_info.distance_unit 
    206203                if det_info.name is not None: 
    207204                    detector_entry['name'] = _h5_string(det_info.name) 
    … …  
    209206                    detector_entry['name'] = _h5_string('') 
    210207                if det_info.slit_length is not None: 
    211                     _write_h5_float(detector_entry, det_info.slit_length, 'slit_length') 
    212                     detector_entry['slit_length'].attrs['units'] = det_info.slit_length_unit 
     208                    _write_h5_float(detector_entry, det_info.slit_length, 
     209                                    'slit_length') 
     210                    detector_entry['slit_length'].attrs['units'] =\ 
     211                        det_info.slit_length_unit 
    213212                _write_h5_vector(detector_entry, det_info.offset) 
    214213                # NXcanSAS doesn't save information about pitch, only roll 
    … …  
    224223                    names=['x_pixel_size', 'y_pixel_size'], 
    225224                    write_fn=_write_h5_float, units=det_info.pixel_size_unit) 
    226  
    227                 i += 1 
    228225        else: 
    229226            # Create a blank one - at least 1 detector required by format 
    … …  
    231228            detector_entry.attrs['canSAS_class'] = 'SASdetector' 
    232229            detector_entry.attrs['name'] = '' 
     230 
     231        # Process meta data 
     232        for i, process in enumerate(data_info.process): 
     233            process_entry = sasentry.create_group('sasprocess{0:0=2d}'.format( 
     234                i + 1)) 
     235            process_entry.attrs['canSAS_class'] = 'SASprocess' 
     236            if process.name: 
     237                name = _h5_string(process.name) 
     238                process_entry.create_dataset('name', data=name) 
     239            if process.date: 
     240                date = _h5_string(process.date) 
     241                process_entry.create_dataset('date', data=date) 
     242            if process.description: 
     243                desc = _h5_string(process.description) 
     244                process_entry.create_dataset('description', data=desc) 
     245            for j, term in enumerate(process.term): 
     246                # Don't save empty terms 
     247                if term: 
     248                    h5_term = _h5_string(term) 
     249                    process_entry.create_dataset('term{0:0=2d}'.format( 
     250                        j + 1), data=h5_term) 
     251            for j, note in enumerate(process.notes): 
     252                # Don't save empty notes 
     253                if note: 
     254                    h5_note = _h5_string(note) 
     255                    process_entry.create_dataset('note{0:0=2d}'.format( 
     256                        j + 1), data=h5_note) 
     257 
     258        # Transmission Spectrum 
     259        for i, trans in enumerate(data_info.trans_spectrum): 
     260            trans_entry = sasentry.create_group( 
     261                'sastransmission_spectrum{0:0=2d}'.format(i + 1)) 
     262            trans_entry.attrs['canSAS_class'] = 'SAStransmission_spectrum' 
     263            trans_entry.attrs['signal'] = 'T' 
     264            trans_entry.attrs['T_axes'] = 'T' 
     265            trans_entry.attrs['name'] = trans.name 
     266            if trans.timestamp is not '': 
     267                trans_entry.attrs['timestamp'] = trans.timestamp 
     268            transmission = trans_entry.create_dataset('T', 
     269                                                      data=trans.transmission) 
     270            transmission.attrs['unertainties'] = 'Tdev' 
     271            trans_entry.create_dataset('Tdev', 
     272                                       data=trans.transmission_deviation) 
     273            trans_entry.create_dataset('lambda', data=trans.wavelength) 
    233274 
    234275        note_entry = sasentry.create_group('sasnote'.format(i)) 
    … …  
    254295        data_entry.attrs['signal'] = 'I' 
    255296        data_entry.attrs['I_axes'] = 'Q' 
    256         data_entry.attrs['I_uncertainties'] = 'Idev' 
    257         data_entry.attrs['Q_indicies'] = 0 
    258  
    259         dI = data_obj.dy 
    260         if dI is None: 
    261             dI = np.zeros((data_obj.y.shape)) 
    262  
    263         data_entry.create_dataset('Q', data=data_obj.x) 
    264         data_entry.create_dataset('I', data=data_obj.y) 
    265         data_entry.create_dataset('Idev', data=dI) 
     297        data_entry.attrs['Q_indices'] = [0] 
     298        q_entry = data_entry.create_dataset('Q', data=data_obj.x) 
     299        q_entry.attrs['units'] = data_obj.x_unit 
     300        i_entry = data_entry.create_dataset('I', data=data_obj.y) 
     301        i_entry.attrs['units'] = data_obj.y_unit 
     302        if data_obj.dy is not None: 
     303            i_entry.attrs['uncertainties'] = 'Idev' 
     304            i_dev_entry = data_entry.create_dataset('Idev', data=data_obj.dy) 
     305            i_dev_entry.attrs['units'] = data_obj.y_unit 
     306        if data_obj.dx is not None: 
     307            q_entry.attrs['resolutions'] = 'dQ' 
     308            dq_entry = data_entry.create_dataset('dQ', data=data_obj.dx) 
     309            dq_entry.attrs['units'] = data_obj.x_unit 
     310        elif data_obj.dxl is not None: 
     311            q_entry.attrs['resolutions'] = ['dQl','dQw'] 
     312            dql_entry = data_entry.create_dataset('dQl', data=data_obj.dxl) 
     313            dql_entry.attrs['units'] = data_obj.x_unit 
     314            dqw_entry = data_entry.create_dataset('dQw', data=data_obj.dxw) 
     315            dqw_entry.attrs['units'] = data_obj.x_unit 
    266316 
    267317    def _write_2d_data(self, data, data_entry): 
    … …  
    273323        """ 
    274324        data_entry.attrs['signal'] = 'I' 
    275         data_entry.attrs['I_axes'] = 'Q,Q' 
    276         data_entry.attrs['I_uncertainties'] = 'Idev' 
    277         data_entry.attrs['Q_indicies'] = [0,1] 
     325        data_entry.attrs['I_axes'] = 'Qx,Qy' 
     326        data_entry.attrs['Q_indices'] = [0,1] 
    278327 
    279328        (n_rows, n_cols) = (len(data.y_bins), len(data.x_bins)) 
    280329 
    281         if n_rows == 0 and n_cols == 0: 
     330        if (n_rows == 0 and n_cols == 0) or (n_cols*n_rows != data.data.size): 
    282331            # Calculate rows and columns, assuming detector is square 
    283332            # Same logic as used in PlotPanel.py _get_bins 
    … …  
    288337                raise ValueError("Unable to calculate dimensions of 2D data") 
    289338 
    290         I = np.reshape(data.data, (n_rows, n_cols)) 
    291         dI = np.zeros((n_rows, n_cols)) 
    292         if not all(data.err_data == [None]): 
    293             dI = np.reshape(data.err_data, (n_rows, n_cols)) 
    294         qx =  np.reshape(data.qx_data, (n_rows, n_cols)) 
     339        intensity = np.reshape(data.data, (n_rows, n_cols)) 
     340        qx = np.reshape(data.qx_data, (n_rows, n_cols)) 
    295341        qy = np.reshape(data.qy_data, (n_rows, n_cols)) 
    296342 
    297         I_entry = data_entry.create_dataset('I', data=I) 
    298         I_entry.attrs['units'] = data.I_unit 
    299         Qx_entry = data_entry.create_dataset('Qx', data=qx) 
    300         Qx_entry.attrs['units'] = data.Q_unit 
    301         Qy_entry = data_entry.create_dataset('Qy', data=qy) 
    302         Qy_entry.attrs['units'] = data.Q_unit 
    303         Idev_entry = data_entry.create_dataset('Idev', data=dI) 
    304         Idev_entry.attrs['units'] = data.I_unit 
     343        i_entry = data_entry.create_dataset('I', data=intensity) 
     344        i_entry.attrs['units'] = data.I_unit 
     345        qx_entry = data_entry.create_dataset('Qx', data=qx) 
     346        qx_entry.attrs['units'] = data.Q_unit 
     347        qy_entry = data_entry.create_dataset('Qy', data=qy) 
     348        qy_entry.attrs['units'] = data.Q_unit 
     349        if (data.err_data is not None 
     350                and not all(v is None for v in data.err_data)): 
     351            d_i = np.reshape(data.err_data, (n_rows, n_cols)) 
     352            i_entry.attrs['uncertainties'] = 'Idev' 
     353            i_dev_entry = data_entry.create_dataset('Idev', data=d_i) 
     354            i_dev_entry.attrs['units'] = data.I_unit 
     355        if (data.dqx_data is not None 
     356                and not all(v is None for v in data.dqx_data)): 
     357            qx_entry.attrs['resolutions'] = 'dQx' 
     358            dqx_entry = data_entry.create_dataset('dQx', data=data.dqx_data) 
     359            dqx_entry.attrs['units'] = data.Q_unit 
     360        if (data.dqy_data is not None 
     361                and not all(v is None for v in data.dqy_data)): 
     362            qy_entry.attrs['resolutions'] = 'dQy' 
     363            dqy_entry = data_entry.create_dataset('dQy', data=data.dqy_data) 
     364            dqy_entry.attrs['units'] = data.Q_unit 
     365        if data.mask is not None and not all(v is None for v in data.mask): 
     366            data_entry.attrs['mask'] = "mask" 
     367            mask = np.invert(np.asarray(data.mask, dtype=bool)) 
     368            data_entry.create_dataset('mask', data=mask) 

  • 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

    rdbfd307 r7af652d  
    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 :: 
    … …  
    498499        try: 
    499500            cov = np.linalg.pinv(inv_cov) 
    500             err = math.fabs(chi2 / float(npts - nfunc)) * cov 
    501         except: 
     501            err = math.fabs(chi2 / (npts - nfunc)) * cov 
     502        except Exception as exc: 
    502503            # We were not able to estimate the errors 
    503504            # Return an empty error matrix 
    504             logger.error(sys.exc_value) 
     505            logger.error(exc) 
    505506 
    506507        # Keep a copy of the last output 
    … …  
    539540 
    540541        """ 
    541         from num_term import NTermEstimator 
     542        from .num_term import NTermEstimator 
    542543        estimator = NTermEstimator(self.clone()) 
    543544        try: 
    544545            return estimator.num_terms(isquit_func) 
    545         except: 
     546        except Exception as exc: 
    546547            # If we fail, estimate alpha and return the default 
    547548            # number of terms 
    548549            best_alpha, _, _ = self.estimate_alpha(self.nfunc) 
    549             logger.warning("Invertor.estimate_numterms: %s" % sys.exc_value) 
     550            logger.warning("Invertor.estimate_numterms: %s" % exc) 
    550551            return self.nfunc, best_alpha, "Could not estimate number of terms" 
    551552 
    … …  
    633634                return best_alpha, message, elapsed 
    634635 
    635         except: 
    636             message = "Invertor.estimate_alpha: %s" % sys.exc_value 
     636        except Exception as exc: 
     637            message = "Invertor.estimate_alpha: %s" % exc 
    637638            return 0, message, elapsed 
    638639 
    … …  
    750751                        self.cov[i][i] = float(toks2[1]) 
    751752 
    752             except: 
    753                 msg = "Invertor.from_file: corrupted file\n%s" % sys.exc_value 
     753            except Exception as exc: 
     754                msg = "Invertor.from_file: corrupted file\n%s" % exc 
    754755                raise RuntimeError(msg) 
    755756        else: 

  • src/sas/sascalc/pr/num_term.py

    re090ba90 r8c9e65c  
    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/guiframe/gui_manager.py

    r8ac05a5 rdcd6efd  
    4646from sas.sasgui.guiframe.CategoryManager import CategoryManager 
    4747from sas.sascalc.dataloader.loader import Loader 
     48from sas.sascalc.file_converter.nxcansas_writer import NXcanSASWriter 
    4849from sas.sasgui.guiframe.proxy import Connection 
    4950 
    … …  
    6263SPLASH_SCREEN_HEIGHT = config.SPLASH_SCREEN_HEIGHT 
    6364SS_MAX_DISPLAY_TIME = config.SS_MAX_DISPLAY_TIME 
    64 if not WELCOME_PANEL_ON: 
    65     WELCOME_PANEL_SHOW = False 
     65 
     66def custom_value(name, default=None): 
     67    """ 
     68    Fetch a config value from custom_config.  Fallback to config, and then 
     69    to default if it doesn't exist in config. 
     70    """ 
     71    default = getattr(config, name, default) 
     72    return getattr(custom_config, name, default) 
     73 
     74# Custom config values in the order they appear. 
     75DATAPANEL_WIDTH = custom_value('DATAPANEL_WIDTH', -1) 
     76CLEANUP_PLOT = custom_value('CLEANUP_PLOT', False) 
     77FIXED_PANEL = custom_value('FIXED_PANEL', True) 
     78PLOPANEL_WIDTH = custom_value('PLOPANEL_WIDTH', -1) 
     79DATALOADER_SHOW = custom_value('DATALOADER_SHOW', True) 
     80GUIFRAME_HEIGHT = custom_value('GUIFRAME_HEIGHT', -1) 
     81GUIFRAME_WIDTH = custom_value('GUIFRAME_WIDTH', -1) 
     82CONTROL_WIDTH = custom_value('CONTROL_WIDTH', -1) 
     83CONTROL_HEIGHT = custom_value('CONTROL_HEIGHT', -1) 
     84open_folder = custom_value('DEFAULT_OPEN_FOLDER', None) 
     85if open_folder is not None and os.path.isdir(open_folder): 
     86    DEFAULT_OPEN_FOLDER = os.path.abspath(open_folder) 
    6687else: 
    67     WELCOME_PANEL_SHOW = True 
    68 try: 
    69     DATALOADER_SHOW = custom_config.DATALOADER_SHOW 
    70     TOOLBAR_SHOW = custom_config.TOOLBAR_SHOW 
    71     FIXED_PANEL = custom_config.FIXED_PANEL 
    72     if WELCOME_PANEL_ON: 
    73         WELCOME_PANEL_SHOW = custom_config.WELCOME_PANEL_SHOW 
    74     PLOPANEL_WIDTH = custom_config.PLOPANEL_WIDTH 
    75     DATAPANEL_WIDTH = custom_config.DATAPANEL_WIDTH 
    76     GUIFRAME_WIDTH = custom_config.GUIFRAME_WIDTH 
    77     GUIFRAME_HEIGHT = custom_config.GUIFRAME_HEIGHT 
    78     CONTROL_WIDTH = custom_config.CONTROL_WIDTH 
    79     CONTROL_HEIGHT = custom_config.CONTROL_HEIGHT 
    80     DEFAULT_PERSPECTIVE = custom_config.DEFAULT_PERSPECTIVE 
    81     CLEANUP_PLOT = custom_config.CLEANUP_PLOT 
    82     # custom open_path 
    83     open_folder = custom_config.DEFAULT_OPEN_FOLDER 
    84     if open_folder is not None and os.path.isdir(open_folder): 
    85         DEFAULT_OPEN_FOLDER = os.path.abspath(open_folder) 
    86     else: 
    87         DEFAULT_OPEN_FOLDER = get_app_dir() 
    88     SAS_OPENCL = custom_config.SAS_OPENCL 
    89 except: 
    90     DATALOADER_SHOW = True 
    91     TOOLBAR_SHOW = True 
    92     FIXED_PANEL = True 
    93     WELCOME_PANEL_SHOW = False 
    94     PLOPANEL_WIDTH = config.PLOPANEL_WIDTH 
    95     DATAPANEL_WIDTH = config.DATAPANEL_WIDTH 
    96     GUIFRAME_WIDTH = config.GUIFRAME_WIDTH 
    97     GUIFRAME_HEIGHT = config.GUIFRAME_HEIGHT 
    98     CONTROL_WIDTH = -1 
    99     CONTROL_HEIGHT = -1 
    100     DEFAULT_PERSPECTIVE = None 
    101     CLEANUP_PLOT = False 
    10288    DEFAULT_OPEN_FOLDER = get_app_dir() 
    103     DEFAULT_OPEN_FOLDER = PATH_APP 
    104     SAS_OPENCL = None 
     89WELCOME_PANEL_SHOW = (custom_value('WELCOME_PANEL_SHOW', False) 
     90                      if WELCOME_PANEL_ON else False) 
     91TOOLBAR_SHOW = custom_value('TOOLBAR_SHOW', True) 
     92DEFAULT_PERSPECTIVE = custom_value('DEFAULT_PERSPECTIVE', 'Fitting') 
     93SAS_OPENCL = custom_value('SAS_OPENCL', 'None') 
     94 
    10595DEFAULT_STYLE = config.DEFAULT_STYLE 
    106  
    10796PLUGIN_STATE_EXTENSIONS = config.PLUGIN_STATE_EXTENSIONS 
    10897OPEN_SAVE_MENU = config.OPEN_SAVE_PROJECT_MENU 
    … …  
    21702159        # original 2.x tutorial. 
    21712160        # Code below, implemented from 4.2.0, redirects 
    2172         # action to the Tutorials page of the help  
     2161        # action to the Tutorials page of the help 
    21732162        # documentation to give access to all available 
    21742163        # tutorials 
    … …  
    24192408        default_name = fname 
    24202409        wildcard = "Text files (*.txt)|*.txt|"\ 
    2421                     "CanSAS 1D files(*.xml)|*.xml" 
    2422         path = None 
     2410                    "CanSAS 1D files (*.xml)|*.xml|"\ 
     2411                     "NXcanSAS files (*.h5)|*.h5|" 
     2412        options = [".txt", ".xml",".h5"] 
    24232413        dlg = wx.FileDialog(self, "Choose a file", 
    24242414                            self._default_save_location, 
    … …  
    24302420            # This is MAC Fix 
    24312421            ext_num = dlg.GetFilterIndex() 
    2432             if ext_num == 0: 
    2433                 ext_format = '.txt' 
    2434             else: 
    2435                 ext_format = '.xml' 
     2422 
     2423            ext_format = options[ext_num] 
    24362424            path = os.path.splitext(path)[0] + ext_format 
    24372425            mypath = os.path.basename(path) 
    2438  
    2439             # Instantiate a loader 
    2440             loader = Loader() 
    2441             ext_format = ".txt" 
    2442             if os.path.splitext(mypath)[1].lower() == ext_format: 
     2426            fName = os.path.splitext(path)[0] + ext_format 
     2427 
     2428            if os.path.splitext(mypath)[1].lower() == options[0]: 
    24432429                # Make sure the ext included in the file name 
    24442430                # especially on MAC 
    2445                 fName = os.path.splitext(path)[0] + ext_format 
    24462431                self._onsaveTXT(data, fName) 
    2447             ext_format = ".xml" 
    2448             if os.path.splitext(mypath)[1].lower() == ext_format: 
     2432            elif os.path.splitext(mypath)[1].lower() == options[1]: 
    24492433                # Make sure the ext included in the file name 
    24502434                # especially on MAC 
    2451                 fName = os.path.splitext(path)[0] + ext_format 
     2435                # Instantiate a loader 
     2436                loader = Loader() 
    24522437                loader.save(fName, data, ext_format) 
     2438            elif os.path.splitext(mypath)[1].lower() == options[2]: 
     2439                nxcansaswriter = NXcanSASWriter() 
     2440                nxcansaswriter.write([data], fName) 
    24532441            try: 
    24542442                self._default_save_location = os.path.dirname(path) 
    … …  
    24772465            if has_errors: 
    24782466                if data.dx is not None and data.dx != []: 
    2479                     out.write("<X>   <Y>   <dY>   <dX>\n") 
     2467                    out.write("<X>\t<Y>\t<dY>\t<dX>\n") 
    24802468                else: 
    2481                     out.write("<X>   <Y>   <dY>\n") 
     2469                    out.write("<X>\t<Y>\t<dY>\n") 
    24822470            else: 
    2483                 out.write("<X>   <Y>\n") 
     2471                out.write("<X>\t<Y>\n") 
    24842472 
    24852473            for i in range(len(data.x)): 
    … …  
    25252513            text += 'dY_min = %s:  dY_max = %s\n' % (min(data.dy), max(data.dy)) 
    25262514        text += '\nData Points:\n' 
    2527         x_st = "X" 
     2515        text += "<index> \t<X> \t<Y> \t<dY> " 
     2516        text += "\t<dXl> \t<dXw>\n" if(data.dxl is not None and 
     2517                                       data.dxw is not None) else "\t<dX>\n" 
    25282518        for index in range(len(data.x)): 
    25292519            if data.dy is not None and len(data.dy) > index: 
    … …  
    25362526                dx_val = 0.0 
    25372527            if data.dxl is not None and len(data.dxl) > index: 
    2538                 if index == 0: 
    2539                     x_st = "Xl" 
    25402528                dx_val = data.dxl[index] 
    2541             elif data.dxw is not None and len(data.dxw) > index: 
    2542                 if index == 0: 
    2543                     x_st = "Xw" 
    2544                 dx_val = data.dxw[index] 
    2545  
    2546             if index == 0: 
    2547                 text += "<index> \t<X> \t<Y> \t<dY> \t<d%s>\n" % x_st 
     2529                if data.dxw is not None and len(data.dxw) > index: 
     2530                    dx_val = "%s \t%s" % (data.dxl[index], data.dxw[index]) 
     2531 
    25482532            text += "%s \t%s \t%s \t%s \t%s\n" % (index, 
    25492533                                                  data.x[index], 
    … …  
    25622546        """ 
    25632547        default_name = fname 
    2564         wildcard = "IGOR/DAT 2D file in Q_map (*.dat)|*.DAT" 
     2548        wildcard = "IGOR/DAT 2D file in Q_map (*.dat)|*.DAT|"\ 
     2549                   "NXcanSAS files (*.h5)|*.h5|" 
    25652550        dlg = wx.FileDialog(self, "Choose a file", 
    25662551                            self._default_save_location, 
    … …  
    25742559            if ext_num == 0: 
    25752560                ext_format = '.dat' 
     2561            elif ext_num == 1: 
     2562                ext_format = '.h5' 
    25762563            else: 
    25772564                ext_format = '' 
    … …  
    25812568            # Instantiate a loader 
    25822569            loader = Loader() 
    2583  
    2584             ext_format = ".dat" 
    2585             if os.path.splitext(mypath)[1].lower() == ext_format: 
     2570            ext = os.path.splitext(mypath)[1].lower() 
     2571            if ext == '.dat': 
    25862572                # Make sure the ext included in the file name 
    25872573                # especially on MAC 
    25882574                fileName = os.path.splitext(path)[0] + ext_format 
    25892575                loader.save(fileName, data, ext_format) 
     2576            elif ext == '.h5': 
     2577                # Make sure the ext included in the file name 
     2578                # especially on MAC 
     2579                fileName = os.path.splitext(path)[0] + ext_format 
     2580                nxcansaswriter = NXcanSASWriter() 
     2581                nxcansaswriter.write([data], fileName) 
    25902582            try: 
    25912583                self._default_save_location = os.path.dirname(path) 

  • src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

    r9c7e2b8 r5218180  
    205205            except NoKnownLoaderException as e: 
    206206                exception_occurred = True 
    207                 error_message = "Loading data failed!" + e.message 
     207                error_message = "Loading data failed!\n" + e.message 
    208208                file_errors[basename] = [error_message] 
    209209            except Exception as e: 
    … …  
    224224                for message in error_array: 
    225225                    error_message += message + "\n" 
     226                error_message = error_message[:-1] 
    226227            self.load_complete(output=output, 
    227228                               message=error_message, 
    … …  
    231232            self.load_complete(output=output, message="Loading data complete!", 
    232233                               info="info") 
    233         else: 
    234             self.load_complete(output=None, message=error_message, info="error") 
    235234 
    236235    def load_update(self, message="", info="warning"): 

  • src/sas/sasgui/perspectives/calculator/model_editor.py

    r9bf40e7 r1752f38  
    965965        out_f.write('    """Absolute scattering"""\n') 
    966966        if "scipy." in func_str: 
    967             out_f.write('    import scipy') 
     967            out_f.write('    import scipy\n') 
    968968        if "numpy." in func_str: 
    969             out_f.write('    import numpy') 
     969            out_f.write('    import numpy\n') 
    970970        if "np." in func_str: 
    971             out_f.write('    import numpy as np') 
     971            out_f.write('    import numpy as np\n') 
    972972        for func_line in func_str.split('\n'): 
    973973            out_f.write('%s%s\n' % ('    ', func_line)) 

  • src/sas/sasgui/perspectives/corfunc/corfunc_panel.py

    r5652efc ref74a8b  
    277277        self._transformed_data = transforms 
    278278        (transform1, transform3, idf) = transforms 
    279         plot_x = transform1.x[transform1.x <= 200] 
    280         plot_y = transform1.y[transform1.x <= 200] 
     279        plot_x = transform1.x[transform1.x <= 1000] 
     280        plot_y = transform1.y[transform1.x <= 1000] 
    281281        self._manager.show_data(Data1D(plot_x, plot_y), TRANSFORM_LABEL1) 
    282         # No need to shorten gamma3 as it's only calculated up to x=200 
     282        # No need to shorten gamma3 as it's only calculated up to x=1000 
    283283        self._manager.show_data(transform3, TRANSFORM_LABEL3) 
    284284 
    285         plot_x = idf.x[idf.x <= 200] 
    286         plot_y = idf.y[idf.x <= 200] 
     285        plot_x = idf.x[idf.x <= 1000] 
     286        plot_y = idf.y[idf.x <= 1000] 
    287287        self._manager.show_data(Data1D(plot_x, plot_y), IDF_LABEL) 
    288288 

  • src/sas/sasgui/perspectives/corfunc/media/corfunc_help.rst

    r490f790 r4d06668  
    3030of the profile provides measures of the layer thickness, and the area under  
    3131the profile is related to the amount of material that is adsorbed. 
     32 
     33.. note:: 
     34    These transforms assume that the data has been measured on a pinhole- 
     35    collimated instrument or, if not, that the data has been Lorentz- 
     36    corrected beforehand. 
    3237 
    3338Both analyses are performed in 3 stages: 

  • src/sas/sasgui/perspectives/fitting/fitpage.py

    rba1c145 rca4f40d  
    1313import time 
    1414import traceback 
     15import logging 
    1516 
    1617from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS 
    1718 
    1819from sas.sascalc.fit.qsmearing import smear_selection 
     20from sas.sascalc.dataloader.data_info import Data1D, Data2D 
    1921 
    2022from sas.sasgui.guiframe.events import StatusEvent, NewPlotEvent, \ 
    … …  
    2830    PageInfoEvent 
    2931from .basepage import ModelTextCtrl 
     32 
     33logger = logging.getLogger(__name__) 
    3034 
    3135(Chi2UpdateEvent, EVT_CHI2_UPDATE) = wx.lib.newevent.NewEvent() 
    … …  
    184188        :return: True or False 
    185189        """ 
    186         if self.data.__class__.__name__ == "Data2D" or \ 
    187                         self.enable2D: 
     190        if isinstance(self.data, Data2D) or self.enable2D: 
    188191            return True 
    189192        return False 
    … …  
    199202 
    200203        # Check if data is 2D 
    201         if self.data.__class__.__name__ == "Data2D" or \ 
    202                         self.enable2D: 
     204        if isinstance(self.data, Data2D) or self.enable2D: 
    203205            is_2d_data = True 
    204206 
    … …  
    213215        smear_message_new_psmear = \ 
    214216              "Please enter a fixed percentage to be applied to all Q values..." 
    215         smear_message_2d_x_title = "<dQp>[1/A]:" 
    216         smear_message_2d_y_title = "<dQs>[1/A]:" 
    217         smear_message_pinhole_percent_title = "dQ[%]:" 
     217        smear_message_2d_x_title = "<dQ/Q>_r[%]:" 
     218        smear_message_2d_y_title = "<dQ/Q>_phi[%]:" 
     219        smear_message_pinhole_percent_min_title = "[dQ/Q]min(%):" 
     220        smear_message_pinhole_percent_max_title = "[dQ/Q]max(%):" 
     221        smear_message_pinhole_percent_title = "dQ/Q(%):" 
    218222        smear_message_slit_height_title = "Slit height[1/A]:" 
    219223        smear_message_slit_width_title = "Slit width[1/A]:" 
    … …  
    418422                            smear_message_2d_x_title, style=wx.ALIGN_LEFT) 
    419423        self.smear_description_2d_x.SetToolTipString( 
    420                                         "  dQp(parallel) in q_r direction.") 
     424                                        "  dQ_r q_r in polar coordinates.") 
    421425        self.smear_description_2d_y = wx.StaticText(self, wx.ID_ANY, 
    422426                            smear_message_2d_y_title, style=wx.ALIGN_LEFT) 
    423427        self.smear_description_2d_y.SetToolTipString( 
    424                                     " dQs(perpendicular) in q_phi direction.") 
     428                                    " dQ_phi q_phi in polar coordinates.") 
     429        self.smear_description_pin_percent_min = wx.StaticText(self, wx.ID_ANY, 
     430                                            smear_message_pinhole_percent_min_title, 
     431                                            style=wx.ALIGN_LEFT) 
     432        self.smear_description_pin_percent_max = wx.StaticText(self, wx.ID_ANY, 
     433                                            smear_message_pinhole_percent_max_title, 
     434                                            style=wx.ALIGN_LEFT) 
    425435        self.smear_description_pin_percent = wx.StaticText(self, wx.ID_ANY, 
    426436                                            smear_message_pinhole_percent_title, 
    … …  
    449459        self.sizer_new_smear.Add((15, -1)) 
    450460        self.sizer_new_smear.Add(self.smear_description_2d_x, 0, wx.CENTER, 10) 
     461        self.sizer_new_smear.Add(self.smear_description_pin_percent_min, 
     462                                 0, wx.CENTER, 10) 
     463        self.sizer_new_smear.Add(self.smear_description_pin_percent, 
     464                                 0, wx.CENTER, 10) 
    451465        self.sizer_new_smear.Add(self.smear_description_slit_height, 
    452466                                 0, wx.CENTER, 10) 
    453467 
     468        self.sizer_new_smear.Add(self.smear_pinhole_percent, 0, wx.CENTER, 10) 
    454469        self.sizer_new_smear.Add(self.smear_slit_height, 0, wx.CENTER, 10) 
    455470        self.sizer_new_smear.Add(self.smear_data_left, 0, wx.CENTER, 10) 
    … …  
    457472        self.sizer_new_smear.Add(self.smear_description_2d_y, 
    458473                                 0, wx.CENTER, 10) 
    459         self.sizer_new_smear.Add(self.smear_description_pin_percent, 
     474        self.sizer_new_smear.Add(self.smear_description_pin_percent_max, 
    460475                                 0, wx.CENTER, 10) 
    461476        self.sizer_new_smear.Add(self.smear_description_slit_width, 
    462477                                 0, wx.CENTER, 10) 
    463478 
    464         self.sizer_new_smear.Add(self.smear_pinhole_percent, 0, wx.CENTER, 10) 
    465479        self.sizer_new_smear.Add(self.smear_slit_width, 0, wx.CENTER, 10) 
    466480        self.sizer_new_smear.Add(self.smear_data_right, 0, wx.CENTER, 10) 
    … …  
    503517 
    504518        # check if it is 2D data 
    505         if self.data.__class__.__name__ == "Data2D" or self.enable2D: 
     519        if isinstance(self.data, Data2D) or self.enable2D: 
    506520            is_2d_data = True 
    507521 
    … …  
    806820                        self.sizer4_4.Add(cb, (iy, ix), (1, 1), 
    807821                                wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5) 
    808                         if self.data.__class__.__name__ == "Data2D" or \ 
    809                                     self.enable2D: 
     822                        if isinstance(self.data, Data2D) or self.enable2D: 
    810823                            cb.Show(True) 
    811824                        elif cb.IsShown(): 
    … …  
    819832                        ctl1.SetToolTipString(poly_tip) 
    820833                        ctl1.SetValue(str(format_number(value, True))) 
    821                         if self.data.__class__.__name__ == "Data2D" or \ 
    822                                     self.enable2D: 
     834                        if isinstance(self.data, Data2D) or self.enable2D: 
    823835                            if first_orient: 
    824836                                values.SetLabel('PD[ratio], Sig[deg]') 
    … …  
    854866 
    855867                        ctl2.Hide() 
    856                         if self.data.__class__.__name__ == "Data2D" or \ 
    857                                 self.enable2D: 
     868                        if isinstance(self.data, Data2D) or self.enable2D: 
    858869                            if self.is_mac: 
    859870                                text2.Show(True) 
    … …  
    880891                        ctl4.Hide() 
    881892 
    882                         if self.data.__class__.__name__ == "Data2D" or \ 
    883                                 self.enable2D: 
     893                        if isinstance(self.data, Data2D) or self.enable2D: 
    884894                            ctl3.Show(True) 
    885895                            ctl4.Show(True) 
    … …  
    893903 
    894904                        Tctl.SetValue(str(format_number(value))) 
    895                         if self.data.__class__.__name__ == "Data2D" or \ 
    896                                 self.enable2D: 
     905                        if isinstance(self.data, Data2D) or self.enable2D: 
    897906                            Tctl.Show(True) 
    898907                        else: 
    … …  
    913922 
    914923                        Tct2.SetValue(str(format_number(value))) 
    915                         if self.data.__class__.__name__ == "Data2D" or \ 
    916                                 self.enable2D: 
     924                        if isinstance(self.data, Data2D) or self.enable2D: 
    917925                            Tct2.Show(True) 
    918926                        else: 
    … …  
    941949                                            text2, ctl2, ctl3, ctl4, disp_box]) 
    942950 
    943                 if self.data.__class__.__name__ == "Data2D" or \ 
    944                                 self.enable2D: 
     951                if isinstance(self.data, Data2D) or self.enable2D: 
    945952                    disp_box.Show(True) 
    946953                else: 
    … …  
    13271334                        flag1 = self.update_pinhole_smear() 
    13281335                        flag = flag or flag1 
    1329                 elif self.data.__class__.__name__ != "Data2D" and \ 
    1330                         not self.enable2D: 
     1336                elif not isinstance(self.data, Data2D) and not self.enable2D: 
    13311337                    enable_smearer = not self.disable_smearer.GetValue() 
    13321338                    self._manager.set_smearer(smearer=temp_smearer, 
    … …  
    14011407        if event is not None: 
    14021408            event.Skip() 
    1403         if self.data.__class__.__name__ == "Data2D": 
     1409        if isinstance(self.data, Data2D): 
    14041410            return 
    14051411        is_click = event.LeftDown() 
    … …  
    14191425        if event is not None: 
    14201426            event.Skip() 
    1421         if self.data.__class__.__name__ == "Data2D": 
     1427        if isinstance(self.data, Data2D): 
    14221428            return 
    14231429        act_ctrl = event.GetEventObject() 
    … …  
    14351441        """ 
    14361442        event.Skip() 
    1437         if self.data.__class__.__name__ == "Data2D": 
     1443        if isinstance(self.data, Data2D): 
    14381444            return 
    14391445        ctrl = event.GetEventObject() 
    … …  
    14961502            # Check if # of points for theory model are valid(>0). 
    14971503            # check for 2d 
    1498             if self.data.__class__.__name__ == "Data2D" or \ 
    1499                     self.enable2D: 
     1504            if isinstance(self.data, Data2D) or self.enable2D: 
    15001505                # set mask 
    15011506                radius = np.sqrt(self.data.qx_data * self.data.qx_data + 
    … …  
    15491554                if item[0].IsShown(): 
    15501555                    # Skip the angle parameters if 1D data 
    1551                     if self.data.__class__.__name__ != "Data2D" and \ 
    1552                             not self.enable2D: 
     1556                    if not isinstance(self.data, Data2D) and not self.enable2D: 
    15531557                        if item in self.orientation_params: 
    15541558                            continue 
    … …  
    15681572                if item[0].IsShown(): 
    15691573                    # Skip the angle parameters if 1D data 
    1570                     if self.data.__class__.__name__ != "Data2D" and \ 
    1571                             not self.enable2D: 
     1574                    if not isinstance(self.data, Data2D) and not self.enable2D: 
    15721575                        if item in self.orientation_params: 
    15731576                            continue 
    … …  
    16011604 
    16021605        :return: self.smear_type, self.dq_l and self.dq_r, 
    1603             respectively the type of the smear, dq_min and 
    1604             dq_max for pinhole smear data 
    1605             while dxl and dxw for slit smear 
    1606         """ 
    1607         # default 
     1606            respectively the type of the smear, The average <dq/q> radial(p) 
     1607            and <dq/q> theta (s)s for 2D pinhole resolution in % (slit is not 
     1608            currently supported in 2D), (dq/q)_min and (dq/q)_max for 1D pinhole 
     1609            smeared data, again in %, and dxl and/or dxw for slit smeared data 
     1610            given in 1/A and assumed constant. 
     1611        """ 
     1612        # set up defaults 
    16081613        self.smear_type = None 
    16091614        self.dq_l = None 
    16101615        self.dq_r = None 
    16111616        data = self.data 
     1617        #sanity check - this should only be called if data exits 
    16121618        if self.data is None: 
    16131619            return 
    1614         elif self.data.__class__.__name__ == "Data2D" or \ 
    1615             self.enable2D: 
    1616             if data.dqx_data is None or data.dqy_data is None: 
    1617                 return 
    1618             elif self.current_smearer is not None \ 
    1619                 and data.dqx_data.any() != 0 \ 
    1620                 and data.dqx_data.any() != 0: 
     1620        #First check if data is 2D 
     1621        #If so check that data set has smearing info and that none are zero. 
     1622        #Otherwise no smearing can be applied using smear from data (a Gaussian 
     1623        #width of zero will cause a divide by zero error) 
     1624        if isinstance(self.data, Data2D): 
     1625            if data.dqx_data is not None and data.dqy_data is not None \ 
     1626              and data.dqx_data.all()and data.dqy_data.all(): 
    16211627                self.smear_type = "Pinhole2d" 
    1622                 self.dq_l = format_number(np.average(data.dqx_data)) 
    1623                 self.dq_r = format_number(np.average(data.dqy_data)) 
    1624                 return 
     1628                #report as average dQ/Q % as for 1D pinhole 
     1629                self.dq_l = format_number(np.average(data.dqx_data 
     1630                                                     / abs(data.qx_data)) * 100) 
     1631                self.dq_r = format_number(np.average(data.dqy_data 
     1632                                                     / abs(data.qy_data)) * 100) 
     1633            #if not then log that data did not contain resolutin info                                         / abs(data.qy_data)) * 100) 
    16251634            else: 
    1626                 return 
    1627         # check if it is pinhole smear and get min max if it is. 
    1628         if data.dx is not None and np.any(data.dx): 
    1629             self.smear_type = "Pinhole" 
    1630             self.dq_l = data.dx[0] 
    1631             self.dq_r = data.dx[-1] 
    1632  
    1633         # check if it is slit smear and get min max if it is. 
    1634         elif data.dxl is not None or data.dxw is not None: 
    1635             self.smear_type = "Slit" 
    1636             if data.dxl is not None and np.all(data.dxl, 0): 
    1637                 self.dq_l = data.dxl[0] 
    1638             if data.dxw is not None and np.all(data.dxw, 0): 
    1639                 self.dq_r = data.dxw[0] 
     1635                self.msg = "2D Data did not contain recognizable " \ 
     1636                           "resolution info." 
     1637                logger.info(self.msg) 
     1638        #If not check that data is 1D 
     1639        #If so check for pinhole vs slit by veryfing whehter dx or dxl or dxw 
     1640        #have data (currently sasview only supports either dx or dxl/dxw but 
     1641        #not both simultaneously) and, as for 2D, are non zero . 
     1642        #Otherwise no smearing can be applied using smear from data (a Gaussian 
     1643        #width of zero will cause a divide by zero error) 
     1644        elif isinstance(self.data, Data1D): 
     1645            #is it valid 1D pinhole resolution data? 
     1646            if data.dx is not None and np.all(data.dx): 
     1647                self.smear_type = "Pinhole" 
     1648                #report in % for display makes more sense than absolute value 
     1649                #for pinhole smearing .. but keep old names of dq_l 
     1650                self.dq_l = format_number(data.dx[0] / data.x[0] * 100,1) 
     1651                self.dq_r = format_number(data.dx[-1] / data.x[-1] * 100,1) 
     1652            #If not, is it valid 1D slit resolution data? 
     1653            elif (data.dxl is not None or data.dxw is not None) \ 
     1654                and (np.all(data.dxl, 0) or np.all(data.dxw, 0)): 
     1655                self.smear_type = "Slit" 
     1656                #for slit units of 1/A make most sense 
     1657                if data.dxl is not None and np.all(data.dxl, 0): 
     1658                    self.dq_l = format_number(data.dxl[0],1) 
     1659                if data.dxw is not None and np.all(data.dxw, 0): 
     1660                    self.dq_r = format_number(data.dxw[0],1) 
     1661            #otherwise log that the data did not conatain resolution info 
     1662            else: 
     1663                self.msg = "1D Data did not contain recognizable " \ 
     1664                           "resolution info." 
     1665                logger.info(self.msg) 
     1666        #If drops to here it is neither data1D or data2D so log that 
     1667        else: 
     1668            self.msg = "Data was not recognized as either 1D or 2D data." 
     1669            logger.info(self.msg) 
    16401670        # return self.smear_type,self.dq_l,self.dq_r 
    16411671 
    … …  
    16441674        Show only the sizers depending on smear selection 
    16451675        """ 
    1646         # smear disabled 
     1676        # smear disabled = No Smearing used 
    16471677        if self.disable_smearer.GetValue(): 
    16481678            self.smear_description_none.Show(True) 
    1649         # 2Dsmear 
     1679        # 2Dsmearing - for use with 2D data only 
    16501680        elif self._is_2D(): 
    16511681            self.smear_description_accuracy_type.Show(True) 
    16521682            self.smear_accuracy.Show(True) 
    1653             self.smear_description_accuracy_type.Show(True) 
    16541683            self.smear_description_2d.Show(True) 
    1655             self.smear_description_2d_x.Show(True) 
    1656             self.smear_description_2d_y.Show(True) 
     1684            #2D custom pinhole smearing 
    16571685            if self.pinhole_smearer.GetValue(): 
     1686                self.smear_description_pin_percent.Show(True) 
    16581687                self.smear_pinhole_percent.Show(True) 
    1659         # smear from data 
     1688            #get 2D smearing from data 
     1689            elif self.enable_smearer.GetValue(): 
     1690                self.smear_description_2d_x.Show(True) 
     1691                self.smear_description_2d_y.Show(True) 
     1692                self.smear_data_left.Show(True) 
     1693                self.smear_data_right.Show(True) 
     1694            #Currently 2D custom slit smearing is not currently supported 
     1695            else: 
     1696                logger.error("2D custom smearing cannot use slit smearing") 
     1697 
     1698        # 1D smearing from data 
    16601699        elif self.enable_smearer.GetValue(): 
    1661  
    16621700            self.smear_description_dqdata.Show(True) 
    16631701            if self.smear_type is not None: 
    16641702                self.smear_description_smear_type.Show(True) 
     1703                #1D data has slit smearing 
    16651704                if self.smear_type == 'Slit': 
    16661705                    self.smear_description_slit_height.Show(True) 
    16671706                    self.smear_description_slit_width.Show(True) 
     1707                #1D data has pinhole smearing 
    16681708                elif self.smear_type == 'Pinhole': 
    1669                     self.smear_description_pin_percent.Show(True) 
     1709                    self.smear_description_pin_percent_min.Show(True) 
     1710                    self.smear_description_pin_percent_max.Show(True) 
    16701711                self.smear_description_smear_type.Show(True) 
    16711712                self.smear_description_type.Show(True) 
    16721713                self.smear_data_left.Show(True) 
    16731714                self.smear_data_right.Show(True) 
    1674         # custom pinhole smear 
     1715        # 1D custom pinhole smearing 
    16751716        elif self.pinhole_smearer.GetValue(): 
    1676             if self.smear_type == 'Pinhole': 
    1677                 self.smear_message_new_p.Show(True) 
    1678                 self.smear_description_pin_percent.Show(True) 
    1679  
     1717            self.smear_message_new_p.Show(True) 
     1718            self.smear_description_pin_percent.Show(True) 
    16801719            self.smear_pinhole_percent.Show(True) 
    1681         # custom slit smear 
     1720        # 1D custom slit smear 
    16821721        elif self.slit_smearer.GetValue(): 
    16831722            self.smear_message_new_s.Show(True) 
    … …  
    16861725            self.smear_description_slit_width.Show(True) 
    16871726            self.smear_slit_width.Show(True) 
     1727        else: 
     1728            logger.error("smearing type is not defined") 
    16881729 
    16891730    def _hide_all_smear_info(self): 
    … …  
    17031744        self.smear_data_left.Hide() 
    17041745        self.smear_data_right.Hide() 
     1746        self.smear_description_pin_percent_min.Hide() 
     1747        self.smear_description_pin_percent_max.Hide() 
    17051748        self.smear_description_pin_percent.Hide() 
    17061749        self.smear_pinhole_percent.Hide() 
    … …  
    19201963            di_flag = False 
    19211964            dq_flag = False 
    1922             if self.data.__class__.__name__ == "Data2D" or \ 
    1923                         self.enable2D: 
     1965            if isinstance(self.data, Data2D) or self.enable2D: 
    19241966                self.slit_smearer.Disable() 
    19251967                self.pinhole_smearer.Enable(True) 
    … …  
    20062048        # update model plot with new data information 
    20072049        if flag: 
    2008             if self.data.__class__.__name__ == "Data2D": 
     2050            if isinstance(self.data, Data2D): 
    20092051                self.enable2D = True 
    20102052                self.model_view.SetLabel("2D Mode") 
    … …  
    20732115        npts2fit = 0 
    20742116        qmin, qmax = self.get_range() 
    2075         if self.data.__class__.__name__ == "Data2D" or \ 
    2076                         self.enable2D: 
     2117        if isinstance(self.data, Data2D) or self.enable2D: 
    20772118            radius = np.sqrt(self.data.qx_data * self.data.qx_data + 
    20782119                                self.data.qy_data * self.data.qy_data) 
    … …  
    24642505            of the values entered for slit smear 
    24652506        """ 
    2466         if self.data.__class__.__name__ == "Data2D" or self.enable2D: 
     2507        if isinstance(self.data, Data2D) or self.enable2D: 
    24672508            return 
    24682509        # make sure once more if it is smearer 
    … …  
    26602701        for item in self.parameters: 
    26612702            # Skip t ifhe angle parameters if 1D data 
    2662             if self.data.__class__.__name__ != "Data2D" and\ 
    2663                         not self.enable2D: 
     2703            if not isinstance(self.data, Data2D) and not self.enable2D: 
    26642704                if item in self.orientation_params: 
    26652705                    continue 
    … …  
    26772717        for item in self.fittable_param: 
    26782718            # Skip t ifhe angle parameters if 1D data 
    2679             if self.data.__class__.__name__ != "Data2D" and\ 
    2680                         not self.enable2D: 
     2719            if not isinstance(self.data, Data2D) and not self.enable2D: 
    26812720                if item in self.orientation_params: 
    26822721                    continue 
    … …  
    26902729 
    26912730        # Calculate num. of angle parameters 
    2692         if self.data.__class__.__name__ == "Data2D" or \ 
    2693                        self.enable2D: 
     2731        if isinstance(self.data, Data2D) or self.enable2D: 
    26942732            len_orient_para = 0 
    26952733        else: 
    … …  
    29843022                if not self._has_magnetic: 
    29853023                    mag_on_button.Show(False) 
    2986                 elif not self.data.__class__.__name__ == "Data2D": 
     3024                elif not isinstance(self.data, Data2D): 
    29873025                    mag_on_button.Show(False) 
    29883026                else: 
    … …  
    30003038                        mag_angle_help_button.Show(False) 
    30013039 
    3002                 if not self.data.__class__.__name__ == "Data2D" and \ 
    3003                         not self.enable2D: 
     3040                if not isinstance(self.data, Data2D) and not self.enable2D: 
    30043041                    orient_angle.Hide() 
    30053042                else: 
    … …  
    30253062                    cb.SetToolTipString("Check mark to fit") 
    30263063                    wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param) 
    3027                     if self.data.__class__.__name__ == "Data2D" or \ 
    3028                             self.enable2D: 
     3064                    if isinstance(self.data, Data2D) or self.enable2D: 
    30293065                        cb.Show(True) 
    30303066                    else: 
    … …  
    30413077                                "Hit 'Enter' after typing to update the plot.") 
    30423078                    ctl1.SetValue(format_number(value, True)) 
    3043                     if self.data.__class__.__name__ == "Data2D" or \ 
    3044                             self.enable2D: 
     3079                    if isinstance(self.data, Data2D) or self.enable2D: 
    30453080                        ctl1.Show(True) 
    30463081                    else: 
    … …  
    30823117                    ctl4.Hide() 
    30833118 
    3084                     if self.data.__class__.__name__ == "Data2D" or \ 
    3085                             self.enable2D: 
     3119                    if isinstance(self.data, Data2D) or self.enable2D: 
    30863120                        if self.is_mac: 
    30873121                            text2.Show(True) 
    … …  
    30993133                        units = wx.StaticText(self, -1, "", 
    31003134                                              style=wx.ALIGN_LEFT) 
    3101                     if self.data.__class__.__name__ == "Data2D" or \ 
    3102                             self.enable2D: 
     3135                    if isinstance(self.data, Data2D) or self.enable2D: 
    31033136                        units.Show(True) 
    31043137                    else: 
    … …  
    31793212        """ 
    31803213        # more disables for 2D 
    3181         if self.data.__class__.__name__ == "Data2D" or \ 
    3182                     self.enable2D: 
     3214        if isinstance(self.data, Data2D) or self.enable2D: 
    31833215            self.slit_smearer.Disable() 
    3184             self.pinhole_smearer.Enable(True) 
    31853216            self.default_mask = copy.deepcopy(self.data.mask) 
    3186         else: 
    3187             self.slit_smearer.Enable(True) 
    3188             self.pinhole_smearer.Enable(True) 
     3217            if self.model is not None: 
     3218                self.pinhole_smearer.Enable(True) 
     3219 
     3220        elif isinstance(self.data, Data1D): 
     3221            if self.model is not None: 
     3222                self.slit_smearer.Enable(True) 
     3223                self.pinhole_smearer.Enable(True) 
     3224        else: 
     3225            msg="data is not recognized as either 1D or 2D" 
     3226            logger.info(msg) 
    31893227 
    31903228 

  • src/sas/sasgui/perspectives/fitting/fitting.py

    raba4559 ra5cffe5  
    776776        :param weight: current dy data 
    777777        """ 
    778         # If we are not dealing with a specific fit problem, then 
    779         # there is no point setting the weights. 
    780         if fid is None: 
    781             return 
     778        # Note: this is used to set the data weights for the fit based on 
     779        # the weight selection in the GUI. 
    782780        if uid in self.page_finder.keys(): 
    783781            self.page_finder[uid].set_weight(flag=flag, is2d=is2d) 

  • src/sas/sasgui/perspectives/fitting/gpu_options.py

    r388aefb r895703d  
    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.sasview_model 
     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.sasview_model.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.sasview_model.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/sasgui/plottools/PlotPanel.py

    r2469df7 r75313af  
    14341434 
    14351435        """ 
     1436        # TODO: include mask info in plotter 
    14361437        self.data = data 
    14371438        self.qx_data = qx_data 
    … …  
    14511452        else: 
    14521453            output = copy.deepcopy(self.data) 
    1453         # check scale 
     1454        # rescale data if necessary 
    14541455        if self.scale == 'log_{10}': 
    1455             try: 
    1456                 if  self.zmin_2D <= 0  and len(output[output > 0]) > 0: 
    1457                     zmin_temp = self.zmin_2D 
    1458                     output[output > 0] = np.log10(output[output > 0]) 
    1459                     #In log scale Negative values are not correct in general 
    1460                     #output[output<=0] = math.log(np.min(output[output>0])) 
    1461                 elif self.zmin_2D <= 0: 
    1462                     zmin_temp = self.zmin_2D 
    1463                     output[output > 0] = np.zeros(len(output)) 
    1464                     output[output <= 0] = -32 
    1465                 else: 
    1466                     zmin_temp = self.zmin_2D 
    1467                     output[output > 0] = np.log10(output[output > 0]) 
    1468                     #In log scale Negative values are not correct in general 
    1469                     #output[output<=0] = math.log(np.min(output[output>0])) 
    1470             except: 
    1471                 #Too many problems in 2D plot with scale 
    1472                 pass 
    1473  
    1474         else: 
    1475             zmin_temp = self.zmin_2D 
     1456            with np.errstate(all='ignore'): 
     1457                output = np.log10(output) 
     1458            index = np.isfinite(output) 
     1459            if not index.all(): 
     1460                cutoff = (np.min(output[index]) - np.log10(2) 
     1461                          if index.any() else 0.) 
     1462                output[~index] = cutoff 
     1463        # TODO: fix handling of zmin_2D/zmax_2D in _onToggleScale 
     1464        # For now, use default vmin/vmax from data 
     1465        #vmin, vmax = self.zmin_2D, self.zmax_2D 
     1466        vmin, vmax = None, None 
    14761467        self.cmap = cmap 
    14771468        if self.dimension != 3: 
    14781469            #Re-adjust colorbar 
    14791470            self.subplot.figure.subplots_adjust(left=0.2, right=.8, bottom=.2) 
    1480  
    14811471            im = self.subplot.imshow(output, interpolation='nearest', 
    14821472                                     origin='lower', 
    1483                                      vmin=zmin_temp, vmax=self.zmax_2D, 
     1473                                     vmin=vmin, vmax=vmax, 
    14841474                                     cmap=self.cmap, 
    14851475                                     extent=(self.xmin_2D, self.xmax_2D, 

  • src/sas/sasview/__init__.py

    rb229a3b r5e16b30  
    1 __version__ = "4.2.0" 
     1from distutils.version import StrictVersion 
     2__version__ = "4.2.1" 
     3StrictVersion(__version__) 
     4__DOI__ = "Zenodo, 10.5281/zenodo.2561236" 
     5__release_date__ = "2019" 
    26__build__ = "GIT_COMMIT" 

  • src/sas/sasview/local_config.py

    r1b4cb41 r839f70f7  
    1616__appname__ = "SasView" 
    1717__version__ = sas.sasview.__version__ 
     18__DOI__ = sas.sasview.__DOI__ 
     19__release_date__ = sas.sasview.__release_date__ 
    1820__build__ = sas.sasview.__build__ 
    1921__download_page__ = 'https://github.com/SasView/sasview/releases' 
    … …  
    3638_do_tutorial = True 
    3739_acknowledgement_preamble =\ 
    38 '''To ensure the long term support and development of this software please''' +\ 
    39 ''' remember to:''' 
     40'''To ensure the long term support and development of this software please 
     41remember to:''' 
    4042_acknowledgement_preamble_bullet1 =\ 
    4143'''Acknowledge its use in your publications as :''' 
    … …  
    4749'''Send us your reference for our records: developers@sasview.org''' 
    4850_acknowledgement_publications = \ 
    49 '''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.''' 
     51("This work benefited from the use of the SasView application, originally" 
     52"developed under NSF Award DMR-0520547. SasView also contains code developed" 
     53"with funding from the EU Horizon 2020 programme under the SINE2020 project" 
     54"Grant No 654000.") 
    5055_acknowledgement_citation = \ 
    51 '''M. Doucet et al. SasView Version 4.2, Zenodo, 10.5281/zenodo.1412041''' 
     56'''M. Doucet et al. SasView Version %s, %s''' % (__version__, __DOI__) 
    5257_acknowledgement =  \ 
    53 '''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, BAM 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: http://www.sasview.org/contact.html 
    54 ''' 
     58("This work was originally developed as part of the DANSE project funded by" 
     59"the US NSF under Award DMR-0520547,\n but is currently maintained by a" 
     60"collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft," 
     61"DLS, BAM and the scattering community.\n\n SasView also contains code" 
     62"developed with funding from the EU Horizon 2020 programme under the SINE2020" 
     63"project (Grant No 654000).\nA list of individual contributors can be found" 
     64"at: http://www.sasview.org/contact.html") 
    5565 
    5666_homepage = "http://www.sasview.org" 
    … …  
    95105_corner_image = os.path.join(icon_path, "angles_flat.png") 
    96106_welcome_image = os.path.join(icon_path, "SVwelcome.png") 
    97 _copyright = "(c) 2009 - 2018, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS and BAM" 
     107_copyright = ("(c) 2009 - %s, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO," 
     108              "TU Delft, DLS and BAM") % __release_date__ 
    98109marketplace_url = "http://marketplace.sasview.org/" 
    99110 

  • src/sas/sascalc/corfunc/corfunc_calculator.py

    re090ba90 rdbfd307  
    245245        """Fit the Guinier region of the curve""" 
    246246        A = np.vstack([q**2, np.ones(q.shape)]).T 
    247         return lstsq(A, np.log(iq), rcond=None) 
     247        # CRUFT: numpy>=1.14.0 allows rcond=None for the following default 
     248        rcond = np.finfo(float).eps * max(A.shape) 
     249        return lstsq(A, np.log(iq), rcond=rcond) 
    248250 
    249251    def _fit_porod(self, q, iq): 

  • src/sas/sascalc/invariant/invariant.py

    re090ba90 rdbfd307  
    344344        else: 
    345345            A = np.vstack([linearized_data.x / linearized_data.dy, 1.0 / linearized_data.dy]).T 
     346            # CRUFT: numpy>=1.14.0 allows rcond=None for the following default 
     347            rcond = np.finfo(float).eps * max(A.shape) 
    346348            p, residuals, _, _ = np.linalg.lstsq(A, linearized_data.y / linearized_data.dy, 
    347                                                  rcond=None) 
     349                                                 rcond=rcond) 
    348350 
    349351            # Get the covariance matrix, defined as inv_cov = a_transposed * a 
Note: See TracChangeset for help on using the changeset viewer.