Changeset 13bd583 in sasmodels for sasmodels

Timestamp:

Feb 12, 2018 8:24:15 PM (6 years ago)

Author:

GitHub <noreply@…>

Branches:

master, core_shell_microgels, magnetic_model, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests

Children:

a2ca6e5

Parents:

e309e23 (diff), f6fd413 (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 Butler <butlerpd@…> (02/12/18 20:24:15)

git-committer:

GitHub <noreply@…> (02/12/18 20:24:15)

Message:

Merge pull request #62 from SasView?/pytest

add support for pytest and use it on travis/appveyor

Location:

sasmodels

Files:

• compare.py (modified) (5 diffs)
• convert.py (modified) (1 diff)
• core.py (modified) (4 diffs)
• jitter.py (modified) (1 diff)
• kernelcl.py (modified) (4 diffs)
• model_test.py (modified) (9 diffs)
• sasview_model.py (modified) (2 diffs)
• kernel_iq.c (modified) (3 diffs)
• weights.py (modified) (4 diffs)

sasmodels/compare.py

@@ -40 +40 @@
 from . import core
 from . import kerneldll
+from . import kernelcl
 from .data import plot_theory, empty_data1D, empty_data2D, load_data
 from .direct_model import DirectModel, get_mesh
@@ -623 +624 @@
 
 
+def time_calculation(calculator, pars, evals=1):
+    # type: (Calculator, ParameterSet, int) -> Tuple[np.ndarray, float]
+    """
+    Compute the average calculation time over N evaluations.
+
+    An additional call is generated without polydispersity in order to
+    initialize the calculation engine, and make the average more stable.
+    """
+    # initialize the code so time is more accurate
+    if evals > 1:
+        calculator(**suppress_pd(pars))
+    toc = tic()
+    # make sure there is at least one eval
+    value = calculator(**pars)
+    for _ in range(evals-1):
+        value = calculator(**pars)
+    average_time = toc()*1000. / evals
+    #print("I(q)",value)
+    return value, average_time
+
+def make_data(opts):
+    # type: (Dict[str, Any]) -> Tuple[Data, np.ndarray]
+    """
+    Generate an empty dataset, used with the model to set Q points
+    and resolution.
+
+    *opts* contains the options, with 'qmax', 'nq', 'res',
+    'accuracy', 'is2d' and 'view' parsed from the command line.
+    """
+    qmin, qmax, nq, res = opts['qmin'], opts['qmax'], opts['nq'], opts['res']
+    if opts['is2d']:
+        q = np.linspace(-qmax, qmax, nq)  # type: np.ndarray
+        data = empty_data2D(q, resolution=res)
+        data.accuracy = opts['accuracy']
+        set_beam_stop(data, qmin)
+        index = ~data.mask
+    else:
+        if opts['view'] == 'log' and not opts['zero']:
+            q = np.logspace(math.log10(qmin), math.log10(qmax), nq)
+        else:
+            q = np.linspace(qmin, qmax, nq)
+        if opts['zero']:
+            q = np.hstack((0, q))
+        data = empty_data1D(q, resolution=res)
+        index = slice(None, None)
+    return data, index
+
 DTYPE_MAP = {
     'half': '16',
@@ -643 +691 @@
     Return a model calculator using the OpenCL calculation engine.
     """
-    if not core.HAVE_OPENCL:
-        raise RuntimeError("OpenCL not available")
-    model = core.build_model(model_info, dtype=dtype, platform="ocl")
-    calculator = DirectModel(data, model, cutoff=cutoff)
-    calculator.engine = "OCL%s"%DTYPE_MAP[str(model.dtype)]
-    return calculator
 
 def eval_ctypes(model_info, data, dtype='double', cutoff=0.):
@@ -660 +702 @@
     return calculator
 
-def time_calculation(calculator, pars, evals=1):
-    # type: (Calculator, ParameterSet, int) -> Tuple[np.ndarray, float]
-    """
-    Compute the average calculation time over N evaluations.
-
-    An additional call is generated without polydispersity in order to
-    initialize the calculation engine, and make the average more stable.
-    """
-    # initialize the code so time is more accurate
-    if evals > 1:
-        calculator(**suppress_pd(pars))
-    toc = tic()
-    # make sure there is at least one eval
-    value = calculator(**pars)
-    for _ in range(evals-1):
-        value = calculator(**pars)
-    average_time = toc()*1000. / evals
-    #print("I(q)",value)
-    return value, average_time
-
-def make_data(opts):
-    # type: (Dict[str, Any]) -> Tuple[Data, np.ndarray]
-    """
-    Generate an empty dataset, used with the model to set Q points
-    and resolution.
-
-    *opts* contains the options, with 'qmax', 'nq', 'res',
-    'accuracy', 'is2d' and 'view' parsed from the command line.
-    """
-    qmin, qmax, nq, res = opts['qmin'], opts['qmax'], opts['nq'], opts['res']
-    if opts['is2d']:
-        q = np.linspace(-qmax, qmax, nq)  # type: np.ndarray
-        data = empty_data2D(q, resolution=res)
-        data.accuracy = opts['accuracy']
-        set_beam_stop(data, qmin)
-        index = ~data.mask
-    else:
-        if opts['view'] == 'log' and not opts['zero']:
-            q = np.logspace(math.log10(qmin), math.log10(qmax), nq)
-        else:
-            q = np.linspace(qmin, qmax, nq)
-        if opts['zero']:
-            q = np.hstack((0, q))
-        data = empty_data1D(q, resolution=res)
-        index = slice(None, None)
-    return data, index
-
 def make_engine(model_info, data, dtype, cutoff, ngauss=0):
     # type: (ModelInfo, Data, str, float) -> Calculator
@@ -718 +713 @@
         set_integration_size(model_info, ngauss)
 
-    if dtype is None or not dtype.endswith('!'):
-        return eval_opencl(model_info, data, dtype=dtype, cutoff=cutoff)
-    else:
-        return eval_ctypes(model_info, data, dtype=dtype[:-1], cutoff=cutoff)
+    if dtype != "default" and not dtype.endswith('!') and not kernelcl.use_opencl():
+        raise RuntimeError("OpenCL not available " + kernelcl.OPENCL_ERROR)
+
+    model = core.build_model(model_info, dtype=dtype, platform="ocl")
+    calculator = DirectModel(data, model, cutoff=cutoff)
+    engine_type = calculator._model.__class__.__name__.replace('Model','').upper()
+    bits = calculator._model.dtype.itemsize*8
+    precision = "fast" if getattr(calculator._model, 'fast', False) else str(bits)
+    calculator.engine = "%s[%s]" % (engine_type, precision)
+    return calculator
 
 def _show_invalid(data, theory):

sasmodels/convert.py

@@ -633 +633 @@
 def test_backward_forward():
     from .core import list_models
+    L = lambda name: _check_one(name, seed=1)
     for name in list_models('all'):
-        L = lambda: _check_one(name, seed=1)
-        L.description = name
-        yield L
+        yield L, name

sasmodels/core.py

@@ -21 +21 @@
 from . import mixture
 from . import kernelpy
+from . import kernelcl
 from . import kerneldll
 from . import custom
-
-if os.environ.get("SAS_OPENCL", "").lower() == "none":
-    HAVE_OPENCL = False
-else:
-    try:
-        from . import kernelcl
-        HAVE_OPENCL = True
-    except Exception:
-        HAVE_OPENCL = False
-
-CUSTOM_MODEL_PATH = os.environ.get('SAS_MODELPATH', "")
-if CUSTOM_MODEL_PATH == "":
-    CUSTOM_MODEL_PATH = joinpath(os.path.expanduser("~"), ".sasmodels", "custom_models")
-    if not os.path.isdir(CUSTOM_MODEL_PATH):
-        os.makedirs(CUSTOM_MODEL_PATH)
 
 # pylint: disable=unused-import
@@ -47 +33 @@
     pass
 # pylint: enable=unused-import
+
+CUSTOM_MODEL_PATH = os.environ.get('SAS_MODELPATH', "")
+if CUSTOM_MODEL_PATH == "":
+    CUSTOM_MODEL_PATH = joinpath(os.path.expanduser("~"), ".sasmodels", "custom_models")
+    if not os.path.isdir(CUSTOM_MODEL_PATH):
+        os.makedirs(CUSTOM_MODEL_PATH)
 
 # TODO: refactor composite model support
@@ -276 +268 @@
     if platform is None:
         platform = "ocl"
-    if platform == "ocl" and not HAVE_OPENCL or not model_info.opencl:
+    if not kernelcl.use_opencl() or not model_info.opencl:
         platform = "dll"
 
@@ -320 +312 @@
     print("\n".join(list_models(kind)))
 
-def test_load():
-    # type: () -> None
-    """Check that model load works"""
+def test_composite_order():
     def test_models(fst, snd):
         """Confirm that two models produce the same parameters"""
         fst = load_model(fst)
         snd = load_model(snd)
-        # Remove the upper case characters frin the parameters, since
-        # they lasndel the order of events and we specfically are
-        # changin that aspect
+        # Un-disambiguate parameter names so that we can check if the same
+        # parameters are in a pair of composite models. Since each parameter in
+        # the mixture model is tagged as e.g., A_sld, we ought to use a
+        # regex subsitution s/^[A-Z]+_/_/, but removing all uppercase letters
+        # is good enough.
         fst = [[x for x in p.name if x == x.lower()] for p in fst.info.parameters.kernel_parameters]
         snd = [[x for x in p.name if x == x.lower()] for p in snd.info.parameters.kernel_parameters]
         assert sorted(fst) == sorted(snd), "{} != {}".format(fst, snd)
 
-
-    test_models(
+    def build_test(first, second):
+        test = lambda description: test_models(first, second)
+        description = first + " vs. " + second
+        return test, description
+
+    yield build_test(
         "cylinder+sphere",
         "sphere+cylinder")
-    test_models(
+    yield build_test(
         "cylinder*sphere",
         "sphere*cylinder")
-    test_models(
+    yield build_test(
         "cylinder@hardsphere*sphere",
         "sphere*cylinder@hardsphere")
-    test_models(
+    yield build_test(
         "barbell+sphere*cylinder@hardsphere",
         "sphere*cylinder@hardsphere+barbell")
-    test_models(
+    yield build_test(
         "barbell+cylinder@hardsphere*sphere",
         "cylinder@hardsphere*sphere+barbell")
-    test_models(
+    yield build_test(
         "barbell+sphere*cylinder@hardsphere",
         "barbell+cylinder@hardsphere*sphere")
-    test_models(
+    yield build_test(
         "sphere*cylinder@hardsphere+barbell",
         "cylinder@hardsphere*sphere+barbell")
-    test_models(
+    yield build_test(
         "barbell+sphere*cylinder@hardsphere",
         "cylinder@hardsphere*sphere+barbell")
-    test_models(
+    yield build_test(
         "barbell+cylinder@hardsphere*sphere",
         "sphere*cylinder@hardsphere+barbell")
 
+def test_composite():
+    # type: () -> None
+    """Check that model load works"""
     #Test the the model produces the parameters that we would expect
     model = load_model("cylinder@hardsphere*sphere")

sasmodels/jitter.py

@@ -13 +13 @@
 import argparse
 
-import mpl_toolkits.mplot3d   # Adds projection='3d' option to subplot
+try: # CRUFT: travis-ci does not support mpl_toolkits.mplot3d
+    import mpl_toolkits.mplot3d  # Adds projection='3d' option to subplot
+except ImportError:
+    pass
+
 import matplotlib.pyplot as plt
 from matplotlib.widgets import Slider, CheckButtons

sasmodels/kernelcl.py

@@ -58 +58 @@
 import numpy as np  # type: ignore
 
+
+# Attempt to setup opencl. This may fail if the opencl package is not
+# installed or if it is installed but there are no devices available.
 try:
-    #raise NotImplementedError("OpenCL not yet implemented for new kernel template")
     import pyopencl as cl  # type: ignore
+    from pyopencl import mem_flags as mf
+    from pyopencl.characterize import get_fast_inaccurate_build_options
     # Ask OpenCL for the default context so that we know that one exists
     cl.create_some_context(interactive=False)
+    HAVE_OPENCL = True
+    OPENCL_ERROR = ""
 except Exception as exc:
-    warnings.warn("OpenCL startup failed with ***"
-                  + str(exc) + "***; using C compiler instead")
-    raise RuntimeError("OpenCL not available")
-
-from pyopencl import mem_flags as mf
-from pyopencl.characterize import get_fast_inaccurate_build_options
+    HAVE_OPENCL = False
+    OPENCL_ERROR = str(exc)
 
 from . import generate
@@ -102 +104 @@
         cl._DEFAULT_INCLUDE_OPTIONS = [quote_path(v) for v in cl._DEFAULT_INCLUDE_OPTIONS]
 
-fix_pyopencl_include()
-
+if HAVE_OPENCL:
+    fix_pyopencl_include()
 
 # The max loops number is limited by the amount of local memory available
@@ -128 +130 @@
 """
 
+def use_opencl():
+    return HAVE_OPENCL and os.environ.get("SAS_OPENCL", "").lower() != "none"
 
 ENV = None
+def reset_environment():
+    """
+    Call to create a new OpenCL context, such as after a change to SAS_OPENCL.
+    """
+    global ENV
+    ENV = GpuEnvironment() if use_opencl() else None
+
 def environment():
     # type: () -> "GpuEnvironment"
@@ -137 +148 @@
     This provides an OpenCL context and one queue per device.
     """
-    global ENV
     if ENV is None:
-        ENV = GpuEnvironment()
+        if not HAVE_OPENCL:
+            raise RuntimeError("OpenCL startup failed with ***"
+                            + OPENCL_ERROR + "***; using C compiler instead")
+        reset_environment()
+        if ENV is None:
+            raise RuntimeError("SAS_OPENCL=None in environment")
     return ENV
 

sasmodels/model_test.py

@@ -62 +62 @@
 from .exception import annotate_exception
 from .modelinfo import expand_pars
+from .kernelcl import use_opencl
 
 # pylint: disable=unused-import
@@ -123 +124 @@
 
         if is_py:  # kernel implemented in python
-            test_name = "Model: %s, Kernel: python"%model_name
+            test_name = "%s-python"%model_name
             test_method_name = "test_%s_python" % model_info.id
             test = ModelTestCase(test_name, model_info,
@@ -134 +135 @@
 
             # test using dll if desired
-            if 'dll' in loaders or not core.HAVE_OPENCL:
-                test_name = "Model: %s, Kernel: dll"%model_name
+            if 'dll' in loaders or not use_opencl():
+                test_name = "%s-dll"%model_name
                 test_method_name = "test_%s_dll" % model_info.id
                 test = ModelTestCase(test_name, model_info,
@@ -145 +146 @@
 
             # test using opencl if desired and available
-            if 'opencl' in loaders and core.HAVE_OPENCL:
-                test_name = "Model: %s, Kernel: OpenCL"%model_name
+            if 'opencl' in loaders and use_opencl():
+                test_name = "%s-opencl"%model_name
                 test_method_name = "test_%s_opencl" % model_info.id
                 # Using dtype=None so that the models that are only
@@ -160 +161 @@
 
     return suite
-
 
 def _hide_model_case_from_nose():
@@ -368 +368 @@
 
     # Build a test suite containing just the model
-    loaders = ['opencl'] if core.HAVE_OPENCL else ['dll']
+    loaders = ['opencl'] if use_opencl() else ['dll']
     models = [model]
     try:
@@ -425 +425 @@
         verbosity = 1
     if models and models[0] == 'opencl':
-        if not core.HAVE_OPENCL:
+        if not use_opencl():
             print("opencl is not available")
             return 1
@@ -435 +435 @@
         models = models[1:]
     elif models and models[0] == 'opencl_and_dll':
-        loaders = ['opencl', 'dll'] if core.HAVE_OPENCL else ['dll']
+        loaders = ['opencl', 'dll'] if use_opencl() else ['dll']
         models = models[1:]
     else:
-        loaders = ['opencl', 'dll'] if core.HAVE_OPENCL else ['dll']
+        loaders = ['opencl', 'dll'] if use_opencl() else ['dll']
     if not models:
         print("""\
@@ -467 +467 @@
     Run "nosetests sasmodels" on the command line to invoke it.
     """
-    loaders = ['opencl', 'dll'] if core.HAVE_OPENCL else ['dll']
+    loaders = ['opencl', 'dll'] if use_opencl() else ['dll']
     tests = make_suite(loaders, ['all'])
-    for test_i in tests:
-        # In order for nosetest to see the correct test name, need to set
-        # the description attribute of the returned function.  Since we
-        # can't do this for the returned instance, wrap it in a lambda and
-        # set the description on the lambda.  Otherwise we could just do:
-        #    yield test_i.run_all
-        L = lambda: test_i.run_all()
-        L.description = test_i.test_name
-        yield L
+    def build_test(test):
+        # In order for nosetest to show the test name, wrap the test.run_all
+        # instance in function that takes the test name as a parameter which
+        # will be displayed when the test is run.  Do this as a function so
+        # that it properly captures the context for tests that captured and
+        # run later.  If done directly in the for loop, then the looping
+        # variable test will be shared amongst all the tests, and we will be
+        # repeatedly testing vesicle.
+
+        # Note: in sasview sas.sasgui.perspectives.fitting.gpu_options
+        # requires that the test.description field be set.
+        wrap = lambda: test.run_all()
+        wrap.description = test.test_name
+        return wrap
+        # The following would work with nosetests and pytest:
+        #     return lambda name: test.run_all(), test.test_name
+
+    for test in tests:
+        yield build_test(test)
 
 

sasmodels/sasview_model.py

@@ -665 +665 @@
 
     def _calculate_Iq(self, qx, qy=None):
-        #core.HAVE_OPENCL = False
         if self._model is None:
             self._model = core.build_model(self._model_info)
@@ -859 +858 @@
     # type: () -> None
     """
-    Load and run cylinder model from sas.models.CylinderModel
+    Load and run cylinder model as sas-models-CylinderModel
     """
     if not SUPPORT_OLD_STYLE_PLUGINS:

sasmodels/kernel_iq.c

@@ -93 +93 @@
 // Compute the magnetic sld
 static double mag_sld(
-  const int xs, // 0=dd, 1=du real, 2=ud real, 3=uu, 4=du imag, 5=up imag
+  const unsigned int xs, // 0=dd, 1=du real, 2=ud real, 3=uu, 4=du imag, 5=up imag
   const double qx, const double qy,
   const double px, const double py,
@@ -103 +103 @@
     const double perp = qy*mx - qx*my;
     switch (xs) {
+      default: // keep compiler happy; condition ensures xs in [0,1,2,3]
       case 0: // uu => sld - D M_perpx
           return sld - px*perp;
@@ -659 +660 @@
 
             // loop over uu, ud real, du real, dd, ud imag, du imag
-            for (int xs=0; xs<6; xs++) {
+            for (unsigned int xs=0; xs<6; xs++) {
               const double xs_weight = spins[xs];
               if (xs_weight > 1.e-8) {

sasmodels/weights.py

@@ -97 +97 @@
         return x, px
 
+class UniformDispersion(Dispersion):
+    r"""
+    Uniform dispersion, with width $\sigma$.
+
+    .. math::
+
+        w = 1
+    """
+    type = "uniform"
+    default = dict(npts=35, width=0, nsigmas=None)
+    def _weights(self, center, sigma, lb, ub):
+        x = np.linspace(center-sigma, center+sigma, self.npts)
+        x = x[(x >= lb) & (x <= ub)]
+        return x, np.ones_like(x)
 
 class RectangleDispersion(Dispersion):
@@ -107 +121 @@
     """
     type = "rectangle"
-    default = dict(npts=35, width=0, nsigmas=1.70325)
-    def _weights(self, center, sigma, lb, ub):
-        x = self._linspace(center, sigma, lb, ub)
-        x = x[np.fabs(x-center) <= np.fabs(sigma)*sqrt(3.0)]
-        return x, np.ones_like(x)
-
+    default = dict(npts=35, width=0, nsigmas=1.73205)
+    def _weights(self, center, sigma, lb, ub):
+         x = self._linspace(center, sigma, lb, ub)
+         x = x[np.fabs(x-center) <= np.fabs(sigma)*sqrt(3.0)]
+         return x, np.ones_like(x)
 
 class LogNormalDispersion(Dispersion):
@@ -190 +203 @@
         return x, px
 
+class BoltzmannDispersion(Dispersion):
+    r"""
+    Boltzmann dispersion, with $\sigma=k T/E$.
+
+    .. math::
+
+        w = \exp\left( -|x - c|/\sigma\right)
+    """
+    type = "boltzmann"
+    default = dict(npts=35, width=0, nsigmas=3)
+    def _weights(self, center, sigma, lb, ub):
+        x = self._linspace(center, sigma, lb, ub)
+        px = np.exp(-np.abs(x-center) / np.abs(sigma))
+        return x, px
 
 # dispersion name -> disperser lookup table.
@@ -196 +223 @@
 MODELS = OrderedDict((d.type, d) for d in (
     RectangleDispersion,
+    UniformDispersion,
     ArrayDispersion,
     LogNormalDispersion,
     GaussianDispersion,
     SchulzDispersion,
+    BoltzmannDispersion
 ))