Changeset faf83f2 in sasmodels

Timestamp:

Feb 9, 2017 4:39:36 AM (8 years ago)

Author:

wojciech

Branches:

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

Children:

1896dff

Parents:

4c8a5b4 (diff), 1105286 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of ​https://github.com/SasView/sasmodels

Files:

• sasmodels/conversion_table.py (modified) (17 diffs)
• sasmodels/convert.py (modified) (10 diffs)
• sasmodels/kernelcl.py (modified) (2 diffs)
• sasmodels/sasview_model.py (modified) (1 diff)
• doc/ref/gpu/gpu_computations.rst (modified) (2 diffs)

sasmodels/conversion_table.py

@@ -5 +5 @@
 names for each parameter in sasmodels.  This is used by :mod:`convert` to
 determine the equivalent parameter set when comparing a sasmodels model to
-the models defined in SasView 3.1.
+the models defined in previous versions of SasView and sasmodels. This is now
+versioned based on the version number of SasView.
+
+When any sasmodels parameter or model name is changed, this must be modified to
+account for that.
+
+Usage:
+<old_Sasview_version> : {
+    <new_model_name> : [
+        <old_model_name> ,
+        {
+            <new_param_name_1> : <old_param_name_1>,
+            ...
+            <new_param_name_n> : <old_param_name_n>
+        }
+    ]
+}
+
+Any future parameter and model name changes can and should be given in this
+table for future compatibility.
 """
 
-
 CONVERSION_TABLE = {
+    (3,1,2) : {
     "adsorbed_layer": [
         "Core2ndMomentModel",
@@ -211 +230 @@
     ],
     "correlation_length": [
-        "CorrLengthModel",
+        "CorrLength",
         {
             "porod_scale": "scale_p",
@@ -218 +237 @@
             "lorentz_exp": "exponent_l",
             "cor_length": "length_l"
-        }
+        },
+        "CorrLengthModel"
     ],
     "cylinder": [
@@ -299 +319 @@
     ],
     "fractal_core_shell": [
-        "FractalCoreShellModel",
+        "FractalCoreShell",
         {
             "sld_core": "core_sld",
@@ -309 +329 @@
             "cor_length": "cor_length",
             "volfraction": "volfraction",
-        }
+        },
+        "FractalCoreShellModel"
     ],
     "fuzzy_sphere": [
@@ -321 +342 @@
     ],
     "gauss_lorentz_gel": [
-        "GaussLorentzGelModel",
+        "GaussLorentzGel",
         {
             "gauss_scale": "scale_g",
@@ -328 +349 @@
             "background": "background",
             "lorentz_scale": "scale_l"
-        }
+        },
+        "GaussLorentzGelModel"
     ],
     "gaussian_peak": [
-        "PeakGaussModel",
+        "Peak Gauss Model",
         {
             "peak_pos": "q0",
             "sigma": "B",
-        }
+        },
+        "PeakGaussModel",
     ],
     "gel_fit": [
@@ -343 +366 @@
             "lorentz_scale": "lScale",
             "guinier_scale": "gScale",
-            "fractal_dim": "scale",
+            "fractal_dim": "FractalExp",
             "cor_length": "zeta",
         }
     ],
     "guinier": [
+        "Guinier",
+        {
+            "rg": "rg"
+        },
         "GuinierModel",
-        {
-            "rg": "rg"
-        }
     ],
     "guinier_porod": [
-        "GuinierPorodModel",
+        "GuinierPorod",
         {
             "s": "dim",
@@ -361 +385 @@
             "scale": "scale",
             "background": "background"
-        }
+        },
+        "GuinierPorodModel",
     ],
     "hardsphere": [
@@ -454 +479 @@
             "d_spacing": "spacing",
             "Caille_parameter": "caille",
-            "Nlayers": "N_plates",
+            "Nlayers": "n_plates",
         }
     ],
@@ -486 +511 @@
     ],
     "lorentz": [
+        "Lorentz",
+        {
+            "cor_length": "length"
+        },
         "LorentzModel",
-        {
-            "cor_length": "length"
-        }
     ],
     "mass_fractal": [
@@ -510 +536 @@
     ],
     "mono_gauss_coil": [
-        "DebyeModel",
+        "Debye",
         {
             "rg": "rg",
             "i_zero": "scale",
             "background": "background",
-        }
+        },
+        "DebyeModel",
     ],
     "multilayer_vesicle": [
@@ -564 +591 @@
     ],
     "peak_lorentz": [
-        "PeakLorentzModel",
+        "Peak Lorentz Model",
         {
             "peak_pos": "q0",
             "peak_hwhm": "B"
-        }
+        },
+        "PeakLorentzModel",
     ],
     "pearl_necklace": [
@@ -802 +830 @@
     ],
     "two_lorentzian": [
-        "TwoLorentzianModel",
+        "TwoLorentzian",
         {
             "lorentz_scale_1": "scale_1",
@@ -811 +839 @@
             "lorentz_length_1": "length_1",
             "background": "background"
-        }
+        },
+        "TwoLorentzianModel",
     ],
     "two_power_law": [
-        "TwoPowerLawModel",
+        "TwoPowerLaw",
         {
             "coefficent_1": "coef_A",
@@ -821 +850 @@
             "background": "background",
             "crossover": "qc"
-        }
+        },
+        "TwoPowerLawModel",
     ],
     "unified_power_Rg": [
+        "UnifiedPowerRg",
+        dict(((field_new+str(index), field_old+str(index))
+              for field_new, field_old in [("rg", "Rg"),
+                                           ("power", "power"),
+                                           ("G", "G"),
+                                           ("B", "B"),]
+              for index in range(11)),
+             **{
+                   "background": "background",
+                   "scale": "scale",
+               }),
         "UnifiedPowerRgModel",
-        {
-        }
     ],
     "vesicle": [
@@ -835 +874 @@
         }
     ]
+    }
 }

sasmodels/convert.py

@@ -53 +53 @@
     ("_pd_nsigma", ".nsigmas"),
     ("_pd_type", ".type"),
+    (".lower", ".lower"),
+    (".upper", ".upper"),
+    (".fittable", ".fittable"),
+    (".std", ".std"),
+    (".units", ".units"),
+    ("", "")
     ]
 
@@ -64 +70 @@
     if id.startswith('M0:'):
         return True
-    if id.startswith('volfraction') or id.startswith('radius_effective'):
-        return False
     if '_pd' in id or '.' in id:
         return False
@@ -75 +79 @@
         if p.id == id:
             return p.type == 'sld'
-    raise ValueError("unknown parameter %r in conversion"%id)
+    return False
 
 def _rescale_sld(model_info, pars, scale):
@@ -88 +92 @@
 
 
-def _get_translation_table(model_info):
-    _, translation = CONVERSION_TABLE.get(model_info.id, [None, {}])
-    translation = translation.copy()
+def _get_translation_table(model_info, version=(3,1,2)):
+    conv_param = CONVERSION_TABLE.get(version, {}).get(model_info.id, [None, {}])
+    translation = conv_param[1].copy()
     for p in model_info.parameters.kernel_parameters:
         if p.length > 1:
@@ -119 +123 @@
 def _pd_to_underscores(pars):
     return dict((_dot_pd_to_underscore_pd(k), v) for k, v in pars.items())
-
-def _convert_name(conv_dict, pars):
-    """
-    Renames parameter values (upper, lower, etc) to v4.0 names
-    :param conv_dict: conversion dictionary mapping new name : old name
-    :param pars: parameters to convert
-    :return:
-    """
-    new_pars = {}
-    i = 0
-    j = 0
-    for key_par, value_par in pars.iteritems():
-        j += 1
-        for key_conv, value_conv in conv_dict.iteritems():
-            if re.search(value_conv, key_par):
-                new_pars[key_par.replace(value_conv, key_conv)] = value_par
-                i += 1
-                break
-            elif re.search("background", key_par) or re.search("scale", key_par):
-                new_pars[key_par] = value_par
-                i += 1
-                break
-        if i != j:
-            new_pars[key_par] = value_par
-            i += 1
-    return new_pars
 
 def _convert_pars(pars, mapping):
@@ -167 +145 @@
     return newpars
 
-
-def _conversion_target(model_name):
+def _conversion_target(model_name, version=(3,1,2)):
     """
     Find the sasmodel name which translates into the sasview name.
@@ -176 +153 @@
     two variants in sasview.
     """
-    for sasmodels_name, [sasview_name, _] in CONVERSION_TABLE.items():
-        if sasview_name == model_name:
+    for sasmodels_name, sasview_dict in \
+            CONVERSION_TABLE.get(version, {}).items():
+        if sasview_dict[0] == model_name:
             return sasmodels_name
     return None
 
-
-def _hand_convert(name, oldpars):
+def _hand_convert(name, oldpars, version=(3,1,2)):
+    if version == (3,1,2):
+        oldpars = _hand_convert_3_1_2_to_4_1(name, oldpars)
+    return oldpars
+
+def _hand_convert_3_1_2_to_4_1(name, oldpars):
     if name == 'core_shell_parallelepiped':
         # Make sure pd on rim parameters defaults to zero
@@ -215 +197 @@
             pd = oldpars['radius.width']*oldpars['radius']/thickness
             oldpars['radius.width'] = pd
+    elif name == 'multilayer_vesicle':
+        if 'scale' in oldpars:
+            oldpars['volfraction'] = oldpars['scale']
+            oldpars['scale'] = 1.0
+        if 'scale.lower' in oldpars:
+            oldpars['volfraction.lower'] = oldpars['scale.lower']
+        if 'scale.upper' in oldpars:
+            oldpars['volfraction.upper'] = oldpars['scale.upper']
+        if 'scale.fittable' in oldpars:
+            oldpars['volfraction.fittable'] = oldpars['scale.fittable']
+        if 'scale.std' in oldpars:
+            oldpars['volfraction.std'] = oldpars['scale.std']
+        if 'scale.units' in oldpars:
+            oldpars['volfraction.units'] = oldpars['scale.units']
     elif name == 'pearl_necklace':
         pass
@@ -236 +232 @@
                 oldpars[p + ".upper"] /= 1e-13
     elif name == 'spherical_sld':
-        oldpars["CONTROL"] += 1
+        j = 0
+        while "func_inter" + str(j) in oldpars:
+            name = "func_inter" + str(j)
+            new_name = "shape" + str(j + 1)
+            if oldpars[name] == 'Erf(|nu|*z)':
+                oldpars[new_name] = int(0)
+            elif oldpars[name] == 'RPower(z^|nu|)':
+                oldpars[new_name] = int(1)
+            elif oldpars[name] == 'LPower(z^|nu|)':
+                oldpars[new_name] = int(2)
+            elif oldpars[name] == 'RExp(-|nu|*z)':
+                oldpars[new_name] = int(3)
+            elif oldpars[name] == 'LExp(-|nu|*z)':
+                oldpars[new_name] = int(4)
+            else:
+                oldpars[new_name] = int(0)
+            oldpars.pop(name)
+            oldpars['n_shells'] = str(j + 1)
+            j += 1
     elif name == 'teubner_strey':
         # basically undoing the entire Teubner-Strey calculations here.
@@ -281 +295 @@
     return oldpars
 
-def convert_model(name, pars, use_underscore=False):
+def convert_model(name, pars, use_underscore=False, model_version=(3,1,2)):
     """
     Convert model from old style parameter names to new style.
     """
-    newname = _conversion_target(name)
-    if newname is None:
-        return name, pars
-    if ':' in newname:   # core_shell_ellipsoid:1
-        model_info = load_model_info(newname[:-2])
-        # Know that the table exists and isn't multiplicity so grab it directly
-        # Can't use _get_translation_table since that will return the 'bare'
-        # version.
-        translation = CONVERSION_TABLE[newname][1]
-    else:
-        model_info = load_model_info(newname)
-        translation = _get_translation_table(model_info)
-    newpars = _hand_convert(newname, pars.copy())
-    newpars = _convert_name(translation, newpars)
-    newpars = _convert_pars(newpars, translation)
-    if not model_info.structure_factor:
-        newpars = _rescale_sld(model_info, newpars, 1e6)
-    newpars.setdefault('scale', 1.0)
-    newpars.setdefault('background', 0.0)
-    if use_underscore:
-        newpars = _pd_to_underscores(newpars)
+    newpars = pars
+    keys = sorted(CONVERSION_TABLE.keys())
+    for i, version in enumerate(keys):
+        # Don't allow indices outside list
+        next_i = i + 1
+        if next_i == len(keys):
+            next_i = i
+        # If the save state is from a later version, skip the check
+        if model_version <= keys[next_i]:
+            newname = _conversion_target(name, version)
+        else:
+            newname = None
+        # If no conversion is found, move on
+        if newname is None:
+            newname = name
+            continue
+        if ':' in newname:   # core_shell_ellipsoid:1
+            model_info = load_model_info(newname[:-2])
+            # Know the table exists and isn't multiplicity so grab it directly
+            # Can't use _get_translation_table since that will return the 'bare'
+            # version.
+            translation = CONVERSION_TABLE.get(version, {})[newname][1]
+        else:
+            model_info = load_model_info(newname)
+            translation = _get_translation_table(model_info, version)
+        newpars = _hand_convert(newname, newpars, version)
+        newpars = _convert_pars(newpars, translation)
+        # TODO: Still not convinced this is the best check
+        if not model_info.structure_factor and version == (3,1,2):
+            newpars = _rescale_sld(model_info, newpars, 1e6)
+        newpars.setdefault('scale', 1.0)
+        newpars.setdefault('background', 0.0)
+        if use_underscore:
+            newpars = _pd_to_underscores(newpars)
+        name = newname
     return newname, newpars
-
 
 # ========= BACKWARD CONVERSION sasmodels => sasview 3.x ===========

sasmodels/kernelcl.py

@@ -465 +465 @@
         # architectures tested so far.
         if self.is_2d:
-            # Note: 17 rather than 15 because results is 2 elements
-            # longer than input.
-            width = ((self.nq+17)//16)*16
+            # Note: 16 rather than 15 because result is 1 longer than input.
+            width = ((self.nq+16)//16)*16
             self.q = np.empty((width, 2), dtype=dtype)
             self.q[:self.nq, 0] = q_vectors[0]
             self.q[:self.nq, 1] = q_vectors[1]
         else:
-            # Note: 33 rather than 31 because results is 2 elements
-            # longer than input.
-            width = ((self.nq+33)//32)*32
+            # Note: 32 rather than 31 because result is 1 longer than input.
+            width = ((self.nq+32)//32)*32
             self.q = np.empty(width, dtype=dtype)
             self.q[:self.nq] = q_vectors[0]
@@ -524 +522 @@
         self.dim = '2d' if q_input.is_2d else '1d'
         # plus three for the normalization values
-        self.result = np.empty(q_input.nq+3, dtype)
+        self.result = np.empty(q_input.nq+1, dtype)
 
         # Inputs and outputs for each kernel call

sasmodels/sasview_model.py

@@ -57 +57 @@
     import sas.models
     from sasmodels.conversion_table import CONVERSION_TABLE
-    for new_name, conversion in CONVERSION_TABLE.items():
+    for new_name, conversion in CONVERSION_TABLE.get((3,1,2), {}).items():
         # CoreShellEllipsoidModel => core_shell_ellipsoid:1
         new_name = new_name.split(':')[0]
-        old_name = conversion[0]
+        old_name = conversion[0] if len(conversion) < 3 else conversion[2]
         module_attrs = {old_name: find_model(new_name)}
         ConstructedModule = type(old_name, (), module_attrs)

doc/ref/gpu/gpu_computations.rst

@@ -31 +31 @@
 from available OpenCL platforms.
 
+OpenCL devices can be set from OpenCL options dialog in Fitting menu or as
+enviromental variables.
+
+**If you don't want to use OpenCL, you can select "No OpenCL" option from**
+**GUI dialog or set *SAS_OPENCL=None* in your environment settings**
+**This will only use normal programs.**
+
 SasView prefers AMD or NVIDIA drivers for GPU, and prefers Intel or
 Apple drivers for CPU. Both GPU and CPU are included on the assumption that CPU 
@@ -39 +46 @@
 chose to run the model.
 
-**If you don't want to use OpenCL, you can set** *SAS_OPENCL=None*
-**in your environment settings, and it will only use normal programs.**
-
-If you want to use one of the other devices, you can run the following
-from the python console in SasView::
+If you want to use one of the other devices, you can select it from OpenCL
+options dialog (accessible from Fitting menu) or run the following from
+the python console in SasView::
 
     import pyopencl as cl