Changeset bbb725c in sasview


Ignore:
Timestamp:
Dec 10, 2018 8:20:50 PM (5 weeks ago)
Author:
GitHub <noreply@…>
Parents:
175b83f (diff), e4e9162 (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@…> (12/10/18 20:20:50)
git-committer:
GitHub <noreply@…> (12/10/18 20:20:50)
Message:

Merge e4e9162012e4f9bbd8ce8fe25bb99135a3a37e40 into 175b83fd92c67464de6cb1cd8c39db1d05503c91

Files:
3 deleted
45 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sascalc/calculator/instrument.py

    rf4775563 re090ba90  
    128128            self.size = 0 
    129129        else: 
    130             self.size = size 
     130            # TODO: Make sure detector size is number of pixels 
     131            # Could be detector dimensions in e.g., mm, but 
     132            # the resolution calculator assumes it is pixels. 
     133            # Being pixels, it has to be integers rather than float 
     134            self.size = [int(s) for s in size] 
    131135            validate(size[0]) 
    132136 
  • src/sas/sascalc/calculator/resolution_calculator.py

    r574adc7 re090ba90  
    10071007        try: 
    10081008            detector_offset = self.sample2detector_distance[1] 
    1009         except: 
    1010             logger.error(sys.exc_value) 
     1009        except Exception as exc: 
     1010            logger.error(exc) 
    10111011 
    10121012        # detector size in [no of pix_x,no of pix_y] 
     
    10941094            output.qx_data = qx_value 
    10951095            output.qy_data = qy_value 
    1096         except: 
    1097             logger.error(sys.exc_value) 
     1096        except Exception as exc: 
     1097            logger.error(exc) 
    10981098 
    10991099        return output 
  • src/sas/sascalc/corfunc/corfunc_calculator.py

    ra26f67f re090ba90  
    3030            self.start = start 
    3131            self.stop = stop 
    32             self._lastx = [] 
    33             self._lasty = [] 
     32            self._lastx = np.empty(0, dtype='d') 
     33            self._lasty = None 
    3434 
    3535        def __call__(self, x): 
    3636            # If input is a single number, evaluate the function at that number 
    3737            # and return a single number 
    38             if type(x) == float or type(x) == int: 
     38            if isinstance(x, (float, int)): 
    3939                return self._smoothed_function(np.array([x]))[0] 
    4040            # If input is a list, and is different to the last input, evaluate 
     
    4242            # the function was called, return the result that was calculated 
    4343            # last time instead of explicity evaluating the function again. 
    44             elif self._lastx == [] or x.tolist() != self._lastx.tolist(): 
    45                 self._lasty = self._smoothed_function(x) 
    46                 self._lastx = x 
     44            if not np.array_equal(x, self._lastx): 
     45                self._lastx, self._lasty = x, self._smoothed_function(x) 
    4746            return self._lasty 
    4847 
     
    8887        # Only process data of the class Data1D 
    8988        if not issubclass(data.__class__, Data1D): 
    90             raise ValueError("Data must be of the type DataLoader.Data1D") 
     89            raise ValueError("Correlation function cannot be computed with 2D data.") 
    9190 
    9291        # Prepare the data 
     
    246245        """Fit the Guinier region of the curve""" 
    247246        A = np.vstack([q**2, np.ones(q.shape)]).T 
    248         return lstsq(A, np.log(iq)) 
     247        return lstsq(A, np.log(iq), rcond=None) 
    249248 
    250249    def _fit_porod(self, q, iq): 
  • src/sas/sascalc/data_util/calcthread.py

    r574adc7 re090ba90  
    66from __future__ import print_function 
    77 
    8 import traceback 
    98import sys 
    109import logging 
     10import traceback 
     11from time import sleep 
     12 
    1113try: 
    1214    import _thread as thread 
    1315except ImportError: # CRUFT: python 2 support 
    1416    import thread 
    15  
    16 if sys.platform.count("darwin") > 0: 
    17     import time 
    18     stime = time.time() 
    19  
    20     def clock(): 
    21         return time.time() - stime 
    22  
    23     def sleep(t): 
    24         return time.sleep(t) 
    25 else: 
    26     from time import clock 
    27     from time import sleep 
     17try: 
     18    from time import perf_counter as clock 
     19except ImportError: # CRUFT: python < 3.3 
     20    if sys.platform.count("darwin") > 0: 
     21        from time import time as clock 
     22    else: 
     23        from time import clock 
    2824 
    2925logger = logging.getLogger(__name__) 
    30  
    3126 
    3227class CalcThread: 
     
    248243                self.exception_handler(*sys.exc_info()) 
    249244                return 
    250             except Exception: 
     245            except Exception as exc: 
    251246                pass 
    252247        logger.error(traceback.format_exc()) 
  • src/sas/sascalc/data_util/nxsunit.py

    r574adc7 re090ba90  
    9999    Strip '^' from unit names. 
    100100 
    101     * WARNING * this will incorrect transform 10^3 to 103. 
    102     """ 
    103     s.update((k.replace('^',''),v) 
    104              for k, v in list(s.items()) 
    105              if '^' in k) 
     101    * WARNING * this will incorrectly transform 10^3 to 103. 
     102    """ 
     103    stripped = [(k.replace('^',''),v) for k, v in s.items() if '^' in k] 
     104    s.update(stripped) 
    106105 
    107106def _build_all_units(): 
  • src/sas/sascalc/data_util/ordereddicttest.py

    rb699768 re090ba90  
    147147                    ]): 
    148148            self.assert_(dup is not od) 
    149             self.assertEquals(dup, od) 
    150             self.assertEquals(list(dup.items()), list(od.items())) 
    151             self.assertEquals(len(dup), len(od)) 
    152             self.assertEquals(type(dup), type(od)) 
     149            self.assertEqual(dup, od) 
     150            self.assertEqual(list(dup.items()), list(od.items())) 
     151            self.assertEqual(len(dup), len(od)) 
     152            self.assertEqual(type(dup), type(od)) 
    153153 
    154154    def test_repr(self): 
  • src/sas/sascalc/data_util/registry.py

    ra26f67f re090ba90  
    148148            # If file has associated loader(s) and they;ve failed 
    149149            raise last_exc 
    150         raise NoKnownLoaderException(e.message)  # raise generic exception 
     150        raise NoKnownLoaderException(str(message))  # raise generic exception 
  • src/sas/sascalc/data_util/uncertainty.py

    r574adc7 re090ba90  
    1919import numpy as np 
    2020 
    21 from .import err1d 
     21from . import err1d 
    2222from .formatnum import format_uncertainty 
    2323 
  • src/sas/sascalc/dataloader/data_info.py

    r9e6aeaf re090ba90  
    2626import numpy as np 
    2727import math 
     28from math import fabs 
    2829 
    2930class plottable_1D(object): 
     
    656657        return self._perform_operation(other, operation) 
    657658 
    658     def __div__(self, other): 
     659    def __truediv__(self, other): 
    659660        """ 
    660661        Divided a data set by another 
     
    667668            return a/b 
    668669        return self._perform_operation(other, operation) 
    669  
    670     def __rdiv__(self, other): 
     670    __div__ = __truediv__ 
     671 
     672    def __rtruediv__(self, other): 
    671673        """ 
    672674        Divided a data set by another 
     
    679681            return b/a 
    680682        return self._perform_operation(other, operation) 
     683    __rdiv__ = __rtruediv__ 
    681684 
    682685    def __or__(self, other): 
     
    800803            TOLERANCE = 0.01 
    801804            for i in range(len(self.x)): 
    802                 if math.fabs((self.x[i] - other.x[i])/self.x[i]) > TOLERANCE: 
     805                if fabs(self.x[i] - other.x[i]) > self.x[i]*TOLERANCE: 
    803806                    msg = "Incompatible data sets: x-values do not match" 
    804807                    raise ValueError(msg) 
     
    10221025                raise ValueError(msg) 
    10231026            for ind in range(len(self.data)): 
    1024                 if math.fabs((self.qx_data[ind] - other.qx_data[ind])/self.qx_data[ind]) > TOLERANCE: 
     1027                if fabs(self.qx_data[ind] - other.qx_data[ind]) > fabs(self.qx_data[ind])*TOLERANCE: 
    10251028                    msg = "Incompatible data sets: qx-values do not match: %s %s" % (self.qx_data[ind], other.qx_data[ind]) 
    10261029                    raise ValueError(msg) 
    1027                 if math.fabs((self.qy_data[ind] - other.qy_data[ind])/self.qy_data[ind]) > TOLERANCE: 
     1030                if fabs(self.qy_data[ind] - other.qy_data[ind]) > fabs(self.qy_data[ind])*TOLERANCE: 
    10281031                    msg = "Incompatible data sets: qy-values do not match: %s %s" % (self.qy_data[ind], other.qy_data[ind]) 
    10291032                    raise ValueError(msg) 
  • src/sas/sascalc/dataloader/loader.py

    r4a8d55c re090ba90  
    169169                        if self._identify_plugin(module): 
    170170                            readers_found += 1 
    171                     except: 
     171                    except Exception as exc: 
    172172                        msg = "Loader: Error importing " 
    173                         msg += "%s\n  %s" % (item, sys.exc_value) 
     173                        msg += "%s\n  %s" % (item, exc) 
    174174                        logger.error(msg) 
    175175 
     
    191191                                if self._identify_plugin(module): 
    192192                                    readers_found += 1 
    193                             except: 
     193                            except Exception as exc: 
    194194                                msg = "Loader: Error importing" 
    195                                 msg += " %s\n  %s" % (mfile, sys.exc_value) 
     195                                msg += " %s\n  %s" % (mfile, exc) 
    196196                                logger.error(msg) 
    197197 
    198                     except: 
     198                    except Exception as exc: 
    199199                        msg = "Loader: Error importing " 
    200                         msg += " %s\n  %s" % (item, sys.exc_value) 
     200                        msg += " %s\n  %s" % (item, exc) 
    201201                        logger.error(msg) 
    202202 
     
    242242                    self.writers[ext].append(loader.write) 
    243243 
    244             except: 
     244            except Exception as exc: 
    245245                msg = "Loader: Error accessing" 
    246                 msg += " Reader in %s\n  %s" % (module.__name__, sys.exc_value) 
     246                msg += " Reader in %s\n  %s" % (module.__name__, exc) 
    247247                logger.error(msg) 
    248248        return reader_found 
     
    275275                    self.wildcards.append(wcard) 
    276276 
    277         except: 
     277        except Exception as exc: 
    278278            msg = "Loader: Error accessing Reader " 
    279             msg += "in %s\n  %s" % (loader.__name__, sys.exc_value) 
     279            msg += "in %s\n  %s" % (loader.__name__, exc) 
    280280            logger.error(msg) 
    281281        return reader_found 
     
    320320                        self.writers[ext].insert(0, loader.write) 
    321321 
    322             except: 
     322            except Exception as exc: 
    323323                msg = "Loader: Error accessing Reader" 
    324                 msg += " in %s\n  %s" % (module.__name__, sys.exc_value) 
     324                msg += " in %s\n  %s" % (module.__name__, exc) 
    325325                logger.error(msg) 
    326326        return reader_found 
  • src/sas/sascalc/dataloader/manipulations.py

    r574adc7 re4e9162  
    928928 
    929929        # Organize the results 
    930         for i in range(self.nbins): 
    931             y[i] = y[i] / y_counts[i] 
    932             y_err[i] = math.sqrt(y_err[i]) / y_counts[i] 
    933  
    934             # The type of averaging: phi,q2, or q 
    935             # Calculate x[i]should be at the center of the bin 
     930        with np.errstate(divide='ignore', invalid='ignore'): 
     931            y = y/y_counts 
     932            y_err = np.sqrt(y_err)/y_counts 
     933            # The type of averaging: phi, q2, or q 
     934            # Calculate x values at the center of the bin 
    936935            if run.lower() == 'phi': 
    937                 x[i] = (self.phi_max - self.phi_min) / self.nbins * \ 
    938                     (1.0 * i + 0.5) + self.phi_min 
     936                step = (self.phi_max - self.phi_min) / self.nbins 
     937                x = (np.arange(self.nbins) + 0.5) * step + self.phi_min 
    939938            else: 
    940                 # We take the center of ring area, not radius. 
    941                 # This is more accurate than taking the radial center of ring. 
    942                 # delta_r = (self.r_max - self.r_min) / self.nbins 
    943                 # r_inner = self.r_min + delta_r * i 
    944                 # r_outer = r_inner + delta_r 
    945                 # x[i] = math.sqrt((r_inner * r_inner + r_outer * r_outer) / 2) 
    946                 x[i] = x[i] / y_counts[i] 
    947         y_err[y_err == 0] = np.average(y_err) 
     939                # set q to the average of the q values within each bin 
     940                x = x/y_counts 
     941 
     942                ### Alternate algorithm 
     943                ## We take the center of ring area, not radius. 
     944                ## This is more accurate than taking the radial center of ring. 
     945                #step = (self.r_max - self.r_min) / self.nbins 
     946                #r_inner = self.r_min + step * np.arange(self.nbins) 
     947                #x = math.sqrt((r_inner**2 + (r_inner + step)**2) / 2) 
     948 
    948949        idx = (np.isfinite(y) & np.isfinite(y_err)) 
    949950        if x_err is not None: 
  • src/sas/sascalc/dataloader/readers/associations.py

    ra32c19c re090ba90  
    5353                exec("loader.associate_file_type('%s', %s)" 
    5454                     % (ext.upper(), reader)) 
    55             except: 
     55            except Exception as exc: 
    5656                msg = "read_associations: skipping association" 
    57                 msg += " for %s\n  %s" % (ext.lower(), sys.exc_value) 
     57                msg += " for %s\n  %s" % (ext.lower(), exc) 
    5858                logger.error(msg) 
  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    r2469df7 re090ba90  
    12391239                        conv = Converter(units) 
    12401240                        setattrchain(storage, variable, conv(value, units=local_unit)) 
    1241                     except Exception: 
    1242                         _, exc_value, _ = sys.exc_info() 
     1241                    except Exception as exc: 
    12431242                        err_mess = "CanSAS reader: could not convert" 
    12441243                        err_mess += " %s unit [%s]; expecting [%s]\n  %s" \ 
    1245                             % (variable, units, local_unit, exc_value) 
     1244                            % (variable, units, local_unit, exc) 
    12461245                        self.errors.add(err_mess) 
    12471246                        if optional: 
  • src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

    r61f329f0 re090ba90  
    475475                for i in range(0, dataset.mask.size - 1): 
    476476                    zeros[i] = dataset.mask[i] 
    477             except: 
    478                 self.errors.add(sys.exc_value) 
     477            except Exception as exc: 
     478                self.errors.add(exc) 
    479479            dataset.mask = zeros 
    480480            # Calculate the actual Q matrix 
  • src/sas/sascalc/fit/expression.py

    r574adc7 re090ba90  
    210210 
    211211    #print("Function: "+functiondef) 
    212     exec functiondef in globals,locals 
     212    exec(functiondef, globals, locals) 
    213213    retfn = locals['eval_expressions'] 
    214214 
  • src/sas/sascalc/fit/models.py

    rb963b20 re090ba90  
    1212import py_compile 
    1313import shutil 
     14 
     15from six import reraise 
    1416 
    1517from sasmodels.sasview_model import load_custom_model, load_standard_models 
     
    6264    try: 
    6365        new_instance = model() 
    64     except Exception: 
    65         msg = "Plugin %s error in __init__ \n\t: %s %s\n" % (str(name), 
    66                                                              str(sys.exc_type), 
    67                                                              sys.exc_info()[1]) 
     66    except Exception as exc: 
     67        msg = ("Plugin %s error in __init__ \n\t: %s %s\n" 
     68               % (name, type(exc), exc)) 
    6869        plugin_log(msg) 
    6970        return None 
     
    7273        try: 
    7374            value = new_instance.function() 
    74         except Exception: 
     75        except Exception as exc: 
    7576            msg = "Plugin %s: error writing function \n\t :%s %s\n " % \ 
    76                     (str(name), str(sys.exc_type), sys.exc_info()[1]) 
     77                    (str(name), str(type(exc)), exc) 
    7778            plugin_log(msg) 
    7879            return None 
     
    139140        if type is not None and issubclass(type, py_compile.PyCompileError): 
    140141            print("Problem with", repr(value)) 
    141             raise type, value, tb 
     142            reraise(type, value, tb) 
    142143        return 1 
    143144 
     
    153154        compileall.compile_dir(dir=dir, ddir=dir, force=0, 
    154155                               quiet=report_problem) 
    155     except Exception: 
    156         return sys.exc_info()[1] 
     156    except Exception as exc: 
     157        return exc 
    157158    return None 
    158159 
     
    185186                    model.name = PLUGIN_NAME_BASE + model.name 
    186187                plugins[model.name] = model 
    187             except Exception: 
     188            except Exception as exc: 
    188189                msg = traceback.format_exc() 
    189190                msg += "\nwhile accessing model in %r" % path 
  • src/sas/sascalc/fit/pagestate.py

    r863ac2c re090ba90  
    650650                    #Truncating string so print doesn't complain of being outside margins 
    651651                    if sys.platform != "win32": 
    652                         MAX_STRING_LENGHT = 50 
    653                         if len(file_value) > MAX_STRING_LENGHT: 
    654                             file_value = "File name:.."+file_value[-MAX_STRING_LENGHT+10:] 
     652                        MAX_STRING_LENGTH = 50 
     653                        if len(file_value) > MAX_STRING_LENGTH: 
     654                            file_value = "File name:.."+file_value[-MAX_STRING_LENGTH+10:] 
    655655                    file_name = CENTRE % file_value 
    656656                    if len(title) == 0: 
     
    905905                doc_model = newdoc.createElement('model_list_item') 
    906906                doc_model.setAttribute('checked', str(model[0].GetValue())) 
    907                 keys = model[1].keys() 
     907                keys = list(model[1].keys()) 
    908908                doc_model.setAttribute('name', str(keys[0])) 
    909909                values = model[1].get(keys[0]) 
     
    964964        if node.get('version'): 
    965965            # Get the version for model conversion purposes 
    966             x = re.sub('[^\d.]', '', node.get('version')) 
     966            x = re.sub(r'[^\d.]', '', node.get('version')) 
    967967            self.version = tuple(int(e) for e in str.split(x, ".")) 
    968968            # The tuple must be at least 3 items long 
     
    984984                try: 
    985985                    self.timestamp = float(entry.get('epoch')) 
    986                 except Exception: 
     986                except Exception as exc: 
    987987                    msg = "PageState.fromXML: Could not" 
    988                     msg += " read timestamp\n %s" % sys.exc_value 
     988                    msg += " read timestamp\n %s" % exc 
    989989                    logger.error(msg) 
    990990 
     
    12821282                        if isinstance(data.run_name, dict): 
    12831283                            # Note: key order in dict is not guaranteed, so sort 
    1284                             name = data.run_name.keys()[0] 
     1284                            name = list(data.run_name.keys())[0] 
    12851285                        else: 
    12861286                            name = data.run_name 
  • src/sas/sascalc/invariant/invariant.py

    r574adc7 re090ba90  
    344344        else: 
    345345            A = np.vstack([linearized_data.x / linearized_data.dy, 1.0 / linearized_data.dy]).T 
    346             (p, residuals, _, _) = np.linalg.lstsq(A, linearized_data.y / linearized_data.dy) 
     346            p, residuals, _, _ = np.linalg.lstsq(A, linearized_data.y / linearized_data.dy, 
     347                                                 rcond=None) 
    347348 
    348349            # Get the covariance matrix, defined as inv_cov = a_transposed * a 
  • src/sas/sascalc/pr/distance_explorer.py

    r959eb01 re090ba90  
    9999                results.pos_err.append(pos_err) 
    100100                results.osc.append(osc) 
    101             except: 
     101            except Exception as exc: 
    102102                # This inversion failed, skip this D_max value 
    103103                msg = "ExploreDialog: inversion failed for " 
    104                 msg += "D_max=%s\n %s" % (str(d), sys.exc_value) 
     104                msg += "D_max=%s\n %s" % (str(d), exc) 
    105105                results.errors.append(msg) 
    106106 
  • src/sas/sascalc/pr/fit/expression.py

    r574adc7 re090ba90  
    210210 
    211211    #print("Function: "+functiondef) 
    212     exec functiondef in globals,locals 
     212    exec(functiondef, globals, locals) 
    213213    retfn = locals['eval_expressions'] 
    214214 
  • src/sas/sascalc/pr/num_term.py

    r3e6829d rbbb725c  
    182182                data_y = np.append(data_y, test_y) 
    183183                data_err = np.append(data_err, err) 
    184             except: 
    185                 logger.error(sys.exc_value) 
     184            except Exception as exc: 
     185                logger.error(exc) 
    186186 
    187187    return data_x, data_y, data_err 
  • src/sas/sascalc/realspace/VolumeCanvas.py

    r98e3f24 re090ba90  
    472472            Return a list of the shapes 
    473473        """ 
    474         return self.shapes.keys() 
     474        return list(self.shapes.keys()) 
    475475 
    476476    def _addSingleShape(self, shapeDesc): 
  • test/calculatorview/test/utest_gui_sld.py

    r959eb01 r88d2e70  
    3333        self.sld_frame.panel.ProcessEvent(clickEvent) 
    3434        bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    35         self.assert_(bkg.GetAsString() == 'pink') 
     35        self.assertTrue(bkg.GetAsString() == 'pink') 
    3636        #compute invariant without entering a value for compound 
    3737        self.sld_frame.panel.compound_ctl.SetValue("") 
     
    3939        self.sld_frame.panel.ProcessEvent(clickEvent) 
    4040        bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    41         self.assert_(bkg.GetAsString() == 'pink') 
     41        self.assertTrue(bkg.GetAsString() == 'pink') 
    4242        #compute invariant without entering a value for compound 
    4343        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
     
    4545        self.sld_frame.panel.ProcessEvent(clickEvent) 
    4646        bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    47         self.assert_(bkg.GetAsString() == 'white') 
     47        self.assertTrue(bkg.GetAsString() == 'white') 
    4848        
    4949    def testDensityTextCtrl(self): 
     
    5959        self.sld_frame.panel.ProcessEvent(clickEvent) 
    6060        bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    61         self.assert_(bkg.GetAsString() == 'pink') 
     61        self.assertTrue(bkg.GetAsString() == 'pink') 
    6262        #compute invariant without entering a value for density 
    6363        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
     
    6565        self.sld_frame.panel.ProcessEvent(clickEvent) 
    6666        bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    67         self.assert_(bkg.GetAsString() == 'pink') 
     67        self.assertTrue(bkg.GetAsString() == 'pink') 
    6868        #compute invariant without entering a value for density 
    6969        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
     
    7171        self.sld_frame.panel.ProcessEvent(clickEvent) 
    7272        bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    73         self.assert_(bkg.GetAsString() == 'white') 
     73        self.assertTrue(bkg.GetAsString() == 'white') 
    7474         
    7575    def testWavelengthTextCtrl(self): 
     
    8686        self.sld_frame.panel.ProcessEvent(clickEvent) 
    8787        bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    88         self.assert_(bkg.GetAsString() == 'pink') 
     88        self.assertTrue(bkg.GetAsString() == 'pink') 
    8989        #compute invariant without entering a value for wavelegnth 
    9090        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
     
    9393        self.sld_frame.panel.ProcessEvent(clickEvent) 
    9494        cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    95         self.assert_(cp_bkg.GetAsString() == 'white') 
     95        self.assertTrue(cp_bkg.GetAsString() == 'white') 
    9696        ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    97         self.assert_(ds_bkg.GetAsString() == 'white') 
     97        self.assertTrue(ds_bkg.GetAsString() == 'white') 
    9898        wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    9999        value = self.sld_frame.panel.wavelength_ctl.GetValue() 
    100         self.assert_(wv_bkg.GetAsString() == 'white') 
    101         self.assert_(float(value) == WAVELENGTH) 
     100        self.assertTrue(wv_bkg.GetAsString() == 'white') 
     101        self.assertTrue(float(value) == WAVELENGTH) 
    102102        sld_real = self.sld_frame.panel.neutron_sld_real_ctl.GetValue() 
    103103        sld_im = self.sld_frame.panel.neutron_sld_im_ctl.GetValue() 
     
    110110        length = self.sld_frame.panel.neutron_length_ctl.GetValue() 
    111111         
    112         self.assertAlmostEquals(float(sld_real), 1.04e-6, 1) 
    113         self.assertAlmostEquals(float(sld_im), -1.5e-7, 1) 
     112        self.assertAlmostEqual(float(sld_real), 1.04e-6, 1) 
     113        self.assertAlmostEqual(float(sld_im), -1.5e-7, 1) 
    114114        #test absorption value 
    115         self.assertAlmostEquals(float(abs) , 0.0741, 2) 
    116         self.assertAlmostEquals(float(incoh), 5.62, 2) 
     115        self.assertAlmostEqual(float(abs) , 0.0741, 2) 
     116        self.assertAlmostEqual(float(incoh), 5.62, 2) 
    117117        #Test length 
    118         self.assertAlmostEquals(float(length), 0.1755, 2) 
     118        self.assertAlmostEqual(float(length), 0.1755, 2) 
    119119        #test Cu sld 
    120         self.assertAlmostEquals(float(cu_real), 9.46e-6, 1) 
    121         self.assertAlmostEquals(float(cu_im), 3.01e-8) 
     120        self.assertAlmostEqual(float(cu_real), 9.46e-6, 1) 
     121        self.assertAlmostEqual(float(cu_im), 3.01e-8) 
    122122        # test Mo sld 
    123         self.assertAlmostEquals(float(mo_real), 9.43e-6) 
    124         self.assertAlmostEquals(float(mo_im), 5.65e-7, 1) 
     123        self.assertAlmostEqual(float(mo_real), 9.43e-6) 
     124        self.assertAlmostEqual(float(mo_im), 5.65e-7, 1) 
    125125        #compute invariant with all correct inputs value 
    126126        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
     
    130130        bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    131131        value = self.sld_frame.panel.wavelength_ctl.GetValue() 
    132         self.assert_(bkg.GetAsString() == 'white') 
    133         self.assert_(float(value) == WAVELENGTH/2) 
     132        self.assertTrue(bkg.GetAsString() == 'white') 
     133        self.assertTrue(float(value) == WAVELENGTH/2) 
    134134         
    135135    def testSomeCombination(self): 
     
    145145        self.sld_frame.panel.ProcessEvent(clickEvent) 
    146146        cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    147         self.assert_(cp_bkg.GetAsString() == 'white') 
     147        self.assertTrue(cp_bkg.GetAsString() == 'white') 
    148148        ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    149         self.assert_(ds_bkg.GetAsString() == 'white') 
     149        self.assertTrue(ds_bkg.GetAsString() == 'white') 
    150150        wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    151         self.assert_(wv_bkg.GetAsString() == 'pink') 
     151        self.assertTrue(wv_bkg.GetAsString() == 'pink') 
    152152        #density, wavelength is invalid 
    153153        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
     
    158158        self.sld_frame.panel.ProcessEvent(clickEvent) 
    159159        cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    160         self.assert_(cp_bkg.GetAsString() == 'white') 
     160        self.assertTrue(cp_bkg.GetAsString() == 'white') 
    161161        ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    162         self.assert_(ds_bkg.GetAsString() == 'pink') 
     162        self.assertTrue(ds_bkg.GetAsString() == 'pink') 
    163163        wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    164         self.assert_(wv_bkg.GetAsString() == 'pink') 
     164        self.assertTrue(wv_bkg.GetAsString() == 'pink') 
    165165        #density, wavelength is invalid 
    166166        self.sld_frame.panel.compound_ctl.SetValue("invalid compound") 
     
    171171        self.sld_frame.panel.ProcessEvent(clickEvent) 
    172172        cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    173         self.assert_(cp_bkg.GetAsString() == 'pink') 
     173        self.assertTrue(cp_bkg.GetAsString() == 'pink') 
    174174        ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    175         self.assert_(ds_bkg.GetAsString() == 'pink') 
     175        self.assertTrue(ds_bkg.GetAsString() == 'pink') 
    176176        wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    177         self.assert_(wv_bkg.GetAsString() == 'white') 
     177        self.assertTrue(wv_bkg.GetAsString() == 'white') 
    178178        value = self.sld_frame.panel.wavelength_ctl.GetValue() 
    179         self.assert_(float(value) == WAVELENGTH) 
     179        self.assertTrue(float(value) == WAVELENGTH) 
    180180 
    181181         
  • test/pr_inversion/test/utest_explorer.py

    rf53d684 r1852b17  
    33""" 
    44 
     5import sys 
    56import os.path 
    67import unittest, math, numpy 
    7 from utest_invertor import load 
    88from sas.sascalc.pr.invertor import Invertor 
    99from sas.sascalc.pr.distance_explorer import DistExplorer 
    1010 
     11try: 
     12    from utest_invertor import load 
     13except ImportError: 
     14    from .utest_invertor import load 
    1115 
    1216def find(filename): 
     
    3640        self.assertEqual(len(results.errors), 0) 
    3741        self.assertEqual(len(results.chi2), 25) 
    38          
     42 
    3943if __name__ == '__main__': 
    4044    unittest.main() 
  • test/sascalculator/test/utest_sld.py

    ra50da82 r88d2e70  
    5151                                  molecule_formula=self.sld_formula) 
    5252        #test sld 
    53         self.assertAlmostEquals(sld_real * _SCALE, -5.6e-7, 1) 
    54         self.assertAlmostEquals(sld_im * _SCALE, 0) 
     53        self.assertAlmostEqual(sld_real * _SCALE, -5.6e-7, 1) 
     54        self.assertAlmostEqual(sld_im * _SCALE, 0) 
    5555        #test absorption value 
    56         self.assertAlmostEquals(abs, 0.0741, 2) 
    57         self.assertAlmostEquals(incoh, 5.62, 2) 
     56        self.assertAlmostEqual(abs, 0.0741, 2) 
     57        self.assertAlmostEqual(incoh, 5.62, 2) 
    5858        #Test length 
    59         self.assertAlmostEquals(length, 0.1755, 3) 
     59        self.assertAlmostEqual(length, 0.1755, 3) 
    6060        #test Cu sld 
    61         self.assertAlmostEquals(cu_real * _SCALE, 9.46e-6, 1) 
    62         self.assertAlmostEquals(cu_im * _SCALE, 3.01e-8) 
     61        self.assertAlmostEqual(cu_real * _SCALE, 9.46e-6, 1) 
     62        self.assertAlmostEqual(cu_im * _SCALE, 3.01e-8) 
    6363        # test Mo sld 
    64         self.assertAlmostEquals(mo_real * _SCALE, 9.43e-6) 
    65         self.assertAlmostEquals(mo_im * _SCALE, 5.65e-7,1) 
     64        self.assertAlmostEqual(mo_real * _SCALE, 9.43e-6) 
     65        self.assertAlmostEqual(mo_im * _SCALE, 5.65e-7,1) 
    6666 
    6767 
     
    9191                                  molecule_formula=self.sld_formula) 
    9292        #test sld 
    93         self.assertAlmostEquals(sld_real * _SCALE, 6.33e-6, 1) 
    94         self.assertAlmostEquals(sld_im * _SCALE, 0) 
     93        self.assertAlmostEqual(sld_real * _SCALE, 6.33e-6, 1) 
     94        self.assertAlmostEqual(sld_im * _SCALE, 0) 
    9595        #test absorption value 
    96         self.assertAlmostEquals(abs, 1.35e-4, 2) 
    97         self.assertAlmostEquals(incoh, 0.138, 2) 
     96        self.assertAlmostEqual(abs, 1.35e-4, 2) 
     97        self.assertAlmostEqual(incoh, 0.138, 2) 
    9898        #Test length 
    99         self.assertAlmostEquals(length, 1.549, 3) 
     99        self.assertAlmostEqual(length, 1.549, 3) 
    100100        #test Cu sld 
    101         self.assertAlmostEquals(cu_real * _SCALE, 9.36e-6, 1) 
    102         self.assertAlmostEquals(cu_im * _SCALE, 2.98e-8) 
     101        self.assertAlmostEqual(cu_real * _SCALE, 9.36e-6, 1) 
     102        self.assertAlmostEqual(cu_im * _SCALE, 2.98e-8) 
    103103        # test Mo sld 
    104         self.assertAlmostEquals(mo_real * _SCALE, 9.33e-6) 
    105         self.assertAlmostEquals(mo_im * _SCALE, 5.59e-9,1) 
     104        self.assertAlmostEqual(mo_real * _SCALE, 9.33e-6) 
     105        self.assertAlmostEqual(mo_im * _SCALE, 5.59e-9,1) 
    106106 
    107107 
     
    131131                                  molecule_formula=self.sld_formula) 
    132132        #test sld 
    133         self.assertAlmostEquals(sld_real * _SCALE, 1.04e-6, 1) 
    134         self.assertAlmostEquals(sld_im * _SCALE, -1.5e-7, 1) 
     133        self.assertAlmostEqual(sld_real * _SCALE, 1.04e-6, 1) 
     134        self.assertAlmostEqual(sld_im * _SCALE, -1.5e-7, 1) 
    135135        #test absorption value 
    136         self.assertAlmostEquals(abs, 180.0,0) 
    137         self.assertAlmostEquals(incoh, 0.0754, 2) 
     136        self.assertAlmostEqual(abs, 180.0,0) 
     137        self.assertAlmostEqual(incoh, 0.0754, 2) 
    138138        #Test length 
    139         self.assertAlmostEquals(length, 0.005551, 4) 
     139        self.assertAlmostEqual(length, 0.005551, 4) 
    140140        #test Cu sld 
    141         self.assertAlmostEquals(cu_real * _SCALE, 2.89e-5, 1) 
    142         self.assertAlmostEquals(cu_im * _SCALE, 2.81e-6) 
     141        self.assertAlmostEqual(cu_real * _SCALE, 2.89e-5, 1) 
     142        self.assertAlmostEqual(cu_im * _SCALE, 2.81e-6) 
    143143        # test Mo sld 
    144         self.assertAlmostEquals(mo_real * _SCALE, 2.84e-5, 1) 
    145         self.assertAlmostEquals(mo_im * _SCALE, 7.26e-7,1) 
     144        self.assertAlmostEqual(mo_real * _SCALE, 2.84e-5, 1) 
     145        self.assertAlmostEqual(mo_im * _SCALE, 7.26e-7,1) 
    146146 
    147147if __name__ == '__main__': 
  • test/sasdataloader/plugins/test_reader.py

    raaf5e49 r88d2e70  
    4040                    input_f =  open(path,'r') 
    4141                except : 
    42                     raise  RuntimeError, "ascii_reader: cannot open %s" % path 
     42                    raise  RuntimeError("ascii_reader: cannot open %s" % path) 
    4343                buff = input_f.read() 
    4444                lines = buff.split('\n') 
     
    5555                return output 
    5656        else: 
    57             raise RuntimeError, "%s is not a file" % path 
     57            raise RuntimeError("%s is not a file" % path) 
    5858        return None 
    5959     
  • test/sasdataloader/test/utest_abs_reader.py

    rbd5c3b1 r88d2e70  
    8080        data_cor = Loader().load(find("sam14_cor.cor")) 
    8181        for i in range(0, len(data_abs) - 1): 
    82             self.assertEquals(data_abs.x[i], data_cor.x[i]) 
    83             self.assertEquals(data_abs.y[i], data_cor.y[i]) 
    84             self.assertEquals(data_abs.dxl[i], data_cor.dxl[i]) 
    85             self.assertEquals(data_abs.dxw[i], data_cor.dxw[i]) 
     82            self.assertEqual(data_abs.x[i], data_cor.x[i]) 
     83            self.assertEqual(data_abs.y[i], data_cor.y[i]) 
     84            self.assertEqual(data_abs.dxl[i], data_cor.dxl[i]) 
     85            self.assertEqual(data_abs.dxw[i], data_cor.dxw[i]) 
    8686            self.assertTrue(data_abs.dxl > 0) 
    8787 
     
    358358        self.assertEqual(self.data.dy[0], 3) 
    359359        self.assertEqual(self.data.x[1], 0.03) 
    360         self.assertAlmostEquals(self.data.y[1], 1001.0) 
     360        self.assertAlmostEqual(self.data.y[1], 1001.0) 
    361361        self.assertEqual(self.data.dxl[1], 0.005) 
    362362        self.assertEqual(self.data.dxw[1], 0.001) 
  • test/sasdataloader/test/utest_generic_file_reader_class.py

    r4a8d55c r88d2e70  
    4545        last_f = f[0] 
    4646        if hasattr(last_f, "errors"): 
    47             self.assertEquals(len(last_f.errors), 1) 
     47            self.assertEqual(len(last_f.errors), 1) 
    4848        else: 
    4949            self.fail("Errors did not propogate to the file properly.") 
     
    7070        self.check_unknown_extension(xml_load[0]) 
    7171        # Be sure the deprecation warning is passed with the file 
    72         self.assertEquals(len(asc_load[0].errors), 1) 
    73         self.assertEquals(len(nxs_load[0].errors), 1) 
     72        self.assertEqual(len(asc_load[0].errors), 1) 
     73        self.assertEqual(len(nxs_load[0].errors), 1) 
    7474 
    7575    def check_unknown_extension(self, data): 
    7676        self.assertTrue(isinstance(data, Data1D)) 
    77         self.assertEquals(len(data.x), 138) 
    78         self.assertEquals(data.sample.ID, "TK49 c10_SANS") 
    79         self.assertEquals(data.meta_data["loader"], "CanSAS XML 1D") 
     77        self.assertEqual(len(data.x), 138) 
     78        self.assertEqual(data.sample.ID, "TK49 c10_SANS") 
     79        self.assertEqual(data.meta_data["loader"], "CanSAS XML 1D") 
    8080 
    8181    def tearDown(self): 
  • test/sasinvariant/test/utest_data_handling.py

    rf53d684 r88d2e70  
    4545 
    4646        # Test results 
    47         self.assertAlmostEquals(p[0], 1.0, 5) 
    48         self.assertAlmostEquals(p[1], 0.0, 5) 
     47        self.assertAlmostEqual(p[0], 1.0, 5) 
     48        self.assertAlmostEqual(p[1], 0.0, 5) 
    4949 
    5050    def test_fit_linear_data_with_noise(self): 
     
    7474 
    7575        # Test results 
    76         self.assertAlmostEquals(p[0], 1.0, 5) 
    77         self.assertAlmostEquals(p[1], 0.0, 5) 
     76        self.assertAlmostEqual(p[0], 1.0, 5) 
     77        self.assertAlmostEqual(p[1], 0.0, 5) 
    7878 
    7979    def test_fit_linear_data_with_noise_and_fixed_par(self): 
     
    506506        for i in range(len(self.data.x)): 
    507507            value  = math.fabs(test_y[i]-self.data.y[i])/self.data.y[i] 
    508             self.assert_(value < 0.001) 
     508            self.assertTrue(value < 0.001) 
    509509             
    510510class TestDataExtraLowSlitGuinier(unittest.TestCase): 
     
    553553 
    554554        test_y = inv._low_extrapolation_function.evaluate_model(x=self.data.x[:inv._low_extrapolation_npts]) 
    555         self.assert_(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts])) 
     555        self.assertTrue(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts])) 
    556556         
    557557        for i in range(inv._low_extrapolation_npts): 
    558558            value  = math.fabs(test_y[i]-self.data.y[i])/self.data.y[i] 
    559             self.assert_(value < 0.001) 
     559            self.assertTrue(value < 0.001) 
    560560             
    561561    def test_low_data(self): 
     
    589589                                               npts = inv._low_extrapolation_npts)  
    590590        test_y = data_in_range.y 
    591         self.assert_(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts])) 
     591        self.assertTrue(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts])) 
    592592        for i in range(inv._low_extrapolation_npts): 
    593593            value  = math.fabs(test_y[i]-self.data.y[i])/self.data.y[i] 
    594             self.assert_(value < 0.001)     
     594            self.assertTrue(value < 0.001) 
    595595        
    596596             
     
    642642         
    643643        test_y = inv._high_extrapolation_function.evaluate_model(x=self.data.x[start: ]) 
    644         self.assert_(len(test_y) == len(self.data.y[start:])) 
     644        self.assertTrue(len(test_y) == len(self.data.y[start:])) 
    645645         
    646646        for i in range(len(self.data.x[start:])): 
    647647            value  = math.fabs(test_y[i]-self.data.y[start+i])/self.data.y[start+i] 
    648             self.assert_(value < 0.001) 
     648            self.assertTrue(value < 0.001) 
    649649             
    650650    def test_high_data(self): 
     
    677677                                               npts = inv._high_extrapolation_npts)  
    678678        test_y = data_in_range.y 
    679         self.assert_(len(test_y) == len(self.data.y[start:])) 
     679        self.assertTrue(len(test_y) == len(self.data.y[start:])) 
    680680        temp = self.data.y[start:] 
    681681         
    682682        for i in range(len(self.data.x[start:])): 
    683683            value  = math.fabs(test_y[i]- temp[i])/temp[i] 
    684             self.assert_(value < 0.001)                 
     684            self.assertTrue(value < 0.001) 
  • test/sasinvariant/test/utest_use_cases.py

    rf53d684 r88d2e70  
    3939 
    4040        # Test results 
    41         self.assertAlmostEquals(p[0], 2.3983,3) 
    42         self.assertAlmostEquals(p[1], 0.87833,3) 
     41        self.assertAlmostEqual(p[0], 2.3983,3) 
     42        self.assertAlmostEqual(p[1], 0.87833,3) 
    4343 
    4444    def test_fit_line_data_fixed(self): 
     
    5454 
    5555        # Test results 
    56         self.assertAlmostEquals(p[0], 4) 
    57         self.assertAlmostEquals(p[1], -4.0676,3) 
     56        self.assertAlmostEqual(p[0], 4) 
     57        self.assertAlmostEqual(p[1], -4.0676,3) 
    5858 
    5959 
     
    7878 
    7979        # Test results 
    80         self.assertAlmostEquals(p[0], 2.4727,3) 
    81         self.assertAlmostEquals(p[1], 0.6,3) 
     80        self.assertAlmostEqual(p[0], 2.4727,3) 
     81        self.assertAlmostEqual(p[1], 0.6,3) 
    8282 
    8383    def test_fit_line_data_fixed_no_weight(self): 
     
    9393 
    9494        # Test results 
    95         self.assertAlmostEquals(p[0], 4) 
    96         self.assertAlmostEquals(p[1], -7.8,3) 
     95        self.assertAlmostEqual(p[0], 4) 
     96        self.assertAlmostEqual(p[1], -7.8,3) 
    9797 
    9898 
     
    132132 
    133133        # Test results 
    134         self.assertAlmostEquals(qstar, 7.48959e-5,2) 
    135         self.assertAlmostEquals(v, 0.005644689, 4) 
    136         self.assertAlmostEquals(s , 941.7452, 3) 
     134        self.assertAlmostEqual(qstar, 7.48959e-5,2) 
     135        self.assertAlmostEqual(v, 0.005644689, 4) 
     136        self.assertAlmostEqual(s , 941.7452, 3) 
    137137 
    138138    def test_use_case_2(self): 
     
    153153        s, ds = inv.get_surface_with_error(contrast=2.6e-6, porod_const=2) 
    154154        # Test results 
    155         self.assertAlmostEquals(qstar, 7.48959e-5,2) 
    156         self.assertAlmostEquals(v, 0.005644689, 1) 
    157         self.assertAlmostEquals(s , 941.7452, 3) 
     155        self.assertAlmostEqual(qstar, 7.48959e-5,2) 
     156        self.assertAlmostEqual(v, 0.005644689, 1) 
     157        self.assertAlmostEqual(s , 941.7452, 3) 
    158158 
    159159    def test_use_case_3(self): 
     
    190190 
    191191        # Test results 
    192         self.assertAlmostEquals(qstar, 7.49e-5, 1) 
    193         self.assertAlmostEquals(v, 0.005648401, 4) 
    194         self.assertAlmostEquals(s , 941.7452, 3) 
     192        self.assertAlmostEqual(qstar, 7.49e-5, 1) 
     193        self.assertAlmostEqual(v, 0.005648401, 4) 
     194        self.assertAlmostEqual(s , 941.7452, 3) 
    195195 
    196196    def test_use_case_4(self): 
     
    218218 
    219219        # Test results 
    220         self.assertAlmostEquals(qstar, 7.49e-5,2) 
    221         self.assertAlmostEquals(v, 0.005952674, 3) 
    222         self.assertAlmostEquals(s , 941.7452, 3) 
     220        self.assertAlmostEqual(qstar, 7.49e-5,2) 
     221        self.assertAlmostEqual(v, 0.005952674, 3) 
     222        self.assertAlmostEqual(s , 941.7452, 3) 
    223223 
    224224    def test_use_case_5(self): 
     
    247247 
    248248        # Test results 
    249         self.assertAlmostEquals(qstar, 7.88981e-5,2) 
    250         self.assertAlmostEquals(v, 0.005952674, 3) 
    251         self.assertAlmostEquals(s , 941.7452, 3) 
     249        self.assertAlmostEqual(qstar, 7.88981e-5,2) 
     250        self.assertAlmostEqual(v, 0.005952674, 3) 
     251        self.assertAlmostEqual(s , 941.7452, 3) 
    252252 
    253253    def test_use_case_6(self): 
     
    273273 
    274274        # Test results 
    275         self.assertAlmostEquals(qstar, 7.49e-5,2) 
    276         self.assertAlmostEquals(v, 0.005952674, 3) 
    277         self.assertAlmostEquals(s , 941.7452, 3) 
     275        self.assertAlmostEqual(qstar, 7.49e-5,2) 
     276        self.assertAlmostEqual(v, 0.005952674, 3) 
     277        self.assertAlmostEqual(s , 941.7452, 3) 
    278278 
    279279 
     
    297297        s = inv.get_surface(contrast=2.6e-6, porod_const=2) 
    298298        # Test results 
    299         self.assertAlmostEquals(qstar, 1.361677e-3, 4) 
    300         self.assertAlmostEquals(v, 0.115352622, 2) 
    301         self.assertAlmostEquals(s , 941.7452, 3 ) 
     299        self.assertAlmostEqual(qstar, 1.361677e-3, 4) 
     300        self.assertAlmostEqual(v, 0.115352622, 2) 
     301        self.assertAlmostEqual(s , 941.7452, 3 ) 
    302302 
    303303    def test_use_case_2(self): 
     
    315315        s, ds = inv.get_surface_with_error(contrast=2.6e-6, porod_const=2) 
    316316        # Test results 
    317         self.assertAlmostEquals(qstar, 1.361677e-3, 4) 
    318         self.assertAlmostEquals(v, 0.115352622, 2) 
    319         self.assertAlmostEquals(s , 941.7452, 3 ) 
     317        self.assertAlmostEqual(qstar, 1.361677e-3, 4) 
     318        self.assertAlmostEqual(v, 0.115352622, 2) 
     319        self.assertAlmostEqual(s , 941.7452, 3 ) 
    320320 
    321321    def test_use_case_3(self): 
     
    336336 
    337337        # Test results 
    338         self.assertAlmostEquals(qstar, 0.00138756,2) 
    339         self.assertAlmostEquals(v, 0.117226896,2) 
    340         self.assertAlmostEquals(s ,941.7452, 3) 
     338        self.assertAlmostEqual(qstar, 0.00138756,2) 
     339        self.assertAlmostEqual(v, 0.117226896,2) 
     340        self.assertAlmostEqual(s ,941.7452, 3) 
    341341 
    342342    def test_use_case_4(self): 
     
    354354 
    355355        # Test results 
    356         self.assertAlmostEquals(qstar, 0.0045773,2) 
     356        self.assertAlmostEqual(qstar, 0.0045773,2) 
    357357 
    358358    def test_use_case_5(self): 
     
    374374 
    375375        # Test results 
    376         self.assertAlmostEquals(qstar, 0.00460319,3) 
     376        self.assertAlmostEqual(qstar, 0.00460319,3) 
    377377       
    378378   
  • test/sasrealspace/test/utest_oriented.py

    r1cdbcd8 r88d2e70  
    5959        ana_val = self.ana.runXY([0.1, 0.1]) 
    6060        sim_val = self.model.getIq2D(0.1, 0.1) 
    61         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.1 ) 
     61        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.1 ) 
    6262 
    6363class TestCylinderAddObject(unittest.TestCase): 
     
    101101        #print ana_val, sim_val, sim_val/ana_val 
    102102 
    103         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     103        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    104104 
    105105 
     
    143143        #print ana_val, sim_val, sim_val/ana_val 
    144144 
    145         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     145        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    146146 
    147147    def testalongZ(self): 
     
    156156        #print ana_val, sim_val, sim_val/ana_val 
    157157 
    158         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     158        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    159159 
    160160    def testalongX(self): 
     
    169169        #print ana_val, sim_val, sim_val/ana_val 
    170170 
    171         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     171        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    172172 
    173173class TestEllipsoid(unittest.TestCase): 
     
    213213        #print ana_val, sim_val, sim_val/ana_val 
    214214 
    215         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     215        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    216216 
    217217    def testalongZ(self): 
     
    226226        #print ana_val, sim_val, sim_val/ana_val 
    227227 
    228         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     228        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    229229 
    230230    def testalongY(self): 
     
    240240 
    241241        try: 
    242             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     242            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    243243        except Exception: 
    244244            print("Error", ana_val, sim_val, sim_val/ana_val) 
     
    295295        sim_val, err = self.canvas.getIq2DError(0.1, 0.2) 
    296296 
    297         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     297        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    298298 
    299299class TestCoreShellError(unittest.TestCase): 
     
    347347        sim_val, err = self.canvas.getIq2DError(0.1, 0.2) 
    348348 
    349         self.assert_( math.fabs(sim_val-ana_val) < 3.0 * err ) 
     349        self.assertTrue( math.fabs(sim_val-ana_val) < 3.0 * err ) 
    350350 
    351351class TestRunMethods(unittest.TestCase): 
     
    392392 
    393393        try: 
    394             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     394            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    395395        except Exception: 
    396396            print("Error", ana_val, sim_val, sim_val/ana_val) 
     
    404404 
    405405        try: 
    406             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     406            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    407407        except Exception: 
    408408            print("Error", ana_val, sim_val, sim_val/ana_val) 
     
    416416 
    417417        try: 
    418             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     418            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    419419        except Exception: 
    420420            print("Error", ana_val, sim_val, sim_val/ana_val) 
     
    428428 
    429429        try: 
    430             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     430            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    431431        except Exception: 
    432432            print("Error", ana_val, sim_val, sim_val/ana_val) 
     
    471471        sim_val = self.model.getIq2D(0.1, 0.2) 
    472472 
    473         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     473        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    474474 
    475475        # Change the radius a re-evaluate 
     
    479479        ana_val = self.ana.runXY([0.1, 0.2]) 
    480480        sim_val = self.model.getIq2D(0.1, 0.2) 
    481         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     481        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    482482 
    483483 
  • test/sasrealspace/test/utest_realspace.py

    r1cdbcd8 r88d2e70  
    3838        self.model.add('ellipsoid','elli2') 
    3939        self.model.delete('elli2') 
    40         self.assert_('elli2' not in self.model.getShapeList()) 
     40        self.assertTrue('elli2' not in self.model.getShapeList()) 
    4141 
    4242    def testsetParam(self): 
     
    8181        value_2 = self.canvas.getIq(0.001) 
    8282 
    83         self.assert_( (value_1-value_2)/value_1 < 0.1) 
     83        self.assertTrue( (value_1-value_2)/value_1 < 0.1) 
    8484 
    8585    def testSetDensityTiming(self): 
     
    9999        t_2 = time.time()-t_0 
    100100 
    101         self.assert_( t_2 < t_1 and (t_1-t_2)/t_2 > 2) 
     101        self.assertTrue( t_2 < t_1 and (t_1-t_2)/t_2 > 2) 
    102102 
    103103    def testGetParamList(self): 
    104104        """ Test GetParamList on empty canvas""" 
    105         self.assert_('lores_density' in self.canvas.getParamList()) 
     105        self.assertTrue('lores_density' in self.canvas.getParamList()) 
    106106        handle = self.canvas.add('sphere') 
    107107 
     
    109109        """ Test GetParamList on filled canvas""" 
    110110        self.canvas.add('sphere') 
    111         self.assert_('lores_density' in self.canvas.getParamList()) 
     111        self.assertTrue('lores_density' in self.canvas.getParamList()) 
    112112 
    113113    def testAdd(self): 
     
    151151        # THIS WILL DEPEND ON THE NUMBER OF SPACE POINTS: 
    152152        # that why we need some error analysis. 
    153         self.assert_( (sim_2*ana_1/sim_1 - ana_2)/ana_2 < 0.1) 
     153        self.assertTrue( (sim_2*ana_1/sim_1 - ana_2)/ana_2 < 0.1) 
    154154 
    155155        # test the absolute amplitude 
    156         self.assert_( math.fabs(sim_2-ana_2)/ana_2 < 0.1) 
     156        self.assertTrue( math.fabs(sim_2-ana_2)/ana_2 < 0.1) 
    157157 
    158158    def testGetIq2(self): 
     
    196196        sim_2 = self.canvas.getIq(0.01) 
    197197 
    198         self.assert_((sim_2-sim_1)/sim_1<0.05) 
     198        self.assertTrue((sim_2-sim_1)/sim_1<0.05) 
    199199 
    200200    def testGetIq_time(self): 
     
    216216        delta_2 = time.time()-t_0 
    217217 
    218         self.assert_((delta_2-delta_1)/delta_1<0.05) 
     218        self.assertTrue((delta_2-delta_1)/delta_1<0.05) 
    219219 
    220220 
     
    342342        ana = self.sphere.run(0.05) 
    343343        val, err = self.canvas.getIqError(0.05) 
    344         self.assert_(math.fabs(ana-val)<2.0*err) 
     344        self.assertTrue(math.fabs(ana-val)<2.0*err) 
    345345 
    346346    def testRightOrder(self): 
     
    350350        val, err = self.canvas.getIqError(0.05) 
    351351        #print 'right', ana, val, err 
    352         self.assert_(math.fabs(ana-val)/ana < 1.1) 
     352        self.assertTrue(math.fabs(ana-val)/ana < 1.1) 
    353353 
    354354    def testWrongOrder(self): 
     
    365365        val, err = self.canvas.getIqError(0.05) 
    366366        #print 'wrong', ana, val, err 
    367         self.assert_(math.fabs(ana-val)/ana < 1.1) 
     367        self.assertTrue(math.fabs(ana-val)/ana < 1.1) 
    368368 
    369369 
  • run.py

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

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

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

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

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

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

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

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

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

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

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