Changeset e7724f5 in sasmodels

Timestamp:

Mar 26, 2015 2:45:00 PM (10 years ago)

Author:

Paul Kienzle <pkienzle@…>

Branches:

master, core_shell_microgels, costrafo411, magnetic_model, release_v0.94, release_v0.95, ticket-1257-vesicle-product, ticket_1156, ticket_1265_superball, ticket_822_more_unit_tests

Children:

6ee9d39

Parents:

2c801fe (diff), 42ade62 (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 github.com:sasview/sasmodels

Files:

• example/se008724_01.ses (added)
• sasmodels/exception.py (added)
• sasmodels/kerneldll.py (modified) (2 diffs)
• sasmodels/model_test.py (modified) (1 diff)
• sasmodels/resolution.py (modified) (11 diffs)

sasmodels/kerneldll.py

@@ -17 +17 @@
 from . import generate
 from .kernelpy import PyInput, PyModel
+from .exception import annotate_exception
 
 # Compiler platform details
@@ -145 +146 @@
 
         #print "dll",self.dllpath
-        self.dll = ct.CDLL(self.dllpath)
+        try:
+            self.dll = ct.CDLL(self.dllpath)
+        except Exception, exc:
+            annotate_exception("while loading "+self.dllpath)
+            raise
 
         fp = c_float if self.dtype == generate.F32 else c_double

sasmodels/model_test.py

@@ -51 +51 @@
 from .core import list_models, load_model_definition, load_model, HAVE_OPENCL
 from .core import make_kernel, call_kernel, call_ER, call_VR
-
-
-def annotate_exception(exc, msg):
-    """
-    Add an annotation to the current exception, which can then be forwarded
-    to the caller using a bare "raise" statement to reraise the annotated
-    exception.
-    Example::
-        >>> D = {}
-        >>> try:
-        ...    print D['hello']
-        ... except Exception,exc:
-        ...    annotate_exception(exc, "while accessing 'D'")
-        ...    raise
-        Traceback (most recent call last):
-            ...
-        KeyError: "hello while accessing 'D'"
-    """
-    args = exc.args
-    if not args:
-        exc.args = (msg,)
-    else:
-        try:
-            arg0 = " ".join((args[0],msg))
-            exc.args = tuple([arg0] + list(args[1:]))
-        except:
-            exc.args = (" ".join((str(exc),msg)),)
+from .exception import annotate_exception
 
 

sasmodels/resolution.py

@@ -56 +56 @@
     be estimated from the *q* and *q_width*.
     """
-    def __init__(self, q, q_width, q_calc=None):
+    def __init__(self, q, q_width, q_calc=None, nsigma=3):
         #*min_step* is the minimum point spacing to use when computing the
         #underlying model.  It should be on the order of
@@ -68 +68 @@
         # default to Perfect1D if the pinhole geometry is not defined.
         self.q, self.q_width = q, q_width
-        self.q_calc = pinhole_extend_q(q, q_width) \
+        self.q_calc = pinhole_extend_q(q, q_width, nsigma=nsigma) \
             if q_calc is None else np.sort(q_calc)
         self.weight_matrix = pinhole_resolution(self.q_calc,
@@ -203 +203 @@
     """
     q_min, q_max = np.min(q - nsigma*q_width), np.max(q + nsigma*q_width)
-    return geometric_extrapolation(q, q_min, q_max)
+    return linear_extrapolation(q, q_min, q_max)
 
 
@@ -267 +267 @@
     """
     Extrapolate *q* out to [*q_min*, *q_max*] using the step size in *q* as
-    a guide.  Extrapolation below uses steps the same size as the first
-    interval.  Extrapolation above uses steps the same size as the final
+    a guide.  Extrapolation below uses about the same size as the first
+    interval.  Extrapolation above uses about the same size as the final
     interval.
 
@@ -276 +276 @@
     if q_min < q[0]:
         if q_min <= 0: q_min = q[0]/10
-        delta = q[1] - q[0]
-        q_low = np.arange(q_min, q[0], delta)
+        n_low = np.ceil((q[0]-q_min) / (q[1]-q[0])) if q[1]>q[0] else 15
+        q_low = np.linspace(q_min, q[0], n_low+1)[:-1]
     else:
         q_low = []
     if q_max > q[-1]:
-        delta = q[-1] - q[-2]
-        q_high = np.arange(q[-1]+delta, q_max, delta)
+        n_high = np.ceil((q_max-q[-1]) / (q[-1]-q[-2])) if q[-1]>q[-2] else 15
+        q_high = np.linspace(q[-1], q_max, n_high+1)[1:]
     else:
         q_high = []
@@ -288 +288 @@
 
 
-def geometric_extrapolation(q, q_min, q_max):
+def geometric_extrapolation(q, q_min, q_max, points_per_decade=None):
     r"""
     Extrapolate *q* to [*q_min*, *q_max*] using geometric steps, with the
@@ -295 +295 @@
     if *q_min* is zero or less then *q[0]/10* is used instead.
 
-    Starting at $q_1$ and stepping geometrically by $\Delta q$
-    to $q_n$ in $n$ points gives a geometric average of:
+    *points_per_decade* sets the ratio between consecutive steps such
+    that there will be $n$ points used for every factor of 10 increase
+    in *q*.
+
+    If *points_per_decade* is not given, it will be estimated as follows.
+    Starting at $q_1$ and stepping geometrically by $\Delta q$ to $q_n$
+    in $n$ points gives a geometric average of:
 
     .. math::
@@ -315 +320 @@
     """
     q = np.sort(q)
-    delta_q = (len(q)-1)/(log(q[-1]) - log(q[0]))
+    if points_per_decade is None:
+        log_delta_q = (len(q) - 1) / (log(q[-1]) - log(q[0]))
+    else:
+        log_delta_q = log(10.) / points_per_decade
     if q_min < q[0]:
         if q_min < 0: q_min = q[0]/10
-        n_low = delta_q * (log(q[0])-log(q_min))
+        n_low = log_delta_q * (log(q[0])-log(q_min))
         q_low  = np.logspace(log10(q_min), log10(q[0]), np.ceil(n_low)+1)[:-1]
     else:
         q_low = []
     if q_max > q[-1]:
-        n_high = delta_q * (log(q_max)-log(q[-1]))
+        n_high = log_delta_q * (log(q_max)-log(q[-1]))
         q_high = np.logspace(log10(q[-1]), log10(q_max), np.ceil(n_high)+1)[1:]
     else:
@@ -372 +380 @@
 
 
-def romberg_pinhole_1d(q, q_width, form, pars):
+def romberg_pinhole_1d(q, q_width, form, pars, nsigma=5):
     """
     Romberg integration for pinhole resolution.
@@ -388 +396 @@
 
     _fn = lambda q, q0, dq: eval_form(q, form, pars)*gaussian(q, q0, dq)
-    r = [romberg(_fn, max(qi-5*dqi,0.01*q[0]), qi+5*dqi, args=(qi, dqi),
+    r = [romberg(_fn, max(qi-nsigma*dqi,1e-10*q[0]), qi+nsigma*dqi, args=(qi, dqi),
                  divmax=100, vec_func=True, tol=0, rtol=1e-8)
          for qi,dqi in zip(q,q_width)]
@@ -640 +648 @@
         output = self.Iq_sphere(pars, resolution)
         self.compare(q, output, answer, 1e-6)
-